From a7d454f48b19b6cb2dca76151cb3faa050df24d1 Mon Sep 17 00:00:00 2001 From: Daisuke Nojiri Date: Thu, 14 Jul 2016 14:12:21 -0700 Subject: cts: Add hook test It's imported from test/hooks.c and adjusted to CTS. BUG=chromium:624520 BRANCH=none TEST=make buildall. Test passed on stm32l476-geval and nucleo-f072rb. Change-Id: I70673f2c0f8316a2b1fd9472eeb7db350fdc2d84 Signed-off-by: Daisuke Nojiri Reviewed-on: https://chromium-review.googlesource.com/360631 Reviewed-by: Chris Chen --- cts/hook/dut.c | 147 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ cts/hook/th.c | 147 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 294 insertions(+) create mode 100644 cts/hook/dut.c create mode 100644 cts/hook/th.c (limited to 'cts') diff --git a/cts/hook/dut.c b/cts/hook/dut.c new file mode 100644 index 0000000000..36494916b9 --- /dev/null +++ b/cts/hook/dut.c @@ -0,0 +1,147 @@ +/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + * + * Test hooks. + */ + +#include "common.h" +#include "console.h" +#include "hooks.h" +#include "test_util.h" +#include "timer.h" +#include "util.h" + +static int init_hook_count; +static int tick_hook_count; +static int tick2_hook_count; +static int tick_count_seen_by_tick2; +static timestamp_t tick_time[2]; +static int second_hook_count; +static timestamp_t second_time[2]; +static int deferred_call_count; + +static void init_hook(void) +{ + init_hook_count++; +} +DECLARE_HOOK(HOOK_INIT, init_hook, HOOK_PRIO_DEFAULT); + +static void tick_hook(void) +{ + tick_hook_count++; + tick_time[0] = tick_time[1]; + tick_time[1] = get_time(); +} +DECLARE_HOOK(HOOK_TICK, tick_hook, HOOK_PRIO_DEFAULT); + +static void tick2_hook(void) +{ + tick2_hook_count++; + tick_count_seen_by_tick2 = tick_hook_count; +} +/* tick2_hook() prio means it should be called after tick_hook() */ +DECLARE_HOOK(HOOK_TICK, tick2_hook, HOOK_PRIO_DEFAULT+1); + +static void second_hook(void) +{ + second_hook_count++; + second_time[0] = second_time[1]; + second_time[1] = get_time(); +} +DECLARE_HOOK(HOOK_SECOND, second_hook, HOOK_PRIO_DEFAULT); + +static void deferred_func(void) +{ + deferred_call_count++; +} +DECLARE_DEFERRED(deferred_func); + +static void non_deferred_func(void) +{ + deferred_call_count++; +} + +static const struct deferred_data non_deferred_func_data = { + non_deferred_func +}; + +static int test_init_hook(void) +{ + TEST_ASSERT(init_hook_count == 1); + return EC_SUCCESS; +} + +static int test_ticks(void) +{ + int64_t interval; + int error_pct; + + /* + * HOOK_SECOND must have been fired at least once when HOOK + * task starts. We only need to wait for just more than a second + * to allow it fires for the second time. + */ + usleep(1300 * MSEC); + + interval = tick_time[1].val - tick_time[0].val; + error_pct = (interval - HOOK_TICK_INTERVAL) * 100 / + HOOK_TICK_INTERVAL; + TEST_ASSERT_ABS_LESS(error_pct, 10); + + interval = second_time[1].val - second_time[0].val; + error_pct = (interval - SECOND) * 100 / SECOND; + TEST_ASSERT_ABS_LESS(error_pct, 10); + + return EC_SUCCESS; +} + +static int test_priority(void) +{ + usleep(HOOK_TICK_INTERVAL); + TEST_ASSERT(tick_hook_count == tick2_hook_count); + TEST_ASSERT(tick_hook_count == tick_count_seen_by_tick2); + + return EC_SUCCESS; +} + +static int test_deferred(void) +{ + deferred_call_count = 0; + hook_call_deferred(&deferred_func_data, 50 * MSEC); + usleep(100 * MSEC); + TEST_ASSERT(deferred_call_count == 1); + + hook_call_deferred(&deferred_func_data, 50 * MSEC); + usleep(25 * MSEC); + hook_call_deferred(&deferred_func_data, -1); + usleep(75 * MSEC); + TEST_ASSERT(deferred_call_count == 1); + + hook_call_deferred(&deferred_func_data, 50 * MSEC); + usleep(25 * MSEC); + hook_call_deferred(&deferred_func_data, -1); + usleep(15 * MSEC); + hook_call_deferred(&deferred_func_data, 25 * MSEC); + usleep(50 * MSEC); + TEST_ASSERT(deferred_call_count == 2); + + TEST_ASSERT(hook_call_deferred(&non_deferred_func_data, 50 * MSEC) != + EC_SUCCESS); + usleep(100 * MSEC); + TEST_ASSERT(deferred_call_count == 2); + + return EC_SUCCESS; +} + +void cts_task(void) +{ + test_reset(); + + RUN_TEST(test_init_hook); + RUN_TEST(test_ticks); + RUN_TEST(test_priority); + RUN_TEST(test_deferred); + + test_print_result(); +} diff --git a/cts/hook/th.c b/cts/hook/th.c new file mode 100644 index 0000000000..36494916b9 --- /dev/null +++ b/cts/hook/th.c @@ -0,0 +1,147 @@ +/* Copyright (c) 2013 The Chromium OS Authors. All rights reserved. + * Use of this source code is governed by a BSD-style license that can be + * found in the LICENSE file. + * + * Test hooks. + */ + +#include "common.h" +#include "console.h" +#include "hooks.h" +#include "test_util.h" +#include "timer.h" +#include "util.h" + +static int init_hook_count; +static int tick_hook_count; +static int tick2_hook_count; +static int tick_count_seen_by_tick2; +static timestamp_t tick_time[2]; +static int second_hook_count; +static timestamp_t second_time[2]; +static int deferred_call_count; + +static void init_hook(void) +{ + init_hook_count++; +} +DECLARE_HOOK(HOOK_INIT, init_hook, HOOK_PRIO_DEFAULT); + +static void tick_hook(void) +{ + tick_hook_count++; + tick_time[0] = tick_time[1]; + tick_time[1] = get_time(); +} +DECLARE_HOOK(HOOK_TICK, tick_hook, HOOK_PRIO_DEFAULT); + +static void tick2_hook(void) +{ + tick2_hook_count++; + tick_count_seen_by_tick2 = tick_hook_count; +} +/* tick2_hook() prio means it should be called after tick_hook() */ +DECLARE_HOOK(HOOK_TICK, tick2_hook, HOOK_PRIO_DEFAULT+1); + +static void second_hook(void) +{ + second_hook_count++; + second_time[0] = second_time[1]; + second_time[1] = get_time(); +} +DECLARE_HOOK(HOOK_SECOND, second_hook, HOOK_PRIO_DEFAULT); + +static void deferred_func(void) +{ + deferred_call_count++; +} +DECLARE_DEFERRED(deferred_func); + +static void non_deferred_func(void) +{ + deferred_call_count++; +} + +static const struct deferred_data non_deferred_func_data = { + non_deferred_func +}; + +static int test_init_hook(void) +{ + TEST_ASSERT(init_hook_count == 1); + return EC_SUCCESS; +} + +static int test_ticks(void) +{ + int64_t interval; + int error_pct; + + /* + * HOOK_SECOND must have been fired at least once when HOOK + * task starts. We only need to wait for just more than a second + * to allow it fires for the second time. + */ + usleep(1300 * MSEC); + + interval = tick_time[1].val - tick_time[0].val; + error_pct = (interval - HOOK_TICK_INTERVAL) * 100 / + HOOK_TICK_INTERVAL; + TEST_ASSERT_ABS_LESS(error_pct, 10); + + interval = second_time[1].val - second_time[0].val; + error_pct = (interval - SECOND) * 100 / SECOND; + TEST_ASSERT_ABS_LESS(error_pct, 10); + + return EC_SUCCESS; +} + +static int test_priority(void) +{ + usleep(HOOK_TICK_INTERVAL); + TEST_ASSERT(tick_hook_count == tick2_hook_count); + TEST_ASSERT(tick_hook_count == tick_count_seen_by_tick2); + + return EC_SUCCESS; +} + +static int test_deferred(void) +{ + deferred_call_count = 0; + hook_call_deferred(&deferred_func_data, 50 * MSEC); + usleep(100 * MSEC); + TEST_ASSERT(deferred_call_count == 1); + + hook_call_deferred(&deferred_func_data, 50 * MSEC); + usleep(25 * MSEC); + hook_call_deferred(&deferred_func_data, -1); + usleep(75 * MSEC); + TEST_ASSERT(deferred_call_count == 1); + + hook_call_deferred(&deferred_func_data, 50 * MSEC); + usleep(25 * MSEC); + hook_call_deferred(&deferred_func_data, -1); + usleep(15 * MSEC); + hook_call_deferred(&deferred_func_data, 25 * MSEC); + usleep(50 * MSEC); + TEST_ASSERT(deferred_call_count == 2); + + TEST_ASSERT(hook_call_deferred(&non_deferred_func_data, 50 * MSEC) != + EC_SUCCESS); + usleep(100 * MSEC); + TEST_ASSERT(deferred_call_count == 2); + + return EC_SUCCESS; +} + +void cts_task(void) +{ + test_reset(); + + RUN_TEST(test_init_hook); + RUN_TEST(test_ticks); + RUN_TEST(test_priority); + RUN_TEST(test_deferred); + + test_print_result(); +} -- cgit v1.2.1