Commit 55913572 authored by NingX Zhao's avatar NingX Zhao Committed by Christopher Friedt
Browse files

tests: subsys: Adding testcases to check trace API 



Add some testcases to verify tracing's APIs,
check output data by using uart backend of self-design.

Signed-off-by: default avatarNingX Zhao <ningx.zhao@intel.com>
parent 637e9f21

tests/subsys/tracing/tracing_api/CMakeLists.txt

0 → 100644
+12 −0
Original line number Diff line number Diff line 
# SPDX-License-Identifier: Apache-2.0



cmake_minimum_required(VERSION 3.20.0)



if(BOARD MATCHES "qemu_.*")

  list(APPEND QEMU_EXTRA_FLAGS -serial file:channel0_0)

endif()



find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})

project(tracing_tests)



target_sources(app PRIVATE src/main.c)

tests/subsys/tracing/tracing_api/prj.conf

0 → 100644
+5 −0
Original line number Diff line number Diff line 
CONFIG_ZTEST=y

CONFIG_TRACING=y

CONFIG_TRACING_TEST=y

CONFIG_TRACING_BACKEND_UART=y

CONFIG_IDLE_STACK_SIZE=4096

tests/subsys/tracing/tracing_api/src/main.c

0 → 100644
+280 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2021 Intel Corporation+

 *

 * SPDX-License-Identifier: Apache-2.0

 */



#include <ztest.h>

#include <zephyr.h>

#include <logging/log.h>

#include <tracing_buffer.h>

#include <tracing_core.h>

#include <tracing/tracing_format.h>

#if defined(CONFIG_TRACING_BACKEND_UART)

#include "../../../../subsys/tracing/include/tracing_backend.h"

#endif



/**

 * @brief Tests for tracing

 * @defgroup tracing_api_tests Tracing

 * @ingroup all_tests

 * @{

 * @}

 */



/* Check flags */

static bool data_format_found;

static bool raw_data_format_found;

static bool sync_string_format_found;

#ifdef CONFIG_TRACING_ASYNC

static bool tracing_api_found;

static bool tracing_api_not_found;

static uint8_t *string_tracked[] = {

	"sys_trace_k_thread_switched_out", "sys_trace_k_thread_switched_in",

	"sys_trace_k_thread_priority_set", "sys_trace_k_thread_sched_set_priority",

	"sys_trace_k_thread_create", "sys_trace_k_thread_start",

	"sys_trace_k_thread_abort", "sys_trace_k_thread_suspend",

	"sys_trace_k_thread_resume", "sys_trace_k_thread_ready",

	"sys_trace_k_thread_sched_ready", "sys_trace_k_thread_sched_abort",

	"sys_trace_k_thread_sched_resume", "sys_trace_k_thread_sched_suspend",

	"sys_trace_k_thread_sleep_enter", "sys_trace_k_thread_sleep_exit",

	"sys_trace_k_thread_abort_enter", "sys_trace_k_thread_abort_exit",

	"sys_trace_k_thread_yield", "sys_trace_k_thread_wakeup",

	"sys_trace_k_thread_pend", "sys_trace_k_thread_info",

	"sys_trace_k_thread_name_set", "sys_trace_k_thread_sched_lock",

	"sys_trace_k_timer_init", "sys_trace_k_thread_join_blocking",

	"sys_trace_k_thread_join_exit", "sys_trace_isr_enter",

	"sys_trace_isr_exit", "sys_trace_idle",

	"sys_trace_k_condvar_broadcast_enter", "sys_trace_k_condvar_broadcast_exit",

	"sys_trace_k_condvar_init", "sys_trace_k_condvar_signal_enter",

	"sys_trace_k_condvar_signal_blocking", "sys_trace_k_condvar_signal_exit",

	"sys_trace_k_condvar_wait_enter", "sys_trace_k_condvar_wait_exit",

	"sys_trace_k_sem_init", "sys_trace_k_sem_give_enter",

	"sys_trace_k_sem_take_enter", "sys_trace_k_sem_take_exit",

	"sys_trace_k_sem_take_blocking", "sys_trace_k_mutex_init",

	"sys_trace_k_mutex_lock_enter", "sys_trace_k_mutex_lock_exit",

	"sys_trace_k_mutex_lock_blocking", "sys_trace_k_mutex_unlock_enter",

	"sys_trace_k_mutex_unlock_exit", "sys_trace_k_timer_start"

};

#endif



#if defined(CONFIG_TRACING_BACKEND_UART)

