| // Copyright 2016 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <stddef.h> |
| #include <stdint.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <sys/time.h> |
| |
| #include <pretty/hexdump.h> |
| #include <unittest/unittest.h> |
| |
| #ifdef UNITTEST_DEATH_TEST_SUPPORTED |
| |
| #include <lib/test-exceptions/exception-handling.h> |
| #include <lib/zx/channel.h> |
| #include <lib/zx/exception.h> |
| #include <lib/zx/port.h> |
| #include <lib/zx/thread.h> |
| #include <threads.h> |
| #include <zircon/assert.h> |
| #include <zircon/status.h> |
| #include <zircon/syscalls/exception.h> |
| #include <zircon/syscalls/port.h> |
| |
| #endif // UNITTEST_DEATH_TEST_SUPPORTED |
| |
| #include "watchdog.h" |
| |
| // Some strings that are used for comparison purposes can be pretty long, and |
| // when printing the failure message it's important to see what the failing |
| // text is. That's why this is as large as it is. |
| #define PRINT_BUFFER_SIZE (4096) |
| |
| using nsecs_t = uint64_t; |
| |
| static nsecs_t now() { |
| #ifdef __Fuchsia__ |
| return zx_clock_get_monotonic(); |
| #else |
| // clock_gettime(CLOCK_MONOTONIC) would be better but may not exist on the host |
| struct timeval tv; |
| if (gettimeofday(&tv, nullptr) < 0) |
| return 0u; |
| return tv.tv_sec * 1000000000ull + tv.tv_usec * 1000ull; |
| #endif |
| } |
| |
| /** |
| * \brief Default function to dump unit test results |
| * |
| * \param[in] line is the buffer to dump |
| * \param[in] len is the length of the buffer to dump |
| * \param[in] arg can be any kind of arguments needed to dump the values |
| */ |
| static void default_printf(const char* line, int len, void* arg) { |
| fputs(line, stdout); |
| fflush(stdout); |
| } |
| |
| // Default output function is the printf |
| static test_output_func out_func = default_printf; |
| // Buffer the argument to be sent to the output function |
| static void* out_func_arg = nullptr; |
| |
| // Controls the behavior of unittest_printf. |
| // To override, specify v=N on the command line. |
| __EXPORT |
| int utest_verbosity_level = 0; |
| |
| // Controls the types of tests which are executed. |
| // Multiple test types can be "OR-ed" together to |
| // run a subset of all tests. |
| __EXPORT |
| test_type_t utest_test_type = static_cast<test_type>(TEST_DEFAULT); |
| |
| /** |
| * \brief Function called to dump results |
| * |
| * This function will call the out_func callback |
| */ |
| __EXPORT |
| void unittest_printf_critical(const char* format, ...) { |
| static char print_buffer[PRINT_BUFFER_SIZE]; |
| |
| va_list argp; |
| va_start(argp, format); |
| |
| if (out_func) { |
| // Format the string |
| vsnprintf(print_buffer, PRINT_BUFFER_SIZE, format, argp); |
| out_func(print_buffer, PRINT_BUFFER_SIZE, out_func_arg); |
| } |
| |
| va_end(argp); |
| } |
| |
| __EXPORT |
| bool unittest_expect_bytes_eq(const uint8_t* expected, const uint8_t* actual, size_t len, |
| const char* msg) { |
| if (memcmp(expected, actual, len)) { |
| printf("%s. expected\n", msg); |
| hexdump8(expected, len); |
| printf("actual\n"); |
| hexdump8(actual, len); |
| return false; |
| } |
| return true; |
| } |
| |
| __EXPORT |
| bool unittest_expect_str_eq(const char* str1_value, const char* str2_value, const char* str1_expr, |
| const char* str2_expr, const char* msg, const char* source_filename, |
| int source_line_num, const char* source_function) { |
| if (strcmp(str1_value, str2_value)) { |
| unittest_printf_critical(UNITTEST_FAIL_TRACEF_FORMAT |
| "%s:\n" |
| " Comparison failed: strings not equal:\n" |
| " String 1 expression: %s\n" |
| " String 2 expression: %s\n" |
| " String 1 value: \"%s\"\n" |
| " String 2 value: \"%s\"\n", |
| source_filename, source_line_num, source_function, msg, str1_expr, |
| str2_expr, str1_value, str2_value); |
| return false; |
| } |
| return true; |
| } |
| |
| __EXPORT |
| bool unittest_expect_str_ne(const char* str1_value, const char* str2_value, const char* str1_expr, |
| const char* str2_expr, const char* msg, const char* source_filename, |
| int source_line_num, const char* source_function) { |
| if (!strcmp(str1_value, str2_value)) { |
| unittest_printf_critical(UNITTEST_FAIL_TRACEF_FORMAT |
| "%s:\n" |
| " Comparison failed: strings are equal," |
| " but expected different strings:\n" |
| " String 1 expression: %s\n" |
| " String 2 expression: %s\n" |
| " Value of both strings: \"%s\"\n", |
| source_filename, source_line_num, source_function, msg, str1_expr, |
| str2_expr, str1_value); |
| return false; |
| } |
| return true; |
| } |
| |
| __EXPORT |
| bool unittest_expect_str_str(const char* str1_value, const char* str2_value, const char* str1_expr, |
| const char* str2_expr, const char* msg, const char* source_filename, |
| int source_line_num, const char* source_function) { |
| if (!strstr(str1_value, str2_value)) { |
| unittest_printf_critical(UNITTEST_FAIL_TRACEF_FORMAT |
| "%s:\n" |
| " Comparison failed: String 1 does not" |
| " contain String 2:\n" |
| " String 1 expression: %s\n" |
| " String 2 expression: %s\n" |
| " Value of both strings: \"%s\"\n", |
| source_filename, source_line_num, source_function, msg, str1_expr, |
| str2_expr, str1_value); |
| return false; |
| } |
| return true; |
| } |
| |
| __EXPORT |
| void unittest_set_output_function(test_output_func fun, void* arg) { |
| out_func = fun; |
| out_func_arg = arg; |
| } |
| |
| __EXPORT |
| void unittest_restore_output_function() { |
| out_func = default_printf; |
| out_func_arg = nullptr; |
| } |
| |
| __EXPORT |
| int unittest_set_verbosity_level(int new_level) { |
| int out = utest_verbosity_level; |
| utest_verbosity_level = new_level; |
| return out; |
| } |
| |
| #ifdef UNITTEST_DEATH_TEST_SUPPORTED |
| |
| namespace { |
| |
| enum { kPortKeyThreadException, kPortKeyThreadCompleted }; |
| |
| // All the state that's necessary to share between the main unittest thread |
| // and the death thread. |
| struct RunDeathFunctionState { |
| // The death function to call and argument to pass it. |
| void (*fn_to_run)(void*); |
| void* arg; |
| |
| // The port to register the exception channel on. |
| zx::port port; |
| |
| // Thread and channel are filled in by RunDeathFunction(). |
| zx::thread zx_thread; |
| zx::channel exception_channel; |
| }; |
| |
| // Sets up the necessary state and calls |fn_to_run|. |
| // |
| // Basic flow is: |
| // 1. Creates the exception channel. |
| // 2. Registers the port for exceptions or thread completion. |
| // 3. Calls the death function |
| // |
| // Returns: |
| // ZX_OK if the death function did not hit an exception. |
| // Non-OK if setup failed. |
| // Does not return if the death function hit an exception. |
| int RunDeathFunction(void* arg) { |
| RunDeathFunctionState* state = reinterpret_cast<RunDeathFunctionState*>(arg); |
| |
| // The caller needs a thread handle to kill if it hits an exception. This has |
| // to be a full handle (i.e. not unowned_thread) or else it might be destroyed |
| // and unregistered from the port wait before we get the signal. |
| if (zx_status_t status = zx::thread::self()->duplicate(ZX_RIGHT_SAME_RIGHTS, &state->zx_thread); |
| status != ZX_OK) { |
| unittest_printf_critical("failed to duplicate thread handle: %s\n", |
| zx_status_get_string(status)); |
| return status; |
| } |
| |
| // Register for thread completion signal on the port. |
| if (zx_status_t status = state->zx_thread.wait_async(state->port, kPortKeyThreadCompleted, |
| ZX_THREAD_TERMINATED, 0); |
| status != ZX_OK) { |
| unittest_printf_critical("failed to wait_async on thread: %s\n", zx_status_get_string(status)); |
| return status; |
| } |
| |
| // We have to create the exception channel here, since we don't have access |
| // to the thread handle until we're in the thread. |
| if (zx_status_t status = state->zx_thread.create_exception_channel(0, &state->exception_channel); |
| status != ZX_OK) { |
| unittest_printf_critical("failed to create exception channel: %s\n", |
| zx_status_get_string(status)); |
| return status; |
| } |
| |
| // Register for exception signal on the port. |
| if (zx_status_t status = state->exception_channel.wait_async(state->port, kPortKeyThreadException, |
| ZX_CHANNEL_READABLE, 0); |
| status != ZX_OK) { |
| unittest_printf_critical("failed to wait_async on exception channel: %s\n", |
| zx_status_get_string(status)); |
| return status; |
| } |
| |
| state->fn_to_run(state->arg); |
| return ZX_OK; |
| } |
| |
| } // namespace |
| |
| __EXPORT |
| death_test_result_t unittest_run_death_fn(void (*fn_to_run)(void*), void* arg) { |
| RunDeathFunctionState state; |
| state.fn_to_run = fn_to_run; |
| state.arg = arg; |
| |
| if (zx_status_t status = zx::port::create(0, &state.port); status != ZX_OK) { |
| unittest_printf_critical("failed to create port: %s\n", zx_status_get_string(status)); |
| return DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| |
| // We intentionally use C thread APIs rather than std::thread to avoid |
| // leaking memory. The thread still doesn't get fully cleaned up (see notes |
| // below) but the C APIs at least allow us to pass on the LSAN build. |
| thrd_t thread; |
| if (int result = thrd_create(&thread, RunDeathFunction, &state); result != thrd_success) { |
| unittest_printf_critical("failed to create thread: thrd code %d\n", result); |
| return DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| |
| // Wait for either thread exception or normal completion. |
| zx_port_packet_t packet; |
| if (zx_status_t status = state.port.wait(zx::time::infinite(), &packet); status != ZX_OK) { |
| unittest_printf_critical("failed to wait on port: %s\n", zx_status_get_string(status)); |
| return DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| |
| if (packet.key == kPortKeyThreadCompleted) { |
| // The thread returned, either due to setup failure or no death. |
| int thread_exit_code; |
| if (int result = thrd_join(thread, &thread_exit_code); result != thrd_success) { |
| unittest_printf_critical("failed to join thread: thrd code %d\n", result); |
| return DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| return thread_exit_code == ZX_OK ? DEATH_TEST_RESULT_LIVED : DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| |
| zx_exception_info_t info; |
| zx::exception exception; |
| zx_status_t status = state.exception_channel.read(0, &info, exception.reset_and_get_address(), |
| sizeof(info), 1, nullptr, nullptr); |
| if (status != ZX_OK) { |
| unittest_printf_critical("Failed to read exception: %d\n", status); |
| return DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| |
| // This causes the thread to exit via thrd_exit. It's impossible to to fully clean |
| // up a thread that has hit an exception however and there are likely small leaks. |
| status = test_exceptions::ExitExceptionCThread(std::move(exception)); |
| if (status != ZX_OK) { |
| unittest_printf_critical("Failed to exit the exception thread: %d\n", status); |
| return DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| |
| // Check that the thrd exited successfully. |
| int thread_exit_code; |
| if (int result = thrd_join(thread, &thread_exit_code); result != thrd_success) { |
| unittest_printf_critical("failed to join exception thread: thrd code %d\n", result); |
| return DEATH_TEST_RESULT_INTERNAL_ERROR; |
| } |
| |
| return DEATH_TEST_RESULT_DIED; |
| } |
| |
| #endif // UNITTEST_DEATH_TEST_SUPPORTED |
| |
| static void unittest_run_test(const char* name, bool (*test)(), |
| struct test_info** current_test_info, bool* all_success) { |
| unittest_printf_critical(" %-51s [RUNNING]", name); |
| nsecs_t start_time = now(); |
| test_info test_info = {.all_ok = true, nullptr}; |
| *current_test_info = &test_info; |
| if (!test()) { |
| test_info.all_ok = false; |
| *all_success = false; |
| } |
| |
| nsecs_t end_time = now(); |
| uint64_t time_taken_ms = (end_time - start_time) / 1000000; |
| unittest_printf_critical(" [%s] (%d ms)\n", test_info.all_ok ? "PASSED" : "FAILED", |
| static_cast<int>(time_taken_ms)); |
| |
| *current_test_info = nullptr; |
| } |
| |
| template <typename F> |
| void run_with_watchdog(test_type_t test_type, const char* name, F fn) { |
| if (watchdog_is_enabled()) { |
| watchdog_start(test_type, name); |
| fn(); |
| watchdog_cancel(); |
| } else { |
| fn(); |
| } |
| } |
| |
| __EXPORT |
| void unittest_run_named_test(const char* name, bool (*test)(), test_type_t test_type, |
| struct test_info** current_test_info, bool* all_success) { |
| if (utest_test_type & test_type) { |
| run_with_watchdog(test_type, name, |
| [&]() { unittest_run_test(name, test, current_test_info, all_success); }); |
| } else { |
| unittest_printf_critical(" %-51s [IGNORED]\n", name); |
| } |
| } |
| |
| __EXPORT |
| void unittest_cancel_timeout(void) { watchdog_cancel(); } |
