test/cmd_ut.c - filogic/uboot - Gitiles

 // SPDX-License-Identifier: GPL-2.0
 /*
  * (C) Copyright 2015
  * Joe Hershberger, National Instruments, joe.hershberger@ni.com
  */

 #include <command.h>
 #include <console.h>
 #include <vsprintf.h>
 #include <test/test.h>
 #include <test/ut.h>

 /**
  * struct suite - A set of tests for a certain topic
  *
  * All tests end up in a single 'struct unit_test' linker-list array, in order
  * of the suite they are in
  *
  * @name: Name of suite
  * @start: First test in suite
  * @end: End test in suite (points to the first test in the next suite)
  * @help: Help-string to show for this suite
  */
 struct suite {
 	const char *name;
 	struct unit_test *start;
 	struct unit_test *end;
 	const char *help;
 };

 static int do_ut_all(struct unit_test_state *uts, const char *select_name,
 		     int runs_per_test, bool force_run,
 		     const char *test_insert);

 static int do_ut_info(bool show_suites);

 /* declare linker-list symbols for the start and end of a suite */
 #define SUITE_DECL(_name) \
 	ll_start_decl(suite_start_ ## _name, struct unit_test, ut_ ## _name); \
 	ll_end_decl(suite_end_ ## _name, struct unit_test, ut_ ## _name)

 /* declare a test suite which can be run directly without a subcommand */
 #define SUITE(_name, _help) { \
 	#_name, \
 	suite_start_ ## _name, \
 	suite_end_ ## _name, \
 	_help, \
 	}

 SUITE_DECL(addrmap);
 SUITE_DECL(bdinfo);
 SUITE_DECL(bloblist);
 SUITE_DECL(bootm);
 SUITE_DECL(bootstd);
 SUITE_DECL(cmd);
 SUITE_DECL(common);
 SUITE_DECL(dm);
 SUITE_DECL(env);
 SUITE_DECL(exit);
 SUITE_DECL(fdt);
 SUITE_DECL(fdt_overlay);
 SUITE_DECL(font);
 SUITE_DECL(hush);
 SUITE_DECL(lib);
 SUITE_DECL(loadm);
 SUITE_DECL(log);
 SUITE_DECL(mbr);
 SUITE_DECL(measurement);
 SUITE_DECL(mem);
 SUITE_DECL(optee);
 SUITE_DECL(pci_mps);
 SUITE_DECL(seama);
 SUITE_DECL(setexpr);
 SUITE_DECL(upl);

 static struct suite suites[] = {
 	SUITE(addrmap, "very basic test of addrmap command"),
 	SUITE(bdinfo, "bdinfo (board info) command"),
 	SUITE(bloblist, "bloblist implementation"),
 	SUITE(bootm, "bootm command"),
 	SUITE(bootstd, "standard boot implementation"),
 	SUITE(cmd, "various commands"),
 	SUITE(common, "tests for common/ directory"),
 	SUITE(dm, "driver model"),
 	SUITE(env, "environment"),
 	SUITE(exit, "shell exit and variables"),
 	SUITE(fdt, "fdt command"),
 	SUITE(fdt_overlay, "device tree overlays"),
 	SUITE(font, "font command"),
 	SUITE(hush, "hush behaviour"),
 	SUITE(lib, "library functions"),
 	SUITE(loadm, "loadm command parameters and loading memory blob"),
 	SUITE(log, "logging functions"),
 	SUITE(mbr, "mbr command"),
 	SUITE(measurement, "TPM-based measured boot"),
 	SUITE(mem, "memory-related commands"),
 	SUITE(optee, "OP-TEE"),
 	SUITE(pci_mps, "PCI Express Maximum Payload Size"),
 	SUITE(seama, "seama command parameters loading and decoding"),
 	SUITE(setexpr, "setexpr command"),
 	SUITE(upl, "Universal payload support"),
 };

 /**
  * has_tests() - Check if a suite has tests, i.e. is supported in this build
  *
  * If the suite is run using a command, we have to assume that tests may be
  * present, since we have no visibility
  *
  * @ste: Suite to check
  * Return: true if supported, false if not
  */
 static bool has_tests(struct suite *ste)
 {
 	int n_ents = ste->end - ste->start;

 	return n_ents;
 }

 /** run_suite() - Run a suite of tests */
 static int run_suite(struct unit_test_state *uts, struct suite *ste,
 		     const char *select_name, int runs_per_test, bool force_run,
 		     const char *test_insert)
 {
 	int n_ents = ste->end - ste->start;
 	char prefix[30];
 	int ret;

 	/* use a standard prefix */
 	snprintf(prefix, sizeof(prefix), "%s_test_", ste->name);

 	ret = ut_run_list(uts, ste->name, prefix, ste->start, n_ents,
 			  select_name, runs_per_test, force_run, test_insert);

 	return ret;
 }

 static void show_stats(struct unit_test_state *uts)
 {
 	if (uts->run_count < 2)
 		return;

 	ut_report(&uts->total, uts->run_count);
 	if (CONFIG_IS_ENABLED(UNIT_TEST_DURATION) &&
 	    uts->total.test_count && uts->worst) {
 		ulong avg = uts->total.duration_ms / uts->total.test_count;

 		printf("Average test time: %ld ms, worst case '%s' took %d ms\n",
 		       avg, uts->worst->name, uts->worst_ms);
 	}
 }

 static void update_stats(struct unit_test_state *uts, const struct suite *ste)
 {
 	if (CONFIG_IS_ENABLED(UNIT_TEST_DURATION) && uts->cur.test_count) {
 		ulong avg;

 		avg = uts->cur.duration_ms ?
 			uts->cur.duration_ms /
 			uts->cur.test_count : 0;
 		if (avg > uts->worst_ms) {
 			uts->worst_ms = avg;
 			uts->worst = ste;
 		}
 	}
 }

 static int do_ut_all(struct unit_test_state *uts, const char *select_name,
 		     int runs_per_test, bool force_run, const char *test_insert)
 {
 	int i;
 	int retval;
 	int any_fail = 0;

 	for (i = 0; i < ARRAY_SIZE(suites); i++) {
 		struct suite *ste = &suites[i];

 		if (has_tests(ste)) {
 			printf("----Running %s tests----\n", ste->name);
 			retval = run_suite(uts, ste, select_name, runs_per_test,
 					   force_run, test_insert);
 			if (!any_fail)
 				any_fail = retval;
 			update_stats(uts, ste);
 		}
 	}

 	return any_fail;
 }

 static int do_ut_info(bool show_suites)
 {
 	int suite_count, i;

 	for (suite_count = 0, i = 0; i < ARRAY_SIZE(suites); i++) {
 		struct suite *ste = &suites[i];

 		if (has_tests(ste))
 			suite_count++;
 	}

 	printf("Test suites: %d\n", suite_count);
 	printf("Total tests: %d\n", (int)UNIT_TEST_ALL_COUNT());

 	if (show_suites) {
 		int i, total;

 		puts("\nTests  Suite         Purpose");
 		puts("\n-----  ------------  -------------------------\n");
 		for (i = 0, total = 0; i < ARRAY_SIZE(suites); i++) {
 			struct suite *ste = &suites[i];
 			long n_ent = ste->end - ste->start;

 			if (n_ent) {
 				printf("%5ld  %-13.13s %s\n", n_ent, ste->name,
 				       ste->help);
 				total += n_ent;
 			}
 		}
 		puts("-----  ------------  -------------------------\n");
 		printf("%5d  %-13.13s\n", total, "Total");

 		if (UNIT_TEST_ALL_COUNT() != total)
 			puts("Error: Suite test-count does not match total\n");
 	}

 	return 0;
 }

 static struct suite *find_suite(const char *name)
 {
 	struct suite *ste;
 	int i;

 	for (i = 0, ste = suites; i < ARRAY_SIZE(suites); i++, ste++) {
 		if (!strcmp(ste->name, name))
 			return ste;
 	}

 	return NULL;
 }

 static int do_ut(struct cmd_tbl *cmdtp, int flag, int argc, char *const argv[])
 {
 	const char *test_insert = NULL, *select_name;
 	struct unit_test_state uts;
 	bool show_suites = false;
 	bool force_run = false;
 	int runs_per_text = 1;
 	struct suite *ste;
 	char *name;
 	int ret;

 	/* drop initial "ut" arg */
 	argc--;
 	argv++;

 	while (argc > 0 && *argv[0] == '-') {
 		const char *str = argv[0];

 		switch (str[1]) {
 		case 'r':
 			runs_per_text = dectoul(str + 2, NULL);
 			break;
 		case 'f':
 			force_run = true;
 			break;
 		case 'I':
 			test_insert = str + 2;
 			if (!strchr(test_insert, ':'))
 				return CMD_RET_USAGE;
 			break;
 		case 's':
 			show_suites = true;
 			break;
 		}
 		argv++;
 		argc--;
 	}

 	if (argc < 1)
 		return CMD_RET_USAGE;

 	ut_init_state(&uts);
 	name = argv[0];
 	select_name = cmd_arg1(argc, argv);
 	if (!strcmp(name, "all")) {
 		ret = do_ut_all(&uts, select_name, runs_per_text, force_run,
 				test_insert);
 	} else if (!strcmp(name, "info")) {
 		ret = do_ut_info(show_suites);
 	} else {
 		int any_fail = 0;
 		const char *p;

 		for (; p = strsep(&name, ","), p; name = NULL) {
 			ste = find_suite(p);
 			if (!ste) {
 				printf("Suite '%s' not found\n", p);
 				return CMD_RET_FAILURE;
 			} else if (!has_tests(ste)) {
 				/* perhaps a Kconfig option needs to be set? */
 				printf("Suite '%s' is not enabled\n", p);
 				return CMD_RET_FAILURE;
 			}

 			ret = run_suite(&uts, ste, select_name, runs_per_text,
 					force_run, test_insert);
 			if (!any_fail)
 				any_fail = ret;
 			update_stats(&uts, ste);
 		}
 		ret = any_fail;
 	}
 	show_stats(&uts);
 	if (ret)
 		return ret;
 	ut_uninit_state(&uts);

 	return 0;
 }

 U_BOOT_LONGHELP(ut,
 	"[-rs] [-f] [-I<n>:<one_test>][<suites>] - run unit tests\n"
 	"   -r<runs>   Number of times to run each test\n"
 	"   -f         Force 'manual' tests to run as well\n"
 	"   -I         Test to run after <n> other tests have run\n"
 	"   -s         Show all suites with ut info\n"
 	"   <suites>   Comma-separated list of suites to run\n"
 	"\n"
 	"Options for <suite>:\n"
 	"all       - execute all enabled tests\n"
 	"info      - show info about tests [and suites]"
 	);

 U_BOOT_CMD(
 	ut, CONFIG_SYS_MAXARGS, 1, do_ut,
 	"unit tests", ut_help_text
 );
	// SPDX-License-Identifier: GPL-2.0
	/*
	* (C) Copyright 2015
	* Joe Hershberger, National Instruments, joe.hershberger@ni.com
	*/

	#include <command.h>
	#include <console.h>
	#include <vsprintf.h>
	#include <test/test.h>
	#include <test/ut.h>

	/**
	* struct suite - A set of tests for a certain topic
	*
	* All tests end up in a single 'struct unit_test' linker-list array, in order
	* of the suite they are in
	*
	* @name: Name of suite
	* @start: First test in suite
	* @end: End test in suite (points to the first test in the next suite)
	* @help: Help-string to show for this suite
	*/
	struct suite {
	const char *name;
	struct unit_test *start;
	struct unit_test *end;
	const char *help;
	};

	static int do_ut_all(struct unit_test_state uts, const char select_name,
	int runs_per_test, bool force_run,
	const char *test_insert);

	static int do_ut_info(bool show_suites);

	/* declare linker-list symbols for the start and end of a suite */
	#define SUITE_DECL(_name) \
	ll_start_decl(suite_start_ ## _name, struct unit_test, ut_ ## _name); \
	ll_end_decl(suite_end_ ## _name, struct unit_test, ut_ ## _name)

	/* declare a test suite which can be run directly without a subcommand */
	#define SUITE(_name, _help) { \
	#_name, \
	suite_start_ ## _name, \
	suite_end_ ## _name, \
	_help, \
	}

	SUITE_DECL(addrmap);
	SUITE_DECL(bdinfo);
	SUITE_DECL(bloblist);
	SUITE_DECL(bootm);
	SUITE_DECL(bootstd);
	SUITE_DECL(cmd);
	SUITE_DECL(common);
	SUITE_DECL(dm);
	SUITE_DECL(env);
	SUITE_DECL(exit);
	SUITE_DECL(fdt);
	SUITE_DECL(fdt_overlay);
	SUITE_DECL(font);
	SUITE_DECL(hush);
	SUITE_DECL(lib);
	SUITE_DECL(loadm);
	SUITE_DECL(log);
	SUITE_DECL(mbr);
	SUITE_DECL(measurement);
	SUITE_DECL(mem);
	SUITE_DECL(optee);
	SUITE_DECL(pci_mps);
	SUITE_DECL(seama);
	SUITE_DECL(setexpr);
	SUITE_DECL(upl);

	static struct suite suites[] = {
	SUITE(addrmap, "very basic test of addrmap command"),
	SUITE(bdinfo, "bdinfo (board info) command"),
	SUITE(bloblist, "bloblist implementation"),
	SUITE(bootm, "bootm command"),
	SUITE(bootstd, "standard boot implementation"),
	SUITE(cmd, "various commands"),
	SUITE(common, "tests for common/ directory"),
	SUITE(dm, "driver model"),
	SUITE(env, "environment"),
	SUITE(exit, "shell exit and variables"),
	SUITE(fdt, "fdt command"),
	SUITE(fdt_overlay, "device tree overlays"),
	SUITE(font, "font command"),
	SUITE(hush, "hush behaviour"),
	SUITE(lib, "library functions"),
	SUITE(loadm, "loadm command parameters and loading memory blob"),
	SUITE(log, "logging functions"),
	SUITE(mbr, "mbr command"),
	SUITE(measurement, "TPM-based measured boot"),
	SUITE(mem, "memory-related commands"),
	SUITE(optee, "OP-TEE"),
	SUITE(pci_mps, "PCI Express Maximum Payload Size"),
	SUITE(seama, "seama command parameters loading and decoding"),
	SUITE(setexpr, "setexpr command"),
	SUITE(upl, "Universal payload support"),
	};

	/**
	* has_tests() - Check if a suite has tests, i.e. is supported in this build
	*
	* If the suite is run using a command, we have to assume that tests may be
	* present, since we have no visibility
	*
	* @ste: Suite to check
	* Return: true if supported, false if not
	*/
	static bool has_tests(struct suite *ste)
	{
	int n_ents = ste->end - ste->start;

	return n_ents;
	}

	/** run_suite() - Run a suite of tests */
	static int run_suite(struct unit_test_state uts, struct suite ste,
	const char *select_name, int runs_per_test, bool force_run,
	const char *test_insert)
	{
	int n_ents = ste->end - ste->start;
	char prefix[30];
	int ret;

	/* use a standard prefix */
	snprintf(prefix, sizeof(prefix), "%s_test_", ste->name);

	ret = ut_run_list(uts, ste->name, prefix, ste->start, n_ents,
	select_name, runs_per_test, force_run, test_insert);

	return ret;
	}

	static void show_stats(struct unit_test_state *uts)
	{
	if (uts->run_count < 2)
	return;

	ut_report(&uts->total, uts->run_count);
	if (CONFIG_IS_ENABLED(UNIT_TEST_DURATION) &&
	uts->total.test_count && uts->worst) {
	ulong avg = uts->total.duration_ms / uts->total.test_count;

	printf("Average test time: %ld ms, worst case '%s' took %d ms\n",
	avg, uts->worst->name, uts->worst_ms);
	}
	}

	static void update_stats(struct unit_test_state uts, const struct suite ste)
	{
	if (CONFIG_IS_ENABLED(UNIT_TEST_DURATION) && uts->cur.test_count) {
	ulong avg;

	avg = uts->cur.duration_ms ?
	uts->cur.duration_ms /
	uts->cur.test_count : 0;
	if (avg > uts->worst_ms) {
	uts->worst_ms = avg;
	uts->worst = ste;
	}
	}
	}

	static int do_ut_all(struct unit_test_state uts, const char select_name,
	int runs_per_test, bool force_run, const char *test_insert)
	{
	int i;
	int retval;
	int any_fail = 0;

	for (i = 0; i < ARRAY_SIZE(suites); i++) {
	struct suite *ste = &suites[i];

	if (has_tests(ste)) {
	printf("----Running %s tests----\n", ste->name);
	retval = run_suite(uts, ste, select_name, runs_per_test,
	force_run, test_insert);
	if (!any_fail)
	any_fail = retval;
	update_stats(uts, ste);
	}
	}

	return any_fail;
	}

	static int do_ut_info(bool show_suites)
	{
	int suite_count, i;

	for (suite_count = 0, i = 0; i < ARRAY_SIZE(suites); i++) {
	struct suite *ste = &suites[i];

	if (has_tests(ste))
	suite_count++;
	}

	printf("Test suites: %d\n", suite_count);
	printf("Total tests: %d\n", (int)UNIT_TEST_ALL_COUNT());

	if (show_suites) {
	int i, total;

	puts("\nTests Suite Purpose");
	puts("\n----- ------------ -------------------------\n");
	for (i = 0, total = 0; i < ARRAY_SIZE(suites); i++) {
	struct suite *ste = &suites[i];
	long n_ent = ste->end - ste->start;

	if (n_ent) {
	printf("%5ld %-13.13s %s\n", n_ent, ste->name,
	ste->help);
	total += n_ent;
	}
	}
	puts("----- ------------ -------------------------\n");
	printf("%5d %-13.13s\n", total, "Total");

	if (UNIT_TEST_ALL_COUNT() != total)
	puts("Error: Suite test-count does not match total\n");
	}

	return 0;
	}

	static struct suite find_suite(const char name)
	{
	struct suite *ste;
	int i;

	for (i = 0, ste = suites; i < ARRAY_SIZE(suites); i++, ste++) {
	if (!strcmp(ste->name, name))
	return ste;
	}

	return NULL;
	}

	static int do_ut(struct cmd_tbl cmdtp, int flag, int argc, char const argv[])
	{
	const char test_insert = NULL, select_name;
	struct unit_test_state uts;
	bool show_suites = false;
	bool force_run = false;
	int runs_per_text = 1;
	struct suite *ste;
	char *name;
	int ret;

	/* drop initial "ut" arg */
	argc--;
	argv++;

	while (argc > 0 && *argv[0] == '-') {
	const char *str = argv[0];

	switch (str[1]) {
	case 'r':
	runs_per_text = dectoul(str + 2, NULL);
	break;
	case 'f':
	force_run = true;
	break;
	case 'I':
	test_insert = str + 2;
	if (!strchr(test_insert, ':'))
	return CMD_RET_USAGE;
	break;
	case 's':
	show_suites = true;
	break;
	}
	argv++;
	argc--;
	}

	if (argc < 1)
	return CMD_RET_USAGE;

	ut_init_state(&uts);
	name = argv[0];
	select_name = cmd_arg1(argc, argv);
	if (!strcmp(name, "all")) {
	ret = do_ut_all(&uts, select_name, runs_per_text, force_run,
	test_insert);
	} else if (!strcmp(name, "info")) {
	ret = do_ut_info(show_suites);
	} else {
	int any_fail = 0;
	const char *p;

	for (; p = strsep(&name, ","), p; name = NULL) {
	ste = find_suite(p);
	if (!ste) {
	printf("Suite '%s' not found\n", p);
	return CMD_RET_FAILURE;
	} else if (!has_tests(ste)) {
	/* perhaps a Kconfig option needs to be set? */
	printf("Suite '%s' is not enabled\n", p);
	return CMD_RET_FAILURE;
	}

	ret = run_suite(&uts, ste, select_name, runs_per_text,
	force_run, test_insert);
	if (!any_fail)
	any_fail = ret;
	update_stats(&uts, ste);
	}
	ret = any_fail;
	}
	show_stats(&uts);
	if (ret)
	return ret;
	ut_uninit_state(&uts);

	return 0;
	}

	U_BOOT_LONGHELP(ut,
	"[-rs] [-f] [-I<n>:<one_test>][<suites>] - run unit tests\n"
	" -r<runs> Number of times to run each test\n"
	" -f Force 'manual' tests to run as well\n"
	" -I Test to run after <n> other tests have run\n"
	" -s Show all suites with ut info\n"
	" <suites> Comma-separated list of suites to run\n"
	"\n"
	"Options for <suite>:\n"
	"all - execute all enabled tests\n"
	"info - show info about tests [and suites]"
	);

	U_BOOT_CMD(
	ut, CONFIG_SYS_MAXARGS, 1, do_ut,
	"unit tests", ut_help_text
	);