eCTS: Convert hook test suite to current format

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

4 files changed, 108 insertions, 194 deletions

diff --git a/cts/common/cts_common.h b/cts/common/cts_common.h
index 607adbc623..3c24b815e7 100644
--- a/cts/common/cts_common.h
+++ b/cts/common/cts_common.h
@@ -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 */
diff --git a/cts/hook/cts.testlist b/cts/hook/cts.testlist
new file mode 100644
index 0000000000..97b25575d4
--- /dev/null
+++ b/cts/hook/cts.testlist
@@ -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,,,,)
\ No newline at end of file
diff --git a/cts/hook/dut.c b/cts/hook/dut.c
index 36494916b9..8be9121128 100644
--- a/cts/hook/dut.c
+++ b/cts/hook/dut.c
@@ -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);
-
-	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);
-
+	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(15 * MSEC);
-	hook_call_deferred(&deferred_func_data, 25 * MSEC);
-	usleep(50 * MSEC);
-	TEST_ASSERT(deferred_call_count == 2);
+	msleep(75);
+	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;
+	/* 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;
+	}
+
+	return CTS_RC_SUCCESS;
 }
 
+#include "cts_testlist.h"
+
 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();
+	enum cts_rc result;
+	int i;
+
+	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();
+	}
+
+	CPRINTS("Hook test finished");
+	cflush();
+	while (1) {
+		watchdog_reload();
+		sleep(1);
+	}
 }
diff --git a/cts/hook/th.c b/cts/hook/th.c
index 36494916b9..41eab28462 100644..120000
--- a/cts/hook/th.c
+++ b/cts/hook/th.c
@@ -1,147 +1 @@
-/* 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();
-}
+dut.c
\ No newline at end of file