static void tracing_backends_output(

		const struct tracing_backend *backend,

		uint8_t *data, uint32_t length)

{

	/* Check the output data. */

#ifdef CONFIG_TRACING_ASYNC

	/* Define static 'i' is for guaranteeing all strings of 0 ~ end

	 * of the array string_tracked are tested.

	 */

	static int i;



	while (string_tracked[i] != NULL) {

		if (strstr(data, string_tracked[i]) != NULL) {

			tracing_api_found = true;

		} else {

			tracing_api_not_found = true;

		}

		i++;

	}

#endif

	if (strstr(data, "tracing_format_data_testing") != NULL) {

		data_format_found = true;

	}

	if (strstr(data, "tracing_format_raw_data_testing") != NULL) {

		raw_data_format_found = true;

	}

	if (strstr(data, "tracing_format_string_testing") != NULL) {

		sync_string_format_found = true;

	}

}



const struct tracing_backend_api tracing_uart_backend_api = {

	.init = NULL,

	.output  = tracing_backends_output

};



TRACING_BACKEND_DEFINE(tracing_backend_uart, tracing_uart_backend_api);

#endif



#ifdef CONFIG_TRACING_ASYNC

/**

 * @brief Test tracing APIS

 *

 * @details For asynchronous mode, self-designed tracing uart backend

 * firstly, and called tracing APIs one by one directly, check if the

 * output from the backend is equal to the input.

 *

 * @ingroup tracing_api_tests

 */

void test_tracing_sys_api(void)

{

	int ret = 0, prio = 0;

	size_t stack = 0;

	struct k_mutex mutex;

	struct k_thread thread;

	struct k_condvar condvar;

	struct k_sem sem, sem2;

	struct k_timer timer;

	k_timeout_t timeout = K_MSEC(1);



	tracing_buffer_init();

	/* thread api */

	sys_trace_k_thread_switched_out();

	sys_trace_k_thread_switched_in();

	sys_trace_k_thread_priority_set(&thread);

	sys_trace_k_thread_sched_set_priority(&thread, prio);

	sys_trace_k_thread_create(&thread, stack, prio);

	sys_trace_k_thread_start(&thread);

	sys_trace_k_thread_abort(&thread);

	sys_trace_k_thread_suspend(&thread);

	sys_trace_k_thread_resume(&thread);

	sys_trace_k_thread_ready(&thread);

	sys_trace_k_thread_sched_ready(&thread);

	sys_trace_k_thread_sched_abort(&thread);

	sys_trace_k_thread_sched_resume(&thread);

	sys_trace_k_thread_sched_suspend(&thread);

	sys_trace_k_thread_sleep_enter(timeout);

	sys_trace_k_thread_sleep_exit(timeout, ret);

	sys_trace_k_thread_abort_enter(&thread);

	sys_trace_k_thread_abort_exit(&thread);

	sys_trace_k_thread_yield();

	sys_trace_k_thread_wakeup(&thread);

	sys_trace_k_thread_pend(&thread);

	sys_trace_k_thread_info(&thread);

	sys_trace_k_thread_name_set(&thread, ret);

	sys_trace_k_thread_sched_lock();

	sys_port_trace_k_thread_sched_unlock();

	sys_trace_k_thread_join_blocking(&thread, timeout);

	sys_trace_k_thread_join_exit(&thread, timeout, ret);

	/* ISR api */

	sys_trace_isr_enter();

	sys_trace_isr_exit();

	sys_trace_idle();

	/* condvar api */

	sys_trace_k_condvar_broadcast_enter(&condvar);

	sys_trace_k_condvar_broadcast_exit(&condvar, ret);

	sys_trace_k_condvar_init(&condvar, ret);

	sys_trace_k_condvar_signal_enter(&condvar);

	sys_trace_k_condvar_signal_blocking(&condvar);

	sys_trace_k_condvar_signal_exit(&condvar, ret);

	sys_trace_k_condvar_wait_enter(&condvar, &mutex, timeout);

	sys_trace_k_condvar_wait_exit(&condvar, &mutex, timeout, ret);

	/* sem api */

	sys_trace_k_sem_init(&sem, ret);

	sys_trace_k_sem_give_enter(&sem);

	sys_trace_k_sem_take_enter(&sem2, timeout);

	sys_trace_k_sem_take_exit(&sem, timeout, ret);

	sys_trace_k_sem_take_blocking(&sem, timeout);

	/* mutex api */

	sys_trace_k_mutex_init(&mutex, ret);

	sys_trace_k_mutex_lock_enter(&mutex, timeout);

	sys_trace_k_mutex_lock_exit(&mutex, timeout, ret);

	sys_trace_k_mutex_lock_blocking(&mutex, timeout);

	sys_trace_k_mutex_unlock_enter(&mutex);

	sys_trace_k_mutex_unlock_exit(&mutex, ret);

	/* timer api */

	sys_trace_k_timer_start(&timer, timeout, timeout);

	sys_trace_k_timer_init(&timer, NULL, NULL);



	/* wait for some actions finished */

	k_sleep(K_MSEC(100));

	zassert_true(tracing_api_found, "Failded to check output from backend");

	zassert_true(tracing_api_not_found == false, "Failded to check output from backend");

}

