scottk/OpenCellular
1
0
Fork 0
mirror of https://github.com/Telecominfraproject/OpenCellular.git synced 2026-01-02 13:14:51 +00:00
Code Issues Packages Projects Releases Wiki Activity

eCTS: Convert hook test suite to current format

Browse Source 
This patch updates the hook test suite so that it can be run
within the current framework.

BUG=chromium:736047
BRANCH=none
TEST=cts.py -m hook
test name    TH_RETURN_CODE DUT_RETURN_CODE TH_STR DUT_STR RESULT
test_init_hook       SUCCESS       SUCCESS      1       1   PASS
test_ticks           SUCCESS       SUCCESS      1       1   PASS
test_priority        SUCCESS       SUCCESS      1       1   PASS
test_deferred        SUCCESS       SUCCESS      1       1   PASS

Change-Id: I3e7f29da61e794b06b03241f3d7706c2db94b5be
Signed-off-by: Daisuke Nojiri <dnojiri@chromium.org>
Reviewed-on: https://chromium-review.googlesource.com/545084
This commit is contained in:
Daisuke Nojiri
2017-06-22 11:52:00 -07:00
committed by chrome-bot
parent 3fdf85ece7
commit 4c23fa01df
5 changed files with 105 additions and 191 deletions
Download Patch File Download Diff File Expand all files Collapse all files

2
cts/common/cts_common.h
View File

@@ -12,6 +12,8 @@
#define CPUTS(outstr) cputs(CC_SYSTEM, outstr)
#define CPRINTF(format, args...) cprintf(CC_SYSTEM, format, ## args)
#define CPRINTS(format, args...) cprints(CC_SYSTEM, format, ## args)
#define CPRINTL(format, args...) CPRINTS("%s:%d: "format, \
__func__, __LINE__, ## args)
#ifdef CTS_DEBUG
/* These debug tags should not be changed */

24
cts/hook/cts.testlist Normal file
View File

@@ -0,0 +1,24 @@
/* Copyright 2017 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 HOOK_INIT
*/
CTS_TEST(test_init_hook,,,,)
/*
* Test HOOK_TICK and HOOK_SECOND
*/
CTS_TEST(test_ticks,,,,)
/*
* Test hook priority
*/
CTS_TEST(test_priority,,,,)
/*
* Test deferred calls
*/
CTS_TEST(test_deferred,,,,)

120
cts/hook/dut.c
View File

@@ -7,10 +7,12 @@
#include "common.h"
#include "console.h"
#include "cts_common.h"
#include "dut_common.h"
#include "hooks.h"
#include "test_util.h"
#include "timer.h"
#include "util.h"
#include "watchdog.h"
static int init_hook_count;
static int tick_hook_count;
@@ -41,7 +43,7 @@ static void tick2_hook(void)
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);
DECLARE_HOOK(HOOK_TICK, tick2_hook, HOOK_PRIO_DEFAULT + 1);
static void second_hook(void)
{
@@ -57,22 +59,23 @@ static void deferred_func(void)
}
DECLARE_DEFERRED(deferred_func);
static void non_deferred_func(void)
static void invalid_deferred_func(void)
{
deferred_call_count++;
}
static const struct deferred_data non_deferred_func_data = {
non_deferred_func
static const struct deferred_data invalid_deferred_func_data = {
invalid_deferred_func
};
static int test_init_hook(void)
static enum cts_rc test_init_hook(void)
{
TEST_ASSERT(init_hook_count == 1);
return EC_SUCCESS;
if (init_hook_count != 1)
return CTS_RC_FAILURE;
return CTS_RC_SUCCESS;
}
static int test_ticks(void)
static enum cts_rc test_ticks(void)
{
int64_t interval;
int error_pct;
@@ -82,66 +85,97 @@ static int test_ticks(void)
* task starts. We only need to wait for just more than a second
* to allow it fires for the second time.
*/
usleep(1300 * MSEC);
msleep(1300);
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);
if (error_pct < -10 || 10 < error_pct) {
CPRINTS("tick error=%d%% interval=%ld", error_pct, interval);
return CTS_RC_FAILURE;
}
interval = second_time[1].val - second_time[0].val;
error_pct = (interval - SECOND) * 100 / SECOND;
TEST_ASSERT_ABS_LESS(error_pct, 10);
if (error_pct < -10 || 10 < error_pct) {
CPRINTS("second error=%d%% interval=%ld", error_pct, interval);
return CTS_RC_FAILURE;
}
return EC_SUCCESS;
return CTS_RC_SUCCESS;
}
static int test_priority(void)
static enum cts_rc 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;
if (tick_hook_count != tick2_hook_count)
return CTS_RC_FAILURE;
if (tick_hook_count != tick_count_seen_by_tick2)
return CTS_RC_FAILURE;
return CTS_RC_SUCCESS;
}
static int test_deferred(void)
static enum cts_rc test_deferred(void)
{
deferred_call_count = 0;
hook_call_deferred(&deferred_func_data, 50 * MSEC);
usleep(100 * MSEC);
TEST_ASSERT(deferred_call_count == 1);
if (deferred_call_count != 0) {
CPRINTL("deferred_call_count=%d", deferred_call_count);
return CTS_RC_FAILURE;
}
msleep(100);
if (deferred_call_count != 1) {
CPRINTL("deferred_call_count=%d", deferred_call_count);
return CTS_RC_FAILURE;
}
/* Test cancellation */
deferred_call_count = 0;
hook_call_deferred(&deferred_func_data, 50 * MSEC);
usleep(25 * MSEC);
msleep(25);
hook_call_deferred(&deferred_func_data, -1);
usleep(75 * MSEC);
TEST_ASSERT(deferred_call_count == 1);
msleep(75);
if (deferred_call_count != 0) {
CPRINTL("deferred_call_count=%d", deferred_call_count);
return CTS_RC_FAILURE;
}
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);
/* Invalid deferred function */
deferred_call_count = 0;
if (hook_call_deferred(&invalid_deferred_func_data, 50 * MSEC)
== EC_SUCCESS) {
CPRINTL("non_deferred_func_data");
return CTS_RC_FAILURE;
}
msleep(100);
if (deferred_call_count != 0) {
CPRINTL("deferred_call_count=%d", deferred_call_count);
return CTS_RC_FAILURE;
}
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;
return CTS_RC_SUCCESS;
}
#include "cts_testlist.h"
void cts_task(void)
{
test_reset();
enum cts_rc result;
int i;
RUN_TEST(test_init_hook);
RUN_TEST(test_ticks);
RUN_TEST(test_priority);
RUN_TEST(test_deferred);
cflush();
for (i = 0; i < CTS_TEST_ID_COUNT; i++) {
sync();
CPRINTF("\n%s start\n", tests[i].name);
result = tests[i].run();
CPRINTF("\n%s end %d\n", tests[i].name, result);
cflush();
}
test_print_result();
CPRINTS("Hook test finished");
cflush();
while (1) {
watchdog_reload();
sleep(1);
}
}

147
cts/hook/th.c
View File

@@ -1,147 +0,0 @@
/* 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();
}

1
cts/hook/th.c Symbolic link
View File

@@ -0,0 +1 @@
dut.c

2
util/run_ects.sh
View File

@@ -13,7 +13,7 @@ RED='\033[0;31m'
GRN='\033[0;32m'
# List of tests to run.
TESTS=(meta interrupt gpio task timer)
TESTS=(meta gpio hook interrupt task timer)
usage() {
cat <<END