LXR 6.1/​cpukit/​libtest/​t-test.c	Source navigation Diff markup Identifier search General search
	Version: 6.1 Revert   Change

File indexing completed on 2025-05-11 08:24:21

 /* SPDX-License-Identifier: BSD-2-Clause */
 
 /**
  * @file
  *
  * @ingroup RTEMSTestFrameworkImpl
  *
  * @brief This source file contains the core implementation of RTEMS Test
  *    Framework.
  */
 
 /*
  * Copyright (C) 2018, 2023 embedded brains GmbH & Co. KG
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
  *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
  * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 
 #define _GNU_SOURCE
 
 #include <rtems/test.h>
 
 #include <sys/queue.h>
 #include <limits.h>
 #include <pthread.h>
 #include <sched.h>
 #include <setjmp.h>
 #include <stdatomic.h>
 
 #ifdef __rtems__
 #include <rtems/dev/io.h>
 #include <rtems/score/percpu.h>
 #include <rtems/score/smp.h>
 #include <rtems/score/threadimpl.h>
 #include <rtems/linkersets.h>
 #include <rtems/version.h>
 #else
 #include "t-test-printf.h"
 #endif /* __rtems__ */
 
 #define T_LINE_SIZE 256
 
 typedef struct {
     pthread_spinlock_t lock;
     char *buf;
     unsigned int buf_mask;
     atomic_uint buf_head;
     atomic_uint buf_tail;
     void (*putchar)(int, void *);
     void *putchar_arg;
     T_verbosity verbosity;
     const T_case_context *registered_cases;
     const T_case_context *current_case;
     T_fixture_node *fixtures;
     T_fixture_node case_fixture;
     LIST_HEAD(, T_destructor) destructors;
     T_remark remarks;
     T_time case_begin_time;
     atomic_uint planned_steps;
     atomic_uint steps;
     atomic_uint failures;
     bool case_begin_context_valid;
     jmp_buf case_begin_context;
     unsigned int fixture_steps;
     unsigned int overall_cases;
     unsigned int overall_steps;
     unsigned int overall_failures;
     T_time run_begin_time;
 #ifdef __rtems__
     Thread_Control *runner_thread;
     const Per_CPU_Control *runner_cpu;
 #else
     bool runner_valid;
     pthread_t runner_thread;
 #endif
     const T_config *config;
 } T_context;
 
 static T_context T_instance;
 
 const T_check_context T_special = {
     .file = "*",
     .line = -1,
     .flags = T_CHECK_FMT | T_CHECK_QUIET
 };
 
 static bool
 T_do_is_runner(T_context *ctx)
 {
     bool is_runner;
 #ifdef __rtems__
     ISR_Level level;
     const Per_CPU_Control *cpu_self;
 #endif
 
 #ifdef __rtems__
     _ISR_Local_disable(level);
     cpu_self = _Per_CPU_Get();
 
     if (ctx->runner_thread != NULL) {
         is_runner = cpu_self->isr_nest_level == 0 &&
             _Per_CPU_Get_executing(cpu_self) == ctx->runner_thread;
     } else {
         is_runner = cpu_self == ctx->runner_cpu;
     }
 
     _ISR_Local_enable(level);
 #else
     is_runner = ctx->runner_valid &&
         pthread_equal(pthread_self(), ctx->runner_thread) != 0;
 #endif
 
     return is_runner;
 }
 
 bool T_is_runner(void)
 {
     return T_do_is_runner(&T_instance);
 }
 
 typedef struct {
     char *s;
     size_t n;
 } T_putchar_string_context;
 
 static void
 T_putchar_string(int c, void *arg)
 {
     T_putchar_string_context *sctx;
     char *s;
     size_t n;
 
     sctx = arg;
     s = sctx->s;
     n = sctx->n;
 
     if (n == 1) {
         c = '\0';
     }
 
     if (n > 1) {
         *s = (char)c;
         ++s;
         --n;
     }
 
     sctx->s = s;
     sctx->n = n;
 }
 
 int
 T_snprintf(char *s, size_t n, char const *fmt, ...)
 {
     va_list ap;
     int len;
     T_putchar_string_context sctx = {
         .s = s,
         .n = n
     };
 
     va_start(ap, fmt);
     len = _IO_Vprintf(T_putchar_string, &sctx, fmt, ap);
     va_end(ap);
 
     if (sctx.n > 0) {
         *sctx.s = '\0';
     }
 
     return len;
 }
 
 static void
 T_output_buffer_drain(T_context *ctx)
 {
     unsigned int head;
     unsigned int tail;
 
     head = atomic_load_explicit(&ctx->buf_head, memory_order_acquire);
     tail = atomic_load_explicit(&ctx->buf_tail, memory_order_relaxed);
 
     while (head != tail) {
         (*ctx->putchar)(ctx->buf[tail], ctx->putchar_arg);
         tail = (tail + 1) & ctx->buf_mask;
     }
 
     atomic_store_explicit(&ctx->buf_tail, tail, memory_order_relaxed);
 }
 
 static unsigned int
 T_output_buffer_fill(T_context *ctx, const char *buf, unsigned int len)
 {
     unsigned int head;
     unsigned int tail;
     unsigned int mask;
     unsigned int capacity;
 
     pthread_spin_lock(&ctx->lock);
     head = atomic_load_explicit(&ctx->buf_head, memory_order_relaxed);
     tail = atomic_load_explicit(&ctx->buf_tail, memory_order_relaxed);
     mask = ctx->buf_mask;
     capacity = (tail - head - 1) & mask;
 
     if (len <= capacity) {
         unsigned int todo;
         const char *c;
 
         todo = len;
         c = buf;
 
         while (todo > 0) {
             ctx->buf[head] = *c;
             head = (head + 1) & mask;
             --todo;
             ++c;
         }
 
         atomic_store_explicit(&ctx->buf_head, head,
             memory_order_release);
     } else {
         /* If it does not fit into the buffer, discard everything */
         len = 0;
     }
 
     pthread_spin_unlock(&ctx->lock);
     return len;
 }
 
 static int
 T_vprintf_direct(char const *fmt, va_list ap)
 {
     T_context *ctx;
 
     ctx = &T_instance;
     T_output_buffer_drain(ctx);
     return _IO_Vprintf(ctx->putchar, ctx->putchar_arg, fmt, ap);
 }
 
 static int
 T_vprintf_buffered(char const *fmt, va_list ap)
 {
     char buf[T_LINE_SIZE];
     T_putchar_string_context sctx = {
         .s = buf,
         .n = sizeof(buf)
     };
     unsigned int len;
 
     len = (unsigned int)_IO_Vprintf(T_putchar_string, &sctx, fmt, ap);
 
     if (len >= sizeof(buf)) {
         len = sizeof(buf) - 1;
     }
 
     return (int)T_output_buffer_fill(&T_instance, buf, len);
 }
 
 int
 T_vprintf(char const *fmt, va_list ap)
 {
     int len;
 
     if (T_is_runner()) {
         len = T_vprintf_direct(fmt, ap);
     } else {
         len = T_vprintf_buffered(fmt, ap);
     }
 
     return len;
 }
 
 static int
 T_do_puts(T_context *ctx, const char *buf, size_t len)
 {
     if (T_do_is_runner(ctx)) {
         size_t i;
 
         T_output_buffer_drain(ctx);
 
         for (i = 0; i < len; ++i) {
             (*ctx->putchar)(buf[i], ctx->putchar_arg);
         }
     } else {
         len = T_output_buffer_fill(ctx, buf, len);
     }
 
     return (int)len;
 }
 
 int
 T_puts(const char *buf, size_t len)
 {
     return T_do_puts(&T_instance, buf, len);
 }
 
 static int
 T_cpu(void)
 {
 #if defined(__rtems__)
     return (int)_SMP_Get_current_processor();
 #elif defined(__linux__)
     return sched_getcpu();
 #else
     return 0;
 #endif
 }
 
 size_t
 T_str_copy(char *dst, const char *src, size_t n)
 {
     size_t i;
 
     i = 0;
 
     while (*src != '\0' && i < n) {
         *dst = *src;
         ++dst;
         ++src;
         ++i;
     }
 
     return i;
 }
 
 #if defined(__rtems__)
 static size_t
 T_object_name_to_string(char *dst, Objects_Name name, size_t n)
 {
     uint32_t on;
     size_t i;
     int s;
 
     on = name.name_u32;
     i = 0;
 
     for (s = 24; s >= 0; s -= 8) {
         unsigned char c;
 
         c = (unsigned char)(on >> s);
 
         if (c >= '!' && c <= '~' && i < n) {
             *dst = (char)c;
             ++dst;
             ++i;
         }
     }
 
     return i;
 }
 
 static size_t
 T_thread_name(char *dst, const Thread_Control *th, size_t n)
 {
     if (th != NULL) {
         const char *name;
 
         name = th->Join_queue.Queue.name;
 
         if (name != NULL && name[0] != '\0') {
             return T_str_copy(dst, name, n);
         }
 
         return T_object_name_to_string(dst, th->Object.name, n);
     }
 
     return T_str_copy(dst, "?", n);
 }
 #endif
 
 static size_t
 T_scope(T_context *ctx, char *dst, size_t n)
 {
     T_fixture_node *node;
     size_t len;
 
 #if defined(__rtems__)
     ISR_Level level;
     const Per_CPU_Control *cpu_self;
 
     _ISR_Local_disable(level);
     cpu_self = _Per_CPU_Get();
 
     if (cpu_self->isr_nest_level == 0) {
         Thread_Control *executing;
 
         executing = _Per_CPU_Get_executing(cpu_self);
         _ISR_Local_enable(level);
         len = T_thread_name(dst, executing, n);
     } else {
         _ISR_Local_enable(level);
         len = T_str_copy(dst, "ISR", n);
     }
 
 #elif defined(__linux__)
     static __thread char name[128];
 
     if (name[0] == '\0') {
         pthread_getname_np(pthread_self(), name, sizeof(name));
     }
 
     len = T_str_copy(dst, name, n);
 #else
     len = T_str_copy(dst, "?", n);
 #endif
 
     dst += len;
     n -= len;
     node = &ctx->case_fixture;
 
     do {
         const T_fixture *fixture;
 
         fixture = node->fixture;
 
         if (fixture != NULL && fixture->scope != NULL) {
             size_t m;
 
             m = (*fixture->scope)(node->context, dst, n);
             dst += m;
             n -= m;
             len += m;
         }
 
         node = node->previous;
     } while (node != NULL);
 
     return len;
 }
 
 static void
 T_do_make_runner(T_context *ctx)
 {
 #ifdef __rtems__
     ISR_Level level;
     const Per_CPU_Control *cpu_self;
 
     _ISR_Local_disable(level);
     cpu_self = _Per_CPU_Get();
     ctx->runner_cpu = cpu_self;
 
     if (cpu_self->isr_nest_level == 0) {
         ctx->runner_thread = _Per_CPU_Get_executing(cpu_self);
     } else {
         ctx->runner_thread = NULL;
     }
 
     _ISR_Local_enable(level);
 #else
     ctx->runner_valid = true;
     ctx->runner_thread = pthread_self();
 #endif
 }
 
 void
 T_make_runner(void)
 {
     T_do_make_runner(&T_instance);
 }
 
 int
 T_printf(char const *fmt, ...)
 {
     va_list ap;
     int len;
 
     va_start(ap, fmt);
     len = T_vprintf(fmt, ap);
     va_end(ap);
 
     return len;
 }
 
 void
 T_log(T_verbosity verbosity, char const *fmt, ...)
 {
     T_context *ctx;
 
     ctx = &T_instance;
 
     if (ctx->verbosity >= verbosity) {
         va_list ap;
 
         T_printf("L:");
         va_start(ap, fmt);
         T_vprintf(fmt, ap);
         va_end(ap);
         T_printf("\n");
     }
 }
 
 static unsigned int
 T_fetch_add_step(T_context *ctx)
 {
     return atomic_fetch_add_explicit(&ctx->steps, 1, memory_order_relaxed);
 }
 
 static unsigned int
 T_add_failure(T_context *ctx)
 {
     return atomic_fetch_add_explicit(&ctx->failures, 1,
         memory_order_relaxed);
 }
 
 static void
 T_actions_forward(const T_config *config, T_event event, const char *name)
 {
     const T_action *actions;
     size_t n;
     size_t i;
 
     actions = config->actions;
     n = config->action_count;
 
     for (i = 0; i < n; ++i) {
         (*actions[i])(event, name);
     }
 }
 
 static void
 T_actions_backward(const T_config *config, T_event event,
     const char *name)
 {
     const T_action *actions;
     size_t n;
     size_t i;
 
     actions = config->actions;
     n = config->action_count;
 
     for (i = 0; i < n; ++i) {
         (*actions[n - i - 1])(event, name);
     }
 }
 
 T_NO_RETURN static void
 T_do_stop(T_context *ctx)
 {
     T_fixture_node *node;
 
     node = ctx->fixtures;
 
     while (node != NULL) {
         const T_fixture *fixture;
         void *node_context;
 
         fixture = node->fixture;
         node_context = node->context;
         node = node->next;
 
         if (fixture != NULL && fixture->stop != NULL) {
             (*fixture->stop)(node_context);
         }
     }
 
     if (T_do_is_runner(ctx) && ctx->case_begin_context_valid) {
         longjmp(ctx->case_begin_context, 1);
     } else {
         T_actions_backward(ctx->config, T_EVENT_CASE_STOP,
             T_case_name());
 #ifdef __GNUC__
         __builtin_unreachable();
 #endif
     }
 }
 
 T_NO_RETURN void
 T_stop(void)
 {
     T_do_stop(&T_instance);
 }
 
 void T_plan(unsigned int planned_steps)
 {
     T_context *ctx;
     unsigned int expected;
     bool success;
 
     ctx = &T_instance;
     expected = UINT_MAX;
     success = atomic_compare_exchange_strong_explicit(&ctx->planned_steps,
         &expected, planned_steps, memory_order_relaxed,
         memory_order_relaxed);
     T_check(&T_special, success, "planned steps (%u) already set",
         expected);
 }
 
 const T_fixture T_empty_fixture;
 
 void
 T_push_plan(T_fixture_node *node, unsigned int planned_steps)
 {
     T_push_fixture(node, &T_empty_fixture);
     T_plan(planned_steps);
 }
 
 void
 T_pop_plan(void)
 {
     T_pop_fixture();
 }
 
 void
 T_check_step(const T_check_context *t, unsigned int expected)
 {
     T_check_context tt;
 
     tt = *t;
     tt.flags |= T_CHECK_STEP(expected);
     T_check(&tt, true, "actual step is not equal to expected step (%u)",
         expected);
 }
 
 void
 T_case_register(T_case_context *tc)
 {
     T_context *ctx;
 
     ctx = &T_instance;
     tc->next = ctx->registered_cases;
     ctx->registered_cases = tc;
 }
 
 T_verbosity
 T_set_verbosity(T_verbosity verbosity)
 {
     T_context *ctx;
     T_verbosity previous;
 
     ctx = &T_instance;
     previous = ctx->verbosity;
     ctx->verbosity = verbosity;
 
     return previous;
 }
 
 void *
 T_fixture_context(void)
 {
     return T_instance.fixtures->context;
 }
 
 void
 T_set_fixture_context(void *context)
 {
     T_instance.fixtures->context = context;
 }
 
 const char *
 T_case_name(void)
 {
     const T_case_context *tc;
 
     tc = T_instance.current_case;
 
     if (tc != NULL) {
         return tc->name;
     } else {
         return "?";
     }
 }
 
 static const char *
 T_file(const T_check_context *t)
 {
     const char *file;
 
     file = strrchr(t->file, '/');
 
     if (file == NULL) {
         return t->file;
     }
 
     return file + 1;
 }
 
 static const char T_planned_step_fmt[] = "planned step (%u)";
 
 static void
 T_check_putc(int c, void *arg)
 {
     T_putchar_string_context *sctx;
     size_t n;
 
     sctx = arg;
     n = sctx->n;
 
     if (n > 0) {
         char *s;
 
         s = sctx->s;
         *s = (char)c;
         sctx->s = s + 1;
         sctx->n = n - 1;
     }
 }
 
 static void
 T_check_print_steps(T_context *ctx, T_putchar_string_context *sctx,
     unsigned int step)
 {
     T_fixture_node *node;
 
     node = &ctx->case_fixture;
 
     while (true) {
         node = node->previous;
 
         if (node != NULL) {
             _IO_Printf(T_check_putc, sctx, "%u.",
                 node->next_steps);
         } else {
             break;
         }
     }
 
     if (step != UINT_MAX) {
         _IO_Printf(T_check_putc, sctx, "%u", step);
     } else {
         T_check_putc('*', sctx);
     }
 }
 
 void
 T_check(const T_check_context *t, bool ok, ...)
 {
     T_context *ctx;
     va_list ap;
     char line[T_LINE_SIZE];
     unsigned int step;
     int line_number;
     const char *fmt;
 
     ctx = &T_instance;
 
     if ((t->flags & T_CHECK_QUIET) == 0) {
         step = T_fetch_add_step(ctx);
     } else {
         step = UINT_MAX;
     }
 
     va_start(ap, ok);
     line[0] = '\0';
     line_number = -1;
     fmt = NULL;
 
     if ((t->flags & T_CHECK_STEP_FLAG) != 0 &&
          step != T_CHECK_STEP_FROM_FLAGS(t->flags)) {
         T_add_failure(ctx);
         line[0] = 'F';
         line_number = t->line;
         fmt = T_planned_step_fmt;
     } else if (!ok) {
         T_add_failure(ctx);
 
         if (ctx->verbosity >= T_NORMAL) {
             line[0] = 'F';
             line_number = t->line;
 
             if ((t->flags & T_CHECK_FMT) != 0) {
                 fmt = va_arg(ap, const char *);
             }
         }
     } else if ((t->flags & T_CHECK_QUIET) == 0 &&
         ctx->verbosity >= T_VERBOSE) {
         line[0] = 'P';
         line_number = t->line;
     }
 
     if (line[0] != '\0') {
         T_putchar_string_context sctx;
         size_t chunk;
 
         sctx.n = sizeof(line) - 1;
         sctx.s = &line[1];
         T_check_putc(':', &sctx);
         T_check_print_steps(ctx, &sctx, step);
         _IO_Printf(T_check_putc, &sctx, ":%i:", T_cpu());
         chunk = T_scope(ctx, sctx.s, sctx.n);
         sctx.s += chunk;
         sctx.n -= chunk;
         T_check_putc(':', &sctx);
         chunk = T_str_copy(sctx.s, T_file(t), sctx.n);
         sctx.s += chunk;
         sctx.n -= chunk;
         T_check_putc(':', &sctx);
 
         if (line_number >= 0) {
             _IO_Printf(T_check_putc, &sctx, "%i", line_number);
         } else {
             T_check_putc('*', &sctx);
         }
 
         if (fmt != NULL) {
             if (fmt == T_planned_step_fmt) {
                 T_check_putc(':', &sctx);
                 _IO_Printf(T_check_putc, &sctx, fmt,
                     T_CHECK_STEP_FROM_FLAGS(t->flags));
             } else {
                 T_check_putc(':', &sctx);
                 _IO_Vprintf(T_check_putc, &sctx, fmt, ap);
             }
         }
 
         T_check_putc('\n', &sctx);
         line[sizeof(line) - 1] = '\n';
         T_puts(&line[0], sizeof(line) - sctx.n);
     }
 
     if (!ok && (t->flags & T_CHECK_STOP) != 0) {
         T_do_stop(ctx);
     }
 
     va_end(ap);
 }
 
 static void
 T_do_log(T_context *ctx, T_verbosity verbosity, char const *fmt, ...)
 {
     if (ctx->verbosity >= verbosity) {
         va_list ap;
 
         va_start(ap, fmt);
         T_vprintf(fmt, ap);
         va_end(ap);
     }
 }
 
 static void
 T_system(T_context *ctx)
 {
 #if defined(__rtems__)
     T_do_log(ctx, T_QUIET, "S:Platform:RTEMS\n");
     T_do_log(ctx, T_QUIET, "S:Compiler:" __VERSION__ "\n");
     T_do_log(ctx, T_QUIET, "S:Version:%s\n", rtems_version());
     T_do_log(ctx, T_QUIET, "S:BSP:%s\n", rtems_board_support_package());
     T_do_log(ctx, T_QUIET, "S:BuildLabel:%s\n", rtems_get_build_label());
     T_do_log(ctx, T_QUIET, "S:TargetHash:SHA256:%s\n",
         rtems_get_target_hash());
 #if RTEMS_DEBUG
     T_do_log(ctx, T_QUIET, "S:RTEMS_DEBUG:1\n");
 #else
     T_do_log(ctx, T_QUIET, "S:RTEMS_DEBUG:0\n");
 #endif
 #if RTEMS_MULTIPROCESSING
     T_do_log(ctx, T_QUIET, "S:RTEMS_MULTIPROCESSING:1\n");
 #else
     T_do_log(ctx, T_QUIET, "S:RTEMS_MULTIPROCESSING:0\n");
 #endif
 #if RTEMS_POSIX_API
     T_do_log(ctx, T_QUIET, "S:RTEMS_POSIX_API:1\n");
 #else
     T_do_log(ctx, T_QUIET, "S:RTEMS_POSIX_API:0\n");
 #endif
 #if RTEMS_PROFILING
     T_do_log(ctx, T_QUIET, "S:RTEMS_PROFILING:1\n");
 #else
     T_do_log(ctx, T_QUIET, "S:RTEMS_PROFILING:0\n");
 #endif
 #if RTEMS_SMP
     T_do_log(ctx, T_QUIET, "S:RTEMS_SMP:1\n");
 #else
     T_do_log(ctx, T_QUIET, "S:RTEMS_SMP:0\n");
 #endif
 #elif defined(__linux__)
     T_do_log(ctx, T_QUIET, "S:Platform:Linux\n");
     T_do_log(ctx, T_QUIET, "S:Compiler:" __VERSION__ "\n");
 #else
     T_do_log(ctx, T_QUIET, "S:Platform:POSIX\n");
 #ifdef __VERSION__
     T_do_log(ctx, T_QUIET, "S:Compiler:" __VERSION__ "\n");
 #endif
 #endif
 }
 
 void
 T_add_destructor(T_destructor *dtor, void (*destroy)(T_destructor *))
 {
     T_context *ctx;
 
     dtor->destroy = destroy;
     ctx = &T_instance;
     pthread_spin_lock(&ctx->lock);
     LIST_INSERT_HEAD(&ctx->destructors, dtor, node);
     pthread_spin_unlock(&ctx->lock);
 }
 
 void
 T_remove_destructor(T_destructor *dtor)
 {
     T_context *ctx;
 
     ctx = &T_instance;
     pthread_spin_lock(&ctx->lock);
     LIST_REMOVE(dtor, node);
     pthread_spin_unlock(&ctx->lock);
 }
 
 static void
 T_call_destructors(const T_context *ctx)
 {
     T_destructor *dtor;
 
 #ifdef __linux__
     while (!LIST_EMPTY(&ctx->destructors)) {
         dtor = LIST_FIRST(&ctx->destructors);
         LIST_REMOVE(dtor, node);
         (*dtor->destroy)(dtor);
     }
 #else
     T_destructor *tmp;
 
     LIST_FOREACH_SAFE(dtor, &ctx->destructors, node, tmp) {
         (*dtor->destroy)(dtor);
     }
 #endif
 }
 
 static void
 T_make_remarks(T_context *ctx)
 {
     T_remark *remark;
 
     remark = ctx->remarks.next;
 
     while (remark != &ctx->remarks) {
         T_remark *current;
 
         current = remark;
         remark = current->next;
         current->next = NULL;
         T_do_log(ctx, T_QUIET, "R:%s\n", current->remark);
     }
 }
 
 static T_context *
 T_do_run_initialize(const T_config *config)
 {
     T_context *ctx;
 
     ctx = &T_instance;
 
     pthread_spin_init(&ctx->lock, PTHREAD_PROCESS_PRIVATE);
 
     ctx->config = config;
     ctx->buf = config->buf;
 
     if (config->buf_size > 0 &&
         (config->buf_size & (config->buf_size - 1)) == 0) {
         ctx->buf_mask = config->buf_size - 1;
     } else {
         ctx->buf_mask = 0;
     }
 
     ctx->fixtures = &ctx->case_fixture;
     atomic_store_explicit(&ctx->buf_head, 0, memory_order_relaxed);
     ctx->buf_tail = 0;
     ctx->putchar = config->putchar;
     ctx->putchar_arg = config->putchar_arg;
     ctx->verbosity = config->verbosity;
     ctx->overall_cases = 0;
     ctx->overall_steps = 0;
     ctx->overall_failures = 0;
 
     T_do_make_runner(ctx);
     T_actions_forward(config, T_EVENT_RUN_INITIALIZE_EARLY, config->name);
     T_do_log(ctx, T_QUIET, "A:%s\n", config->name);
     T_system(ctx);
     ctx->run_begin_time = (*config->now)();
     T_actions_forward(config, T_EVENT_RUN_INITIALIZE_LATE, config->name);
 
     return ctx;
 }
 
 static void
 T_do_case_begin(T_context *ctx, const T_case_context *tc)
 {
     const T_config *config;
     const T_fixture *fixture;
 
     config = ctx->config;
     fixture = tc->fixture;
     ctx->verbosity = config->verbosity;
     ctx->current_case = tc;
     ctx->fixtures = &ctx->case_fixture;
     LIST_INIT(&ctx->destructors);
     ctx->remarks.next = &ctx->remarks;
     atomic_store_explicit(&ctx->planned_steps, UINT_MAX,
         memory_order_relaxed);
     atomic_store_explicit(&ctx->steps, 0, memory_order_relaxed);
     atomic_store_explicit(&ctx->failures, 0, memory_order_relaxed);
     ctx->fixture_steps = 0;
 
     T_actions_forward(config, T_EVENT_CASE_EARLY, tc->name);
     T_do_log(ctx, T_NORMAL, "B:%s\n", tc->name);
     ctx->case_begin_time = (*config->now)();
     T_actions_forward(config, T_EVENT_CASE_BEGIN, tc->name);
 
     if (fixture != NULL) {
         ctx->case_fixture.fixture = fixture;
         ctx->case_fixture.context = fixture->initial_context;
 
         if (fixture->setup != NULL) {
             (*fixture->setup)(ctx->case_fixture.context);
         }
     }
 }
 
 static void
 T_check_steps(unsigned int planned_steps, unsigned int steps,
     unsigned int failures)
 {
     if (planned_steps != UINT_MAX && planned_steps != steps &&
         failures == 0) {
         T_check(&T_special, false, "actual steps (%u), "
             "planned steps (%u)", steps, planned_steps);
     }
 }
 
 static void T_do_pop_fixture(T_context *);
 
 static void
 T_do_case_end(T_context *ctx, const T_case_context *tc)
 {
     const T_config *config;
     unsigned int planned_steps;
     unsigned int steps;
     unsigned int failures;
     T_time delta;
     T_time_string ts;
 
     while (ctx->fixtures != NULL) {
         T_do_pop_fixture(ctx);
     }
 
     T_call_destructors(ctx);
     config = ctx->config;
     T_actions_backward(config, T_EVENT_CASE_END, tc->name);
     T_make_remarks(ctx);
 
     planned_steps = atomic_fetch_add_explicit(&ctx->planned_steps,
         0, memory_order_relaxed);
     steps = atomic_fetch_add_explicit(&ctx->steps, 0,
         memory_order_relaxed);
     failures = atomic_fetch_add_explicit(&ctx->failures, 0,
         memory_order_relaxed);
     T_check_steps(planned_steps, steps, failures);
 
     failures = atomic_load_explicit(&ctx->failures, memory_order_relaxed);
     delta = (*config->now)() - ctx->case_begin_time;
     steps += ctx->fixture_steps;
     T_do_log(ctx, T_QUIET, "E:%s:N:%u:F:%u:D:%s\n",
         tc->name, steps, failures, T_time_to_string_us(delta, ts));
 
     ++ctx->overall_cases;
     ctx->overall_steps += steps;
     ctx->overall_failures += failures;
 
     T_actions_backward(config, T_EVENT_CASE_LATE, tc->name);
 }
 
 static void
 T_run_case(T_context *ctx, const T_case_context *tc)
 {
     if (setjmp(ctx->case_begin_context) == 0) {
         ctx->case_begin_context_valid = true;
         T_do_case_begin(ctx, tc);
         (*tc->body)();
     }
 
     ctx->case_begin_context_valid = false;
     T_do_case_end(ctx, tc);
 }
 
 static void
 T_do_run_all(T_context *ctx)
 {
     const T_case_context *tc;
 
     tc = ctx->registered_cases;
 
     while (tc != NULL) {
         T_run_case(ctx, tc);
         tc = tc->next;
     }
 }
 
 static bool
 T_do_run_finalize(T_context *ctx)
 {
     const T_config *config;
     T_time delta;
     T_time_string ts;
 
     config = ctx->config;
     T_actions_backward(config, T_EVENT_RUN_FINALIZE_EARLY, config->name);
     delta = (*config->now)() - ctx->run_begin_time;
     T_do_log(ctx, T_QUIET, "Z:%s:C:%u:N:%u:F:%u:D:%s\n", config->name,
         ctx->overall_cases, ctx->overall_steps, ctx->overall_failures,
         T_time_to_string_us(delta, ts));
     T_actions_backward(config, T_EVENT_RUN_FINALIZE_LATE, config->name);
 #ifdef __rtems__
     ctx->runner_thread = NULL;
     ctx->runner_cpu = NULL;
 #else
     ctx->runner_valid = false;
 #endif
     pthread_spin_destroy(&ctx->lock);
 
     return ctx->overall_failures == 0;
 }
 
 int
 T_main(const T_config *config)
 {
     T_context *ctx;
 
     ctx = T_do_run_initialize(config);
     T_do_run_all(ctx);
 
     return T_do_run_finalize(ctx) ? 0 : 1;
 }
 
 #ifdef __rtems__
 RTEMS_LINKER_ROSET(_T, T_case_context *);
 #endif /* __rtems__ */
 
 void T_register(void)
 {
 #ifdef __rtems__
     T_case_context * const *tc;
 
     RTEMS_LINKER_SET_FOREACH(_T, tc) {
         T_case_register(*tc);
     }
 #endif /* __rtems__ */
 }
 
 void
 T_run_initialize(const T_config *config)
 {
     (void)T_do_run_initialize(config);
 }
 
 void
 T_run_all(void)
 {
     T_do_run_all(&T_instance);
 }
 
 void
 T_run_by_name(const char *name)
 {
     T_context *ctx;
     const T_case_context *tc;
 
     ctx = &T_instance;
     tc = ctx->registered_cases;
 
     while (tc != NULL) {
         if (strcmp(tc->name, name) == 0) {
             T_run_case(ctx, tc);
             break;
         }
 
         tc = tc->next;
     }
 }
 
 static T_case_context default_case;
 
 void *
 T_case_begin(const char *name, const T_fixture *fixture)
 {
     T_case_context *tc;
 
     tc = &default_case;
     tc->name = name;
     tc->fixture = fixture;
     T_do_case_begin(&T_instance, tc);
     return T_instance.case_fixture.context;
 }
 
 void
 T_case_end(void)
 {
     T_case_context *tc;
 
     tc = &default_case;
     T_do_case_end(&T_instance, tc);
 }
 
 bool
 T_run_finalize(void)
 {
     return T_do_run_finalize(&T_instance);
 }
 
 T_time
 T_case_begin_time(void)
 {
     return T_instance.case_begin_time;
 }
 
 void
 T_set_putchar(T_putchar new_putchar, void *new_arg, T_putchar *old_putchar,
     void **old_arg)
 {
     T_context *ctx;
 
     ctx = &T_instance;
     *old_putchar = ctx->putchar;
     *old_arg = ctx->putchar_arg;
     ctx->putchar = new_putchar;
     ctx->putchar_arg = new_arg;
 }
 
 T_time
 T_now(void)
 {
     T_context *ctx;
     const T_config *config;
 
     ctx = &T_instance;
     config = ctx->config;
     return (*config->now)();
 }
 
 void *
 T_push_fixture(T_fixture_node *node, const T_fixture *fixture)
 {
     T_context *ctx;
     T_fixture_node *old;
     void *context;
 
     ctx = &T_instance;
     old = ctx->fixtures;
     old->previous = node;
     node->next = old;
     node->previous = NULL;
     node->fixture = fixture;
     context = fixture->initial_context;
     node->context = context;
     node->next_planned_steps = atomic_exchange_explicit(
         &ctx->planned_steps, UINT_MAX, memory_order_relaxed);
     node->next_steps = atomic_exchange_explicit(&ctx->steps, 0,
         memory_order_relaxed);
     node->failures = atomic_fetch_add_explicit(&ctx->failures, 0,
         memory_order_relaxed);
     ctx->fixtures = node;
 
     if (fixture->setup != NULL) {
         (*fixture->setup)(context);
     }
 
     return context;
 }
 
 static void
 T_do_pop_fixture(T_context *ctx)
 {
     T_fixture_node *node;
     const T_fixture *fixture;
     T_fixture_node *next;
 
     node = ctx->fixtures;
     next = node->next;
     ctx->fixtures = next;
     fixture = node->fixture;
 
     if (fixture != NULL && fixture->teardown != NULL) {
         (*fixture->teardown)(node->context);
     }
 
     if (next != NULL) {
         unsigned int planned_steps;
         unsigned int steps;
         unsigned int failures;
 
         next->previous = NULL;
         planned_steps = atomic_exchange_explicit(&ctx->planned_steps,
             node->next_planned_steps, memory_order_relaxed);
         steps = atomic_exchange_explicit(&ctx->steps, node->next_steps,
             memory_order_relaxed);
         failures = atomic_fetch_add_explicit(&ctx->failures, 0,
             memory_order_relaxed);
         ctx->fixture_steps += steps;
         T_check_steps(planned_steps, steps, node->failures - failures);
     }
 
     memset(node, 0, sizeof(*node));
 }
 
 void
 T_pop_fixture(void)
 {
     T_do_pop_fixture(&T_instance);
 }
 
 void
 T_add_remark(T_remark *remark)
 {
     if (remark->next == NULL) {
         T_context *ctx;
 
         ctx = &T_instance;
         remark->next = ctx->remarks.next;
         ctx->remarks.next = remark;
     }
 }
 
 size_t
 T_get_scope(const char * const * const *desc, char *buf, size_t n,
     const size_t *second_indices)
 {
     size_t c;
     size_t i;
 
     c = n;
     i = 0;
 
     while (true) {
         const char * const *desc2;
         size_t m;
 
         desc2 = desc[i];
 
         if (desc2 == NULL) {
             break;
         }
 
         if (c > 1) {
             buf[0] = '/';
             --c;
             ++buf;
         } else {
             break;
         }
 
         m = T_str_copy(buf, desc2[second_indices[i]], c);
         buf += m;
         c -= m;
         ++i;
     }
 
     return n - c;
 }
 
 #ifdef __BIGGEST_ALIGNMENT__
 #define T_BIGGEST_ALIGNMENT __BIGGEST_ALIGNMENT__
 #else
 #define T_BIGGEST_ALIGNMENT sizeof(long long)
 #endif
 
 typedef struct __attribute__((__aligned__(T_BIGGEST_ALIGNMENT))) {
     T_destructor base;
     void (*destroy)(void *);
 } T_malloc_destructor;
 
 static void
 T_malloc_destroy(T_destructor *base)
 {
     T_malloc_destructor *dtor;
 
     dtor = (T_malloc_destructor *)(uintptr_t)base;
 
     if (dtor->destroy != NULL) {
         (*dtor->destroy)(dtor + 1);
     }
 
     (*T_instance.config->deallocate)(dtor);
 }
 
 static void *
 T_do_malloc(size_t size, void (*destroy)(void *))
 {
     T_malloc_destructor *dtor;
     size_t new_size;
 
     new_size = sizeof(*dtor) + size;
     if (new_size <= size) {
         return NULL;
     }
 
     if (T_instance.config->allocate == NULL) {
         return NULL;
     }
 
     dtor = (*T_instance.config->allocate)(new_size);
     if (dtor != NULL) {
         dtor->destroy = destroy;
         T_add_destructor(&dtor->base, T_malloc_destroy);
         ++dtor;
     }
 
     return dtor;
 }
 
 void *
 T_malloc(size_t size)
 {
     return T_do_malloc(size, NULL);
 }
 
 void *
 T_calloc(size_t nelem, size_t elsize)
 {
     return T_zalloc(nelem * elsize, NULL);
 }
 
 void *
 T_zalloc(size_t size, void (*destroy)(void *))
 {
     void *p;
 
     p = T_do_malloc(size, destroy);
     if (p != NULL) {
         p = memset(p, 0, size);
     }
 
     return p;
 }
 
 void
 T_free(void *ptr)
 {
     T_malloc_destructor *dtor;
 
     dtor = ptr;
     --dtor;
     T_remove_destructor(&dtor->base);
     (*T_instance.config->deallocate)(dtor);
 }

This page was automatically generated by the 2.3.7 LXR engine. The LXR team