#else

/**

 * @brief Test tracing APIS

 *

 * @details For synchronize mode, self-designed tracing uart backend

 * firstly, called API tracing_format_string to put a string, meanwhile,

 * check the output for the backend.

 *

 * @ingroup tracing_api_tests

 */

void test_tracing_sys_api(void)

{

	tracing_buffer_init();

	tracing_format_string("tracing_format_string_testing");

	k_sleep(K_MSEC(100));



	zassert_true(sync_string_format_found == true, "Failded to check output from backend");

}

#endif /* CONFIG_TRACING_ASYNC */



/**

 * @brief Test tracing APIS

 *

 * @details Packaged the data by different format as the tracing input,

 * check the output for the self-designed uart backend.

 *

 * @ingroup tracing_api_tests

 */

void test_tracing_data_format(void)

{

	tracing_data_t tracing_data, tracing_raw_data;

	uint8_t data[] = "tracing_format_data_testing";

	uint8_t raw_data[] = "tracing_format_raw_data_testing";



	tracing_buffer_init();

	tracing_data.data = data;

	tracing_data.length = sizeof(data);

	tracing_raw_data.data = raw_data;

	tracing_raw_data.length = sizeof(raw_data);



	tracing_format_data(&tracing_data, 1);

	k_sleep(K_MSEC(100));

	zassert_true(data_format_found == true, "Failded to check output from backend");



	tracing_format_raw_data(tracing_raw_data.data, tracing_raw_data.length);

	k_sleep(K_MSEC(100));

	zassert_true(raw_data_format_found == true, "Failded to check output from backend");

}



/**

 * @brief Test tracing APIS

 *

 * @details Simulate the host computer command to pass to the function

 * tracing_cmd_handle to detect the tracing behavior.

 *

 * @ingroup tracing_api_tests

 */

void test_tracing_cmd_manual(void)

{

	uint32_t length = 0;

	uint8_t *cmd = NULL;

	uint8_t cmd0[] = " ";

	uint8_t cmd1[] = "enable";

	uint8_t cmd2[] = "disable";



	length = tracing_cmd_buffer_alloc(&cmd);

	cmd = cmd0;

	zassert_true(sizeof(cmd0) < length, "cmd0 is too long");

	tracing_cmd_handle(cmd, sizeof(cmd0));

	zassert_true(is_tracing_enabled(),

		"Failed to check default status of tracing");



	length = tracing_cmd_buffer_alloc(&cmd);

	cmd = cmd1;

	zassert_true(sizeof(cmd1) < length, "cmd1 is too long");

	tracing_cmd_handle(cmd, sizeof(cmd1));

	zassert_true(is_tracing_enabled(), "Failed to enable tracing");



	length = tracing_cmd_buffer_alloc(&cmd);

	cmd = cmd2;

	zassert_true(sizeof(cmd2) < length, "cmd2 is too long");

	tracing_cmd_handle(cmd, sizeof(cmd2));

	zassert_false(is_tracing_enabled(), "Failed to disable tracing");

}





void test_main(void)

{

	ztest_test_suite(test_tracing,

			 ztest_unit_test(test_tracing_sys_api),

			 ztest_unit_test(test_tracing_data_format),

			 ztest_unit_test(test_tracing_cmd_manual)

			 );

	ztest_run_test_suite(test_tracing);

}

tests/subsys/tracing/tracing_api/testcase.yaml

0 → 100644
+10 −0
Original line number Diff line number Diff line 
common:

  platform_allow: qemu_x86

  extra_args: CONF_FILE="prj.conf"



tests:

  tracing.transport.uart.async.test:

    tags: tracing_testing

  tracing.transport.uart.sync.test:

    extra_configs:

      - CONFIG_TRACING_SYNC=y

CRA Git | Maintained and supported by SUSTech CRA and CCSE