Branch data Line data Source code
1 : : /*
2 : : * Copyright (c) 2016 Intel Corporation
3 : : *
4 : : * SPDX-License-Identifier: Apache-2.0
5 : : */
6 : :
7 : : #include <zephyr/ztest.h>
8 : :
9 : : #include <zephyr/app_memory/app_memdomain.h>
10 : : #ifdef CONFIG_USERSPACE
11 : : #include <zephyr/sys/libc-hooks.h>
12 : : #endif
13 : : #include <zephyr/logging/log_ctrl.h>
14 : : #include <zephyr/sys/reboot.h>
15 : :
16 : : #include <zephyr/llext/symbol.h>
17 : :
18 : : #include <zephyr/sys/barrier.h>
19 : :
20 : : #ifdef KERNEL
21 : : static struct k_thread ztest_thread;
22 : : #endif
23 : : static bool failed_expectation;
24 : :
25 : : #ifdef CONFIG_ZTEST_SHELL
26 : : #include <zephyr/shell/shell.h>
27 : : #endif
28 : :
29 : : #ifdef CONFIG_ZTEST_SHUFFLE
30 : : #include <stdlib.h>
31 : : #include <time.h>
32 : : #include <zephyr/random/random.h>
33 : :
34 : : #define NUM_ITER_PER_SUITE CONFIG_ZTEST_SHUFFLE_SUITE_REPEAT_COUNT
35 : : #define NUM_ITER_PER_TEST CONFIG_ZTEST_SHUFFLE_TEST_REPEAT_COUNT
36 : : #else
37 : : #define NUM_ITER_PER_SUITE 1
38 : : #define NUM_ITER_PER_TEST 1
39 : : #endif
40 : :
41 : : #ifdef CONFIG_ZTEST_COVERAGE_RESET_BEFORE_TESTS
42 : : #include <coverage.h>
43 : : #endif
44 : :
45 : : /* ZTEST_DMEM and ZTEST_BMEM are used for the application shared memory test */
46 : :
47 : : /**
48 : : * @brief The current status of the test binary
49 : : */
50 : : enum ztest_status {
51 : : ZTEST_STATUS_OK,
52 : : ZTEST_STATUS_HAS_FAILURE,
53 : : ZTEST_STATUS_CRITICAL_ERROR
54 : : };
55 : :
56 : : /**
57 : : * @brief Tracks the current phase that ztest is operating in.
58 : : */
59 : : ZTEST_DMEM enum ztest_phase cur_phase = TEST_PHASE_FRAMEWORK;
60 : :
61 : : static ZTEST_BMEM enum ztest_status test_status = ZTEST_STATUS_OK;
62 : :
63 : : extern ZTEST_DMEM const struct ztest_arch_api ztest_api;
64 : :
65 : : static void __ztest_show_suite_summary(void);
66 : :
67 : 1 : static void end_report(void)
68 : : {
69 : 1 : __ztest_show_suite_summary();
70 [ - + ]: 1 : if (test_status) {
71 : 0 : TC_END_REPORT(TC_FAIL);
72 : : } else {
73 : 1 : TC_END_REPORT(TC_PASS);
74 : : }
75 : : }
76 : :
77 : 42 : static int cleanup_test(struct ztest_unit_test *test)
78 : : {
79 : 42 : int ret = TC_PASS;
80 : 42 : int mock_status;
81 : :
82 : 42 : mock_status = z_cleanup_mock();
83 : :
84 : : #ifdef KERNEL
85 : : /* we need to remove the ztest_thread information from the timeout_q.
86 : : * Because we reuse the same k_thread structure this would
87 : : * causes some problems.
88 : : */
89 : 42 : if (IS_ENABLED(CONFIG_MULTITHREADING)) {
90 : 42 : k_thread_abort(&ztest_thread);
91 : : }
92 : : #endif
93 : :
94 : 42 : if (!ret && mock_status == 1) {
95 : : PRINT_DATA("Test %s failed: Unused mock parameter values\n", test->name);
96 : : ret = TC_FAIL;
97 : 42 : } else if (!ret && mock_status == 2) {
98 : : PRINT_DATA("Test %s failed: Unused mock return values\n", test->name);
99 : : ret = TC_FAIL;
100 : : } else {
101 : 42 : ;
102 : : }
103 : :
104 : 42 : return ret;
105 : : }
106 : :
107 : : #ifdef KERNEL
108 : :
109 : : #if defined(CONFIG_SMP) && (CONFIG_MP_MAX_NUM_CPUS > 1)
110 : : #define MAX_NUM_CPUHOLD (CONFIG_MP_MAX_NUM_CPUS - 1)
111 : : #define CPUHOLD_STACK_SZ (512 + CONFIG_TEST_EXTRA_STACK_SIZE)
112 : :
113 : : struct cpuhold_pool_item {
114 : : struct k_thread thread;
115 : : bool used;
116 : : };
117 : :
118 : : static struct cpuhold_pool_item cpuhold_pool_items[MAX_NUM_CPUHOLD + 1];
119 : :
120 : : K_KERNEL_STACK_ARRAY_DEFINE(cpuhold_stacks, MAX_NUM_CPUHOLD + 1, CPUHOLD_STACK_SZ);
121 : :
122 : : static struct k_sem cpuhold_sem;
123 : :
124 : : volatile int cpuhold_active;
125 : : volatile bool cpuhold_spawned;
126 : :
127 : : static int find_unused_thread(void)
128 : : {
129 : : for (unsigned int i = 0; i <= MAX_NUM_CPUHOLD; i++) {
130 : : if (!cpuhold_pool_items[i].used) {
131 : : return i;
132 : : }
133 : : }
134 : :
135 : : return -1;
136 : : }
137 : :
138 : : static void mark_thread_unused(struct k_thread *thread)
139 : : {
140 : : for (unsigned int i = 0; i <= MAX_NUM_CPUHOLD; i++) {
141 : : if (&cpuhold_pool_items[i].thread == thread) {
142 : : cpuhold_pool_items[i].used = false;
143 : : }
144 : : }
145 : : }
146 : :
147 : : static inline void wait_for_thread_to_switch_out(struct k_thread *thread)
148 : : {
149 : : unsigned int key = arch_irq_lock();
150 : : volatile void **shp = (void *)&thread->switch_handle;
151 : :
152 : : while (*shp == NULL) {
153 : : arch_spin_relax();
154 : : }
155 : : /* Read barrier: don't allow any subsequent loads in the
156 : : * calling code to reorder before we saw switch_handle go
157 : : * non-null.
158 : : */
159 : : barrier_dmem_fence_full();
160 : :
161 : : arch_irq_unlock(key);
162 : : }
163 : :
164 : : /* "Holds" a CPU for use with the "1cpu" test cases. Note that we
165 : : * can't use tools like the cpumask feature because we have tests that
166 : : * may need to control that configuration themselves. We do this at
167 : : * the lowest level, but locking interrupts directly and spinning.
168 : : */
169 : : static void cpu_hold(void *arg1, void *arg2, void *arg3)
170 : : {
171 : : struct k_thread *thread = arg1;
172 : : unsigned int idx = (unsigned int)(uintptr_t)arg2;
173 : : char tname[CONFIG_THREAD_MAX_NAME_LEN];
174 : :
175 : : ARG_UNUSED(arg3);
176 : :
177 : : if (arch_proc_id() == 0) {
178 : : int i;
179 : :
180 : : i = find_unused_thread();
181 : :
182 : : __ASSERT_NO_MSG(i != -1);
183 : :
184 : : cpuhold_spawned = false;
185 : :
186 : : cpuhold_pool_items[i].used = true;
187 : : k_thread_create(&cpuhold_pool_items[i].thread, cpuhold_stacks[i], CPUHOLD_STACK_SZ,
188 : : cpu_hold, k_current_get(), (void *)(uintptr_t)idx, NULL,
189 : : K_HIGHEST_THREAD_PRIO, 0, K_NO_WAIT);
190 : :
191 : : /*
192 : : * Busy-wait until we know the spawned thread is running to
193 : : * ensure it does not spawn on CPU0.
194 : : */
195 : :
196 : : while (!cpuhold_spawned) {
197 : : k_busy_wait(1000);
198 : : }
199 : :
200 : : return;
201 : : }
202 : :
203 : : if (thread != NULL) {
204 : : cpuhold_spawned = true;
205 : :
206 : : /* Busywait until a new thread is scheduled in on CPU0 */
207 : :
208 : : wait_for_thread_to_switch_out(thread);
209 : :
210 : : mark_thread_unused(thread);
211 : : }
212 : :
213 : : if (IS_ENABLED(CONFIG_THREAD_NAME)) {
214 : : snprintk(tname, CONFIG_THREAD_MAX_NAME_LEN, "cpuhold%02d", idx);
215 : : k_thread_name_set(k_current_get(), tname);
216 : : }
217 : :
218 : : uint32_t dt, start_ms = k_uptime_get_32();
219 : : unsigned int key = arch_irq_lock();
220 : :
221 : : k_sem_give(&cpuhold_sem);
222 : :
223 : : #if (defined(CONFIG_ARM64) || defined(CONFIG_RISCV)) && defined(CONFIG_FPU_SHARING)
224 : : /*
225 : : * We'll be spinning with IRQs disabled. The flush-your-FPU request
226 : : * IPI will never be serviced during that time. Therefore we flush
227 : : * the FPU preemptively here to prevent any other CPU waiting after
228 : : * this CPU forever and deadlock the system.
229 : : */
230 : : k_float_disable(_current_cpu->arch.fpu_owner);
231 : : #endif
232 : :
233 : : while (cpuhold_active) {
234 : : k_busy_wait(1000);
235 : : }
236 : :
237 : : /* Holding the CPU via spinning is expensive, and abusing this
238 : : * for long-running test cases tends to overload the CI system
239 : : * (qemu runs separate CPUs in different threads, but the CI
240 : : * logic views it as one "job") and cause other test failures.
241 : : */
242 : : dt = k_uptime_get_32() - start_ms;
243 : : zassert_true(dt < CONFIG_ZTEST_CPU_HOLD_TIME_MS, "1cpu test took too long (%d ms)", dt);
244 : : arch_irq_unlock(key);
245 : : }
246 : : #endif /* CONFIG_SMP && (CONFIG_MP_MAX_NUM_CPUS > 1) */
247 : :
248 : 0 : void z_impl_z_test_1cpu_start(void)
249 : : {
250 : : #if defined(CONFIG_SMP) && (CONFIG_MP_MAX_NUM_CPUS > 1)
251 : : unsigned int num_cpus = arch_num_cpus();
252 : : int j;
253 : :
254 : : cpuhold_active = 1;
255 : :
256 : : k_sem_init(&cpuhold_sem, 0, 999);
257 : :
258 : : /* Spawn N-1 threads to "hold" the other CPUs, waiting for
259 : : * each to signal us that it's locked and spinning.
260 : : */
261 : : for (int i = 0; i < num_cpus - 1; i++) {
262 : : j = find_unused_thread();
263 : :
264 : : __ASSERT_NO_MSG(j != -1);
265 : :
266 : : cpuhold_pool_items[j].used = true;
267 : : k_thread_create(&cpuhold_pool_items[j].thread, cpuhold_stacks[j], CPUHOLD_STACK_SZ,
268 : : cpu_hold, NULL, (void *)(uintptr_t)i, NULL, K_HIGHEST_THREAD_PRIO,
269 : : 0, K_NO_WAIT);
270 : : k_sem_take(&cpuhold_sem, K_FOREVER);
271 : : }
272 : : #endif
273 : 0 : }
274 : :
275 : 0 : void z_impl_z_test_1cpu_stop(void)
276 : : {
277 : : #if defined(CONFIG_SMP) && (CONFIG_MP_MAX_NUM_CPUS > 1)
278 : : cpuhold_active = 0;
279 : :
280 : : for (int i = 0; i <= MAX_NUM_CPUHOLD; i++) {
281 : : if (cpuhold_pool_items[i].used) {
282 : : k_thread_abort(&cpuhold_pool_items[i].thread);
283 : : cpuhold_pool_items[i].used = false;
284 : : }
285 : : }
286 : : #endif
287 : 0 : }
288 : :
289 : : #ifdef CONFIG_USERSPACE
290 : : void z_vrfy_z_test_1cpu_start(void)
291 : : {
292 : : z_impl_z_test_1cpu_start();
293 : : }
294 : : #include <zephyr/syscalls/z_test_1cpu_start_mrsh.c>
295 : :
296 : : void z_vrfy_z_test_1cpu_stop(void)
297 : : {
298 : : z_impl_z_test_1cpu_stop();
299 : : }
300 : : #include <zephyr/syscalls/z_test_1cpu_stop_mrsh.c>
301 : : #endif /* CONFIG_USERSPACE */
302 : : #endif
303 : :
304 : 84 : __maybe_unused static void run_test_rules(bool is_before, struct ztest_unit_test *test, void *data)
305 : : {
306 : 84 : for (struct ztest_test_rule *rule = _ztest_test_rule_list_start;
307 [ - + ]: 84 : rule < _ztest_test_rule_list_end; ++rule) {
308 [ # # # # ]: 0 : if (is_before && rule->before_each) {
309 : 0 : rule->before_each(test, data);
310 [ # # # # ]: 0 : } else if (!is_before && rule->after_each) {
311 : 0 : rule->after_each(test, data);
312 : : }
313 : : }
314 : 84 : }
315 : :
316 : 42 : static void run_test_functions(struct ztest_suite_node *suite, struct ztest_unit_test *test,
317 : : void *data)
318 : : {
319 : 42 : __ztest_set_test_phase(TEST_PHASE_TEST);
320 : 42 : test->test(data);
321 : 42 : }
322 : :
323 : : COND_CODE_1(KERNEL, (ZTEST_BMEM), ()) static enum ztest_result test_result;
324 : :
325 : 42 : static int get_final_test_result(const struct ztest_unit_test *test, int ret)
326 : : {
327 : 42 : enum ztest_expected_result expected_result = -1;
328 : :
329 : 42 : for (struct ztest_expected_result_entry *expectation =
330 : : _ztest_expected_result_entry_list_start;
331 [ - + ]: 42 : expectation < _ztest_expected_result_entry_list_end; ++expectation) {
332 [ # # ]: 0 : if (strcmp(expectation->test_name, test->name) == 0 &&
333 [ # # ]: 0 : strcmp(expectation->test_suite_name, test->test_suite_name) == 0) {
334 : 0 : expected_result = expectation->expected_result;
335 : 0 : break;
336 : : }
337 : : }
338 : :
339 [ - + ]: 42 : if (expected_result == ZTEST_EXPECTED_RESULT_FAIL) {
340 : : /* Expected a failure:
341 : : * - If we got a failure, return TC_PASS
342 : : * - Otherwise force a failure
343 : : */
344 : 0 : return (ret == TC_FAIL) ? TC_PASS : TC_FAIL;
345 : : }
346 [ - + ]: 42 : if (expected_result == ZTEST_EXPECTED_RESULT_SKIP) {
347 : : /* Expected a skip:
348 : : * - If we got a skip, return TC_PASS
349 : : * - Otherwise force a failure
350 : : */
351 : 0 : return (ret == TC_SKIP) ? TC_PASS : TC_FAIL;
352 : : }
353 : : /* No expectation was made, no change is needed. */
354 : : return ret;
355 : : }
356 : :
357 : : /**
358 : : * @brief Get a friendly name string for a given test phrase.
359 : : *
360 : : * @param phase an enum ztest_phase value describing the desired test phase
361 : : * @returns a string name for `phase`
362 : : */
363 : 0 : static inline const char *get_friendly_phase_name(enum ztest_phase phase)
364 : : {
365 [ # # ]: 0 : switch (phase) {
366 : : case TEST_PHASE_SETUP:
367 : : return "setup";
368 : : case TEST_PHASE_BEFORE:
369 : : return "before";
370 : : case TEST_PHASE_TEST:
371 : : return "test";
372 : : case TEST_PHASE_AFTER:
373 : : return "after";
374 : : case TEST_PHASE_TEARDOWN:
375 : : return "teardown";
376 : : case TEST_PHASE_FRAMEWORK:
377 : : return "framework";
378 : : default:
379 : : return "(unknown)";
380 : : }
381 : : }
382 : :
383 : : static bool current_test_failed_assumption;
384 : 0 : void ztest_skip_failed_assumption(void)
385 : : {
386 : 0 : if (IS_ENABLED(CONFIG_ZTEST_FAIL_ON_ASSUME)) {
387 : 0 : current_test_failed_assumption = true;
388 : : }
389 : 0 : ztest_test_skip();
390 : 0 : }
391 : :
392 : : #ifndef KERNEL
393 : :
394 : : /* Static code analysis tool can raise a violation that the standard header
395 : : * <setjmp.h> shall not be used.
396 : : *
397 : : * setjmp is using in a test code, not in a runtime code, it is acceptable.
398 : : * It is a deliberate deviation.
399 : : */
400 : : #include <setjmp.h> /* parasoft-suppress MISRAC2012-RULE_21_4-a MISRAC2012-RULE_21_4-b*/
401 : : #include <signal.h>
402 : : #include <stdlib.h>
403 : : #include <string.h>
404 : :
405 : : #define FAIL_FAST 0
406 : :
407 : : static jmp_buf test_fail;
408 : : static jmp_buf test_pass;
409 : : static jmp_buf test_skip;
410 : : static jmp_buf stack_fail;
411 : : static jmp_buf test_suite_fail;
412 : :
413 : : void ztest_test_fail(void)
414 : : {
415 : : switch (cur_phase) {
416 : : case TEST_PHASE_SETUP:
417 : : PRINT_DATA(" at %s function\n", get_friendly_phase_name(cur_phase));
418 : : longjmp(test_suite_fail, 1);
419 : : case TEST_PHASE_BEFORE:
420 : : case TEST_PHASE_TEST:
421 : : PRINT_DATA(" at %s function\n", get_friendly_phase_name(cur_phase));
422 : : longjmp(test_fail, 1);
423 : : case TEST_PHASE_AFTER:
424 : : case TEST_PHASE_TEARDOWN:
425 : : case TEST_PHASE_FRAMEWORK:
426 : : PRINT_DATA(" ERROR: cannot fail in test phase '%s()', bailing\n",
427 : : get_friendly_phase_name(cur_phase));
428 : : longjmp(stack_fail, 1);
429 : : }
430 : : }
431 : : EXPORT_SYMBOL(ztest_test_fail);
432 : :
433 : : void ztest_test_pass(void)
434 : : {
435 : : if (cur_phase == TEST_PHASE_TEST) {
436 : : longjmp(test_pass, 1);
437 : : }
438 : : PRINT_DATA(" ERROR: cannot pass in test phase '%s()', bailing\n",
439 : : get_friendly_phase_name(cur_phase));
440 : : longjmp(stack_fail, 1);
441 : : }
442 : : EXPORT_SYMBOL(ztest_test_pass);
443 : :
444 : : void ztest_test_skip(void)
445 : : {
446 : : switch (cur_phase) {
447 : : case TEST_PHASE_SETUP:
448 : : case TEST_PHASE_BEFORE:
449 : : case TEST_PHASE_TEST:
450 : : longjmp(test_skip, 1);
451 : : default:
452 : : PRINT_DATA(" ERROR: cannot skip in test phase '%s()', bailing\n",
453 : : get_friendly_phase_name(cur_phase));
454 : : longjmp(stack_fail, 1);
455 : : }
456 : : }
457 : : EXPORT_SYMBOL(ztest_test_skip);
458 : :
459 : : void ztest_test_expect_fail(void)
460 : : {
461 : : failed_expectation = true;
462 : :
463 : : switch (cur_phase) {
464 : : case TEST_PHASE_SETUP:
465 : : PRINT_DATA(" at %s function\n", get_friendly_phase_name(cur_phase));
466 : : break;
467 : : case TEST_PHASE_BEFORE:
468 : : case TEST_PHASE_TEST:
469 : : PRINT_DATA(" at %s function\n", get_friendly_phase_name(cur_phase));
470 : : break;
471 : : case TEST_PHASE_AFTER:
472 : : case TEST_PHASE_TEARDOWN:
473 : : case TEST_PHASE_FRAMEWORK:
474 : : PRINT_DATA(" ERROR: cannot fail in test phase '%s()', bailing\n",
475 : : get_friendly_phase_name(cur_phase));
476 : : longjmp(stack_fail, 1);
477 : : }
478 : : }
479 : :
480 : : static int run_test(struct ztest_suite_node *suite, struct ztest_unit_test *test, void *data)
481 : : {
482 : : int ret = TC_PASS;
483 : :
484 : : TC_START(test->name);
485 : : __ztest_set_test_phase(TEST_PHASE_BEFORE);
486 : :
487 : : if (test_result == ZTEST_RESULT_SUITE_FAIL) {
488 : : ret = TC_FAIL;
489 : : goto out;
490 : : }
491 : :
492 : : if (setjmp(test_fail)) {
493 : : ret = TC_FAIL;
494 : : goto out;
495 : : }
496 : :
497 : : if (setjmp(test_pass)) {
498 : : ret = TC_PASS;
499 : : goto out;
500 : : }
501 : :
502 : : if (setjmp(test_skip)) {
503 : : ret = TC_SKIP;
504 : : goto out;
505 : : }
506 : :
507 : : run_test_rules(/*is_before=*/true, test, data);
508 : : if (suite->before) {
509 : : suite->before(data);
510 : : }
511 : : run_test_functions(suite, test, data);
512 : : out:
513 : : if (failed_expectation) {
514 : : failed_expectation = false;
515 : : ret = TC_FAIL;
516 : : }
517 : :
518 : : __ztest_set_test_phase(TEST_PHASE_AFTER);
519 : : if (test_result != ZTEST_RESULT_SUITE_FAIL) {
520 : : if (suite->after != NULL) {
521 : : suite->after(data);
522 : : }
523 : : run_test_rules(/*is_before=*/false, test, data);
524 : : }
525 : : __ztest_set_test_phase(TEST_PHASE_FRAMEWORK);
526 : : ret |= cleanup_test(test);
527 : :
528 : : ret = get_final_test_result(test, ret);
529 : : Z_TC_END_RESULT(ret, test->name);
530 : : if (ret == TC_SKIP && current_test_failed_assumption) {
531 : : test_status = 1;
532 : : }
533 : :
534 : : return ret;
535 : : }
536 : :
537 : : #else /* KERNEL */
538 : :
539 : : /* Zephyr's probably going to cause all tests to fail if one test fails, so
540 : : * skip the rest of tests if one of them fails
541 : : */
542 : : #ifdef CONFIG_ZTEST_FAIL_FAST
543 : : #define FAIL_FAST 1
544 : : #else
545 : : #define FAIL_FAST 0
546 : : #endif
547 : :
548 : : K_THREAD_STACK_DEFINE(ztest_thread_stack, CONFIG_ZTEST_STACK_SIZE + CONFIG_TEST_EXTRA_STACK_SIZE);
549 : :
550 : 0 : static void test_finalize(void)
551 : : {
552 : 0 : if (IS_ENABLED(CONFIG_MULTITHREADING)) {
553 : 0 : k_thread_abort(&ztest_thread);
554 [ # # ]: 0 : if (k_is_in_isr()) {
555 : 0 : return;
556 : : }
557 : :
558 : 0 : k_thread_abort(k_current_get());
559 : 0 : CODE_UNREACHABLE;
560 : : }
561 : : }
562 : :
563 : 0 : void ztest_test_fail(void)
564 : : {
565 [ # # # ]: 0 : switch (cur_phase) {
566 : 0 : case TEST_PHASE_SETUP:
567 : 0 : __ztest_set_test_result(ZTEST_RESULT_SUITE_FAIL);
568 : 0 : break;
569 : 0 : case TEST_PHASE_BEFORE:
570 : : case TEST_PHASE_TEST:
571 : 0 : __ztest_set_test_result(ZTEST_RESULT_FAIL);
572 : 0 : test_finalize();
573 : 0 : break;
574 : 0 : default:
575 : 0 : PRINT_DATA(" ERROR: cannot fail in test phase '%s()', bailing\n",
576 : : get_friendly_phase_name(cur_phase));
577 : 0 : test_status = ZTEST_STATUS_CRITICAL_ERROR;
578 : 0 : break;
579 : : }
580 : 0 : }
581 : : EXPORT_SYMBOL(ztest_test_fail);
582 : :
583 : 0 : void ztest_test_pass(void)
584 : : {
585 [ # # ]: 0 : switch (cur_phase) {
586 : 0 : case TEST_PHASE_TEST:
587 : 0 : __ztest_set_test_result(ZTEST_RESULT_PASS);
588 : 0 : test_finalize();
589 : 0 : break;
590 : 0 : default:
591 : 0 : PRINT_DATA(" ERROR: cannot pass in test phase '%s()', bailing\n",
592 : : get_friendly_phase_name(cur_phase));
593 : 0 : test_status = ZTEST_STATUS_CRITICAL_ERROR;
594 [ # # ]: 0 : if (cur_phase == TEST_PHASE_BEFORE) {
595 : 0 : test_finalize();
596 : : }
597 : : }
598 : 0 : }
599 : : EXPORT_SYMBOL(ztest_test_pass);
600 : :
601 : 0 : void ztest_test_skip(void)
602 : : {
603 [ # # # ]: 0 : switch (cur_phase) {
604 : 0 : case TEST_PHASE_SETUP:
605 : 0 : __ztest_set_test_result(ZTEST_RESULT_SUITE_SKIP);
606 : 0 : break;
607 : 0 : case TEST_PHASE_BEFORE:
608 : : case TEST_PHASE_TEST:
609 : 0 : __ztest_set_test_result(ZTEST_RESULT_SKIP);
610 : 0 : test_finalize();
611 : 0 : break;
612 : 0 : default:
613 : 0 : PRINT_DATA(" ERROR: cannot skip in test phase '%s()', bailing\n",
614 : : get_friendly_phase_name(cur_phase));
615 : 0 : test_status = ZTEST_STATUS_CRITICAL_ERROR;
616 : 0 : break;
617 : : }
618 : 0 : }
619 : : EXPORT_SYMBOL(ztest_test_skip);
620 : :
621 : 0 : void ztest_test_expect_fail(void)
622 : : {
623 : 0 : failed_expectation = true;
624 : 0 : }
625 : :
626 : 0 : void ztest_simple_1cpu_before(void *data)
627 : : {
628 : 0 : ARG_UNUSED(data);
629 : 0 : z_test_1cpu_start();
630 : 0 : }
631 : :
632 : 0 : void ztest_simple_1cpu_after(void *data)
633 : : {
634 : 0 : ARG_UNUSED(data);
635 : 0 : z_test_1cpu_stop();
636 : 0 : }
637 : :
638 : 42 : static void test_cb(void *a, void *b, void *c)
639 : : {
640 : 42 : struct ztest_suite_node *suite = a;
641 : 42 : struct ztest_unit_test *test = b;
642 : 42 : const bool config_user_mode = FIELD_GET(K_USER, test->thread_options) != 0;
643 : :
644 : 42 : if (!IS_ENABLED(CONFIG_USERSPACE) || !k_is_user_context()) {
645 : 42 : __ztest_set_test_result(ZTEST_RESULT_PENDING);
646 : 42 : run_test_rules(/*is_before=*/true, test, /*data=*/c);
647 [ - + ]: 42 : if (suite->before) {
648 : 0 : suite->before(/*data=*/c);
649 : : }
650 : 42 : if (IS_ENABLED(CONFIG_USERSPACE) && config_user_mode) {
651 : : k_thread_user_mode_enter(test_cb, a, b, c);
652 : : }
653 : : }
654 : 42 : run_test_functions(suite, test, c);
655 : 42 : __ztest_set_test_result(ZTEST_RESULT_PASS);
656 : 42 : }
657 : :
658 : 42 : static int run_test(struct ztest_suite_node *suite, struct ztest_unit_test *test, void *data)
659 : : {
660 : 42 : int ret = TC_PASS;
661 : :
662 : : #if CONFIG_ZTEST_TEST_DELAY_MS > 0
663 : : k_busy_wait(CONFIG_ZTEST_TEST_DELAY_MS * USEC_PER_MSEC);
664 : : #endif
665 : 42 : TC_START(test->name);
666 : :
667 : 42 : __ztest_set_test_phase(TEST_PHASE_BEFORE);
668 : :
669 : : /* If the suite's setup function marked us as skipped, don't bother
670 : : * running the tests.
671 : : */
672 : 42 : if (IS_ENABLED(CONFIG_MULTITHREADING)) {
673 : 42 : get_start_time_cyc();
674 : 42 : k_thread_create(&ztest_thread, ztest_thread_stack,
675 : : K_THREAD_STACK_SIZEOF(ztest_thread_stack), test_cb, suite, test,
676 : 42 : data, CONFIG_ZTEST_THREAD_PRIORITY, K_INHERIT_PERMS, K_FOREVER);
677 : :
678 : 42 : k_thread_access_grant(&ztest_thread, suite, test, suite->stats);
679 [ + - ]: 42 : if (test->name != NULL) {
680 : 42 : k_thread_name_set(&ztest_thread, test->name);
681 : : }
682 : : /* Only start the thread if we're not skipping the suite */
683 [ + - ]: 42 : if (test_result != ZTEST_RESULT_SUITE_SKIP &&
684 : : test_result != ZTEST_RESULT_SUITE_FAIL) {
685 : 42 : k_thread_start(&ztest_thread);
686 : 42 : k_thread_join(&ztest_thread, K_FOREVER);
687 : : }
688 : : } else if (test_result != ZTEST_RESULT_SUITE_SKIP &&
689 : : test_result != ZTEST_RESULT_SUITE_FAIL) {
690 : : __ztest_set_test_result(ZTEST_RESULT_PENDING);
691 : : get_start_time_cyc();
692 : : run_test_rules(/*is_before=*/true, test, data);
693 : : if (suite->before) {
694 : : suite->before(data);
695 : : }
696 : : run_test_functions(suite, test, data);
697 : : }
698 : :
699 : 42 : __ztest_set_test_phase(TEST_PHASE_AFTER);
700 [ - + ]: 42 : if (suite->after != NULL) {
701 : 0 : suite->after(data);
702 : : }
703 : 42 : run_test_rules(/*is_before=*/false, test, data);
704 : :
705 : 42 : get_test_duration_ms();
706 [ - + ]: 42 : if (tc_spend_time > test->stats->duration_worst_ms) {
707 : 0 : test->stats->duration_worst_ms = tc_spend_time;
708 : : }
709 : :
710 : 42 : __ztest_set_test_phase(TEST_PHASE_FRAMEWORK);
711 : :
712 : : /* Flush all logs in case deferred mode and default logging thread are used. */
713 : 42 : while (IS_ENABLED(CONFIG_TEST_LOGGING_FLUSH_AFTER_TEST) &&
714 : : IS_ENABLED(CONFIG_LOG_PROCESS_THREAD) && log_data_pending()) {
715 : : k_msleep(100);
716 : : }
717 : :
718 [ + - - + ]: 42 : if (test_result == ZTEST_RESULT_FAIL || test_result == ZTEST_RESULT_SUITE_FAIL ||
719 : : failed_expectation) {
720 : 0 : ret = TC_FAIL;
721 : 0 : failed_expectation = false;
722 [ - + ]: 42 : } else if (test_result == ZTEST_RESULT_SKIP || test_result == ZTEST_RESULT_SUITE_SKIP) {
723 : 0 : ret = TC_SKIP;
724 : : }
725 : :
726 : 42 : if (test_result == ZTEST_RESULT_PASS || !FAIL_FAST) {
727 : 42 : ret |= cleanup_test(test);
728 : : }
729 : :
730 : 42 : ret = get_final_test_result(test, ret);
731 : 42 : Z_TC_END_RESULT(ret, test->name);
732 [ - + - - ]: 42 : if (ret == TC_SKIP && current_test_failed_assumption) {
733 : 0 : test_status = 1;
734 : : }
735 : :
736 : 42 : return ret;
737 : : }
738 : :
739 : : #endif /* !KERNEL */
740 : :
741 : 42 : static struct ztest_suite_node *ztest_find_test_suite(const char *name)
742 : : {
743 : 42 : struct ztest_suite_node *node;
744 : :
745 [ + - ]: 42 : for (node = _ztest_suite_node_list_start; node < _ztest_suite_node_list_end; ++node) {
746 [ + - ]: 42 : if (strcmp(name, node->name) == 0) {
747 : 42 : return node;
748 : : }
749 : : }
750 : :
751 : : return NULL;
752 : : }
753 : :
754 : 172 : struct ztest_unit_test *z_ztest_get_next_test(const char *suite, struct ztest_unit_test *prev)
755 : : {
756 [ + + ]: 172 : struct ztest_unit_test *test = (prev == NULL) ? _ztest_unit_test_list_start : prev + 1;
757 : :
758 [ + + ]: 172 : for (; test < _ztest_unit_test_list_end; ++test) {
759 [ + - ]: 168 : if (strcmp(suite, test->test_suite_name) == 0) {
760 : 168 : return test;
761 : : }
762 : : }
763 : : return NULL;
764 : : }
765 : :
766 : : #if CONFIG_ZTEST_SHUFFLE
767 : : static void z_ztest_shuffle(bool shuffle, void *dest[], intptr_t start, size_t num_items,
768 : : size_t element_size)
769 : : {
770 : : /* Initialize dest array */
771 : : for (size_t i = 0; i < num_items; ++i) {
772 : : dest[i] = (void *)(start + (i * element_size));
773 : : }
774 : : void *tmp;
775 : :
776 : : /* Shuffle dest array */
777 : : if (shuffle) {
778 : : for (size_t i = num_items - 1; i > 0; i--) {
779 : : int j = sys_rand32_get() % (i + 1);
780 : :
781 : : if (i != j) {
782 : : tmp = dest[j];
783 : : dest[j] = dest[i];
784 : : dest[i] = tmp;
785 : : }
786 : : }
787 : : }
788 : : }
789 : : #endif
790 : :
791 : 1 : static int z_ztest_run_test_suite_ptr(struct ztest_suite_node *suite, bool shuffle, int suite_iter,
792 : : int case_iter, void *param)
793 : : {
794 : 1 : struct ztest_unit_test *test = NULL;
795 : 1 : void *data = NULL;
796 : 1 : int fail = 0;
797 : 1 : int tc_result = TC_PASS;
798 : :
799 : 1 : if (FAIL_FAST && test_status != ZTEST_STATUS_OK) {
800 : : return test_status;
801 : : }
802 : :
803 [ - + ]: 1 : if (suite == NULL) {
804 : 0 : test_status = ZTEST_STATUS_CRITICAL_ERROR;
805 : 0 : return -1;
806 : : }
807 : :
808 : : #ifndef KERNEL
809 : : if (setjmp(stack_fail)) {
810 : : PRINT_DATA("TESTSUITE crashed.\n");
811 : : test_status = ZTEST_STATUS_CRITICAL_ERROR;
812 : : end_report();
813 : : exit(1);
814 : : }
815 : : #else
816 : 1 : k_object_access_all_grant(&ztest_thread);
817 : : #endif
818 : :
819 : 1 : TC_SUITE_START(suite->name);
820 : 1 : current_test_failed_assumption = false;
821 : 1 : __ztest_set_test_result(ZTEST_RESULT_PENDING);
822 : 1 : __ztest_set_test_phase(TEST_PHASE_SETUP);
823 : : #ifndef KERNEL
824 : : if (setjmp(test_suite_fail)) {
825 : : __ztest_set_test_result(ZTEST_RESULT_SUITE_FAIL);
826 : : }
827 : : #endif
828 [ + - - + ]: 1 : if (test_result != ZTEST_RESULT_SUITE_FAIL && suite->setup != NULL) {
829 : 0 : data = suite->setup();
830 : : }
831 [ - + ]: 1 : if (param != NULL) {
832 : 0 : data = param;
833 : : }
834 : :
835 [ + + ]: 2 : for (int i = 0; i < case_iter; i++) {
836 : : #ifdef CONFIG_ZTEST_SHUFFLE
837 : : struct ztest_unit_test *tests_to_run[ZTEST_TEST_COUNT];
838 : :
839 : : memset(tests_to_run, 0, ZTEST_TEST_COUNT * sizeof(struct ztest_unit_test *));
840 : : z_ztest_shuffle(shuffle, (void **)tests_to_run,
841 : : (intptr_t)_ztest_unit_test_list_start, ZTEST_TEST_COUNT,
842 : : sizeof(struct ztest_unit_test));
843 : : for (size_t j = 0; j < ZTEST_TEST_COUNT; ++j) {
844 : : test = tests_to_run[j];
845 : : /* Make sure that the test belongs to this suite */
846 : : if (strcmp(suite->name, test->test_suite_name) != 0) {
847 : : continue;
848 : : }
849 : : if (ztest_api.should_test_run(suite->name, test->name)) {
850 : : test->stats->run_count++;
851 : : tc_result = run_test(suite, test, data);
852 : : if (tc_result == TC_PASS) {
853 : : test->stats->pass_count++;
854 : : } else if (tc_result == TC_SKIP) {
855 : : test->stats->skip_count++;
856 : : } else if (tc_result == TC_FAIL) {
857 : : test->stats->fail_count++;
858 : : }
859 : : if (tc_result == TC_FAIL) {
860 : : fail++;
861 : : }
862 : : }
863 : :
864 : : if ((fail && FAIL_FAST) || test_status == ZTEST_STATUS_CRITICAL_ERROR) {
865 : : break;
866 : : }
867 : : }
868 : : #else
869 [ + + ]: 43 : while (((test = z_ztest_get_next_test(suite->name, test)) != NULL)) {
870 [ + - ]: 42 : if (ztest_api.should_test_run(suite->name, test->name)) {
871 : 42 : test->stats->run_count++;
872 : 42 : tc_result = run_test(suite, test, data);
873 [ + - ]: 42 : if (tc_result == TC_PASS) {
874 : 42 : test->stats->pass_count++;
875 [ # # ]: 0 : } else if (tc_result == TC_SKIP) {
876 : 0 : test->stats->skip_count++;
877 [ # # ]: 0 : } else if (tc_result == TC_FAIL) {
878 : 0 : test->stats->fail_count++;
879 : : }
880 : :
881 [ - + ]: 42 : if (tc_result == TC_FAIL) {
882 : 0 : fail++;
883 : : }
884 : : }
885 : :
886 [ + - ]: 42 : if ((fail && FAIL_FAST) || test_status == ZTEST_STATUS_CRITICAL_ERROR) {
887 : : break;
888 : : }
889 : : }
890 : : #endif
891 [ + - - + ]: 1 : if (test_status == ZTEST_STATUS_OK && fail != 0) {
892 : 0 : test_status = ZTEST_STATUS_HAS_FAILURE;
893 : : }
894 : : }
895 : :
896 [ + - ]: 1 : TC_SUITE_END(suite->name, (fail > 0 ? TC_FAIL : TC_PASS));
897 : 1 : __ztest_set_test_phase(TEST_PHASE_TEARDOWN);
898 [ - + ]: 1 : if (suite->teardown != NULL) {
899 : 0 : suite->teardown(data);
900 : : }
901 : :
902 : : return fail;
903 : : }
904 : :
905 : 0 : int z_ztest_run_test_suite(const char *name, bool shuffle,
906 : : int suite_iter, int case_iter, void *param)
907 : : {
908 : 0 : return z_ztest_run_test_suite_ptr(ztest_find_test_suite(name), shuffle, suite_iter,
909 : : case_iter, param);
910 : : }
911 : :
912 : : #ifdef CONFIG_USERSPACE
913 : : K_APPMEM_PARTITION_DEFINE(ztest_mem_partition);
914 : : #endif
915 : :
916 : 1 : static void __ztest_init_unit_test_result_for_suite(struct ztest_suite_node *suite)
917 : : {
918 : 1 : struct ztest_unit_test *test = NULL;
919 : :
920 [ + + ]: 43 : while (((test = z_ztest_get_next_test(suite->name, test)) != NULL)) {
921 : 42 : test->stats->run_count = 0;
922 : 42 : test->stats->skip_count = 0;
923 : 42 : test->stats->fail_count = 0;
924 : 42 : test->stats->pass_count = 0;
925 : 42 : test->stats->duration_worst_ms = 0;
926 : : }
927 : 1 : }
928 : :
929 : 19 : static void flush_log(void)
930 : : {
931 : 19 : if (IS_ENABLED(CONFIG_LOG_PROCESS_THREAD)) {
932 : : while (log_data_pending()) {
933 : : k_sleep(K_MSEC(10));
934 : : }
935 : : k_sleep(K_MSEC(10));
936 : : } else {
937 [ - + ]: 38 : while (LOG_PROCESS()) {
938 : 19 : }
939 : : }
940 : 19 : }
941 : :
942 : : /* Show one line summary for a test suite.
943 : : */
944 : 1 : static void __ztest_show_suite_summary_oneline(struct ztest_suite_node *suite)
945 : : {
946 : 1 : int distinct_pass = 0, distinct_fail = 0, distinct_skip = 0, distinct_total = 0;
947 : 1 : int effective_total = 0;
948 : 1 : int expanded_pass = 0, expanded_passrate = 0;
949 : 1 : int passrate_major = 0, passrate_minor = 0, passrate_tail = 0;
950 : 1 : int suite_result = TC_PASS;
951 : :
952 : 1 : struct ztest_unit_test *test = NULL;
953 : 1 : unsigned int suite_duration_worst_ms = 0;
954 : :
955 : : /** summary of distinct run */
956 [ + + ]: 43 : while (((test = z_ztest_get_next_test(suite->name, test)) != NULL)) {
957 : 42 : distinct_total++;
958 : 42 : suite_duration_worst_ms += test->stats->duration_worst_ms;
959 [ - + ]: 42 : if (test->stats->skip_count == test->stats->run_count) {
960 : 0 : distinct_skip++;
961 [ + - ]: 42 : } else if (test->stats->pass_count == test->stats->run_count) {
962 : 42 : distinct_pass++;
963 : : } else {
964 : 0 : distinct_fail++;
965 : : }
966 : : }
967 : :
968 [ + - ]: 1 : if (distinct_skip == distinct_total) {
969 : : suite_result = TC_SKIP;
970 : : passrate_major = passrate_minor = 0;
971 : : } else {
972 : 1 : suite_result = (distinct_fail > 0) ? TC_FAIL : TC_PASS;
973 : 1 : effective_total = distinct_total - distinct_skip;
974 : 1 : expanded_pass = distinct_pass * 100000;
975 : 1 : expanded_passrate = expanded_pass / effective_total;
976 : 1 : passrate_major = expanded_passrate / 1000;
977 : 1 : passrate_minor = (expanded_passrate - passrate_major * 1000) / 10;
978 : 1 : passrate_tail = expanded_passrate - passrate_major * 1000 - passrate_minor * 10;
979 [ - + ]: 1 : if (passrate_tail >= 5) { /* rounding */
980 : 0 : passrate_minor++;
981 : : }
982 : : }
983 : :
984 : 1 : TC_SUMMARY_PRINT("SUITE %s - %3d.%02d%% [%s]: pass = %d, fail = %d, "
985 : : "skip = %d, total = %d duration = %u.%03u seconds\n",
986 : : TC_RESULT_TO_STR(suite_result), passrate_major, passrate_minor,
987 : : suite->name, distinct_pass, distinct_fail, distinct_skip, distinct_total,
988 : : suite_duration_worst_ms / 1000, suite_duration_worst_ms % 1000);
989 : 1 : flush_log();
990 : 1 : }
991 : :
992 : 1 : static void __ztest_show_suite_summary_verbose(struct ztest_suite_node *suite)
993 : : {
994 : 1 : struct ztest_unit_test *test = NULL;
995 : 1 : int tc_result = TC_PASS;
996 : 1 : int flush_frequency = 0;
997 : :
998 : 1 : if (IS_ENABLED(CONFIG_ZTEST_VERBOSE_SUMMARY) == 0) {
999 : : return;
1000 : : }
1001 : :
1002 [ + + ]: 43 : while (((test = z_ztest_get_next_test(suite->name, test)) != NULL)) {
1003 [ + - ]: 42 : if (test->stats->skip_count == test->stats->run_count) {
1004 : : tc_result = TC_SKIP;
1005 [ - + ]: 42 : } else if (test->stats->pass_count == test->stats->run_count) {
1006 : : tc_result = TC_PASS;
1007 [ # # ]: 0 : } else if (test->stats->pass_count == 0) {
1008 : : tc_result = TC_FAIL;
1009 : : } else {
1010 : 0 : tc_result = TC_FLAKY;
1011 : : }
1012 : :
1013 : 0 : if (tc_result == TC_FLAKY) {
1014 : 0 : TC_SUMMARY_PRINT(
1015 : : " - %s - [%s.%s] - (Failed %d of %d attempts)"
1016 : : " - duration = %u.%03u seconds\n",
1017 : : TC_RESULT_TO_STR(tc_result), test->test_suite_name, test->name,
1018 : : test->stats->run_count - test->stats->pass_count,
1019 : : test->stats->run_count, test->stats->duration_worst_ms / 1000,
1020 : : test->stats->duration_worst_ms % 1000);
1021 : : } else {
1022 : 42 : TC_SUMMARY_PRINT(" - %s - [%s.%s] duration = %u.%03u seconds\n",
1023 : : TC_RESULT_TO_STR(tc_result), test->test_suite_name,
1024 : : test->name, test->stats->duration_worst_ms / 1000,
1025 : : test->stats->duration_worst_ms % 1000);
1026 : : }
1027 : :
1028 [ + + ]: 42 : if (flush_frequency % 3 == 0) {
1029 : : /** Reduce the flush frequency a bit to speed up the output */
1030 : 14 : flush_log();
1031 : : }
1032 : 42 : flush_frequency++;
1033 : : }
1034 : 1 : TC_SUMMARY_PRINT("\n");
1035 : 1 : flush_log();
1036 : : }
1037 : :
1038 : 1 : static void __ztest_show_suite_summary(void)
1039 : : {
1040 : 1 : if (IS_ENABLED(CONFIG_ZTEST_SUMMARY) == 0) {
1041 : : return;
1042 : : }
1043 : : /* Flush the log a lot to ensure that no summary content
1044 : : * is dropped if it goes through the logging subsystem.
1045 : : */
1046 : 1 : flush_log();
1047 : 1 : TC_SUMMARY_PRINT("\n------ TESTSUITE SUMMARY START ------\n\n");
1048 : 1 : flush_log();
1049 : 1 : for (struct ztest_suite_node *ptr = _ztest_suite_node_list_start;
1050 [ + + ]: 2 : ptr < _ztest_suite_node_list_end; ++ptr) {
1051 : :
1052 : 1 : __ztest_show_suite_summary_oneline(ptr);
1053 : 1 : __ztest_show_suite_summary_verbose(ptr);
1054 : : }
1055 : 1 : TC_SUMMARY_PRINT("------ TESTSUITE SUMMARY END ------\n\n");
1056 : 1 : flush_log();
1057 : : }
1058 : :
1059 : 1 : static int __ztest_run_test_suite(struct ztest_suite_node *ptr, const void *state, bool shuffle,
1060 : : int suite_iter, int case_iter, void *param)
1061 : : {
1062 : 1 : struct ztest_suite_stats *stats = ptr->stats;
1063 : 1 : int count = 0;
1064 : :
1065 [ + + ]: 2 : for (int i = 0; i < suite_iter; i++) {
1066 [ + - ]: 1 : if (ztest_api.should_suite_run(state, ptr)) {
1067 : 1 : int fail = z_ztest_run_test_suite_ptr(ptr, shuffle,
1068 : : suite_iter, case_iter, param);
1069 : :
1070 : 1 : count++;
1071 : 1 : stats->run_count++;
1072 [ + - ]: 2 : stats->fail_count += (fail != 0) ? 1 : 0;
1073 : : } else {
1074 : 0 : stats->skip_count++;
1075 : : }
1076 : : }
1077 : :
1078 : 1 : return count;
1079 : : }
1080 : :
1081 : 1 : int z_impl_ztest_run_test_suites(const void *state, bool shuffle, int suite_iter, int case_iter)
1082 : : {
1083 : 1 : int count = 0;
1084 : 1 : void *param = NULL;
1085 [ + - ]: 1 : if (test_status == ZTEST_STATUS_CRITICAL_ERROR) {
1086 : : return count;
1087 : : }
1088 : :
1089 : : #ifdef CONFIG_ZTEST_COVERAGE_RESET_BEFORE_TESTS
1090 : : gcov_reset_all_counts();
1091 : : #endif
1092 : :
1093 : : #ifdef CONFIG_ZTEST_SHUFFLE
1094 : : struct ztest_suite_node *suites_to_run[ZTEST_SUITE_COUNT];
1095 : :
1096 : : memset(suites_to_run, 0, ZTEST_SUITE_COUNT * sizeof(struct ztest_suite_node *));
1097 : : z_ztest_shuffle(shuffle, (void **)suites_to_run, (intptr_t)_ztest_suite_node_list_start,
1098 : : ZTEST_SUITE_COUNT, sizeof(struct ztest_suite_node));
1099 : : for (size_t i = 0; i < ZTEST_SUITE_COUNT; ++i) {
1100 : : __ztest_init_unit_test_result_for_suite(suites_to_run[i]);
1101 : : }
1102 : : for (size_t i = 0; i < ZTEST_SUITE_COUNT; ++i) {
1103 : : count += __ztest_run_test_suite(suites_to_run[i], state, shuffle, suite_iter,
1104 : : case_iter, param);
1105 : : /* Stop running tests if we have a critical error or if we have a failure and
1106 : : * FAIL_FAST was set
1107 : : */
1108 : : if (test_status == ZTEST_STATUS_CRITICAL_ERROR ||
1109 : : (test_status == ZTEST_STATUS_HAS_FAILURE && FAIL_FAST)) {
1110 : : break;
1111 : : }
1112 : : }
1113 : : #else
1114 : : for (struct ztest_suite_node *ptr = _ztest_suite_node_list_start;
1115 [ + + ]: 2 : ptr < _ztest_suite_node_list_end; ++ptr) {
1116 : 1 : __ztest_init_unit_test_result_for_suite(ptr);
1117 : 1 : count += __ztest_run_test_suite(ptr, state, shuffle, suite_iter, case_iter, param);
1118 : : /* Stop running tests if we have a critical error or if we have a failure and
1119 : : * FAIL_FAST was set
1120 : : */
1121 [ + - ]: 1 : if (test_status == ZTEST_STATUS_CRITICAL_ERROR ||
1122 : : (test_status == ZTEST_STATUS_HAS_FAILURE && FAIL_FAST)) {
1123 : : break;
1124 : : }
1125 : : }
1126 : : #endif
1127 : :
1128 : : return count;
1129 : : }
1130 : :
1131 : 85 : void z_impl___ztest_set_test_result(enum ztest_result new_result)
1132 : : {
1133 : 85 : test_result = new_result;
1134 : 85 : }
1135 : :
1136 : 170 : void z_impl___ztest_set_test_phase(enum ztest_phase new_phase)
1137 : : {
1138 : 170 : cur_phase = new_phase;
1139 : 170 : }
1140 : :
1141 : : #ifdef CONFIG_USERSPACE
1142 : : void z_vrfy___ztest_set_test_result(enum ztest_result new_result)
1143 : : {
1144 : : z_impl___ztest_set_test_result(new_result);
1145 : : }
1146 : : #include <zephyr/syscalls/__ztest_set_test_result_mrsh.c>
1147 : :
1148 : : void z_vrfy___ztest_set_test_phase(enum ztest_phase new_phase)
1149 : : {
1150 : : z_impl___ztest_set_test_phase(new_phase);
1151 : : }
1152 : : #include <zephyr/syscalls/__ztest_set_test_phase_mrsh.c>
1153 : : #endif /* CONFIG_USERSPACE */
1154 : :
1155 : 1 : void ztest_verify_all_test_suites_ran(void)
1156 : : {
1157 : 1 : bool all_tests_run = true;
1158 : 1 : struct ztest_suite_node *suite;
1159 : 1 : struct ztest_unit_test *test;
1160 : :
1161 : 1 : if (IS_ENABLED(CONFIG_ZTEST_VERIFY_RUN_ALL)) {
1162 [ + + ]: 2 : for (suite = _ztest_suite_node_list_start; suite < _ztest_suite_node_list_end;
1163 : 1 : ++suite) {
1164 [ - + ]: 1 : if (suite->stats->run_count < 1) {
1165 : 0 : PRINT_DATA("ERROR: Test suite '%s' did not run.\n", suite->name);
1166 : 0 : all_tests_run = false;
1167 : : }
1168 : : }
1169 : :
1170 [ + + ]: 43 : for (test = _ztest_unit_test_list_start; test < _ztest_unit_test_list_end; ++test) {
1171 : 42 : suite = ztest_find_test_suite(test->test_suite_name);
1172 [ - + ]: 42 : if (suite == NULL) {
1173 : 0 : PRINT_DATA("ERROR: Test '%s' assigned to test suite '%s' which "
1174 : : "doesn't "
1175 : : "exist\n",
1176 : : test->name, test->test_suite_name);
1177 : 0 : all_tests_run = false;
1178 : : }
1179 : : }
1180 : :
1181 [ - + ]: 1 : if (!all_tests_run) {
1182 : 0 : test_status = ZTEST_STATUS_HAS_FAILURE;
1183 : : }
1184 : : }
1185 : :
1186 [ + + ]: 43 : for (test = _ztest_unit_test_list_start; test < _ztest_unit_test_list_end; ++test) {
1187 : 42 : if (test->stats->fail_count + test->stats->pass_count + test->stats->skip_count !=
1188 [ - + ]: 42 : test->stats->run_count) {
1189 : 0 : PRINT_DATA("Bad stats for %s.%s\n", test->test_suite_name, test->name);
1190 : 0 : test_status = 1;
1191 : : }
1192 : : }
1193 : 1 : }
1194 : :
1195 : 1 : void ztest_run_all(const void *state, bool shuffle, int suite_iter, int case_iter)
1196 : : {
1197 : 1 : ztest_api.run_all(state, shuffle, suite_iter, case_iter);
1198 : 1 : }
1199 : :
1200 : 1 : void __weak test_main(void)
1201 : : {
1202 : : #if CONFIG_ZTEST_SHUFFLE
1203 : : ztest_run_all(NULL, true, NUM_ITER_PER_SUITE, NUM_ITER_PER_TEST);
1204 : : #else
1205 : 1 : ztest_run_all(NULL, false, NUM_ITER_PER_SUITE, NUM_ITER_PER_TEST);
1206 : : #endif
1207 : 1 : ztest_verify_all_test_suites_ran();
1208 : 1 : }
1209 : :
1210 : : #ifndef KERNEL
1211 : : int main(void)
1212 : : {
1213 : : z_init_mock();
1214 : : test_main();
1215 : : end_report();
1216 : : #ifdef CONFIG_ZTEST_NO_YIELD
1217 : : /*
1218 : : * Rather than yielding to idle thread, keep the part awake so debugger can
1219 : : * still access it, since some SOCs cannot be debugged in low power states.
1220 : : */
1221 : : uint32_t key = irq_lock();
1222 : :
1223 : : while (1) {
1224 : : ; /* Spin */
1225 : : }
1226 : : irq_unlock(key);
1227 : : #endif
1228 : : return test_status;
1229 : : }
1230 : : #else
1231 : :
1232 : : /* Shell */
1233 : :
1234 : : #ifdef CONFIG_ZTEST_SHELL
1235 : : static int cmd_list_suites(const struct shell *sh, size_t argc, char **argv)
1236 : : {
1237 : : struct ztest_suite_node *suite;
1238 : :
1239 : : for (suite = _ztest_suite_node_list_start; suite < _ztest_suite_node_list_end; ++suite) {
1240 : : shell_print(sh, "%s", suite->name);
1241 : : }
1242 : : return 0;
1243 : : }
1244 : :
1245 : : static int cmd_list_cases(const struct shell *sh, size_t argc, char **argv)
1246 : : {
1247 : : struct ztest_suite_node *ptr;
1248 : : struct ztest_unit_test *test = NULL;
1249 : : int test_count = 0;
1250 : :
1251 : : for (ptr = _ztest_suite_node_list_start; ptr < _ztest_suite_node_list_end; ++ptr) {
1252 : : test = NULL;
1253 : : while ((test = z_ztest_get_next_test(ptr->name, test)) != NULL) {
1254 : : shell_print(sh, "%s::%s", test->test_suite_name, test->name);
1255 : : test_count++;
1256 : : }
1257 : : }
1258 : : return 0;
1259 : : }
1260 : : extern void ztest_set_test_args(char *argv);
1261 : : extern void ztest_reset_test_args(void);
1262 : :
1263 : : static int cmd_runall(const struct shell *sh, size_t argc, char **argv)
1264 : : {
1265 : : ztest_reset_test_args();
1266 : : ztest_run_all(NULL, false, 1, 1);
1267 : : end_report();
1268 : : return 0;
1269 : : }
1270 : :
1271 : : #ifdef CONFIG_ZTEST_SHUFFLE
1272 : : static int cmd_shuffle(const struct shell *sh, size_t argc, char **argv)
1273 : : {
1274 : :
1275 : : struct getopt_state *state;
1276 : : int opt;
1277 : : static struct option long_options[] = {{"suite_iter", required_argument, 0, 's'},
1278 : : {"case_iter", required_argument, 0, 'c'},
1279 : : {0, 0, 0, 0}};
1280 : : int opt_index = 0;
1281 : : int val;
1282 : : int opt_num = 0;
1283 : :
1284 : : int suite_iter = 1;
1285 : : int case_iter = 1;
1286 : :
1287 : : while ((opt = getopt_long(argc, argv, "s:c:", long_options, &opt_index)) != -1) {
1288 : : state = getopt_state_get();
1289 : : switch (opt) {
1290 : : case 's':
1291 : : val = atoi(state->optarg);
1292 : : if (val < 1) {
1293 : : shell_error(sh, "Invalid number of suite iterations");
1294 : : return -ENOEXEC;
1295 : : }
1296 : : suite_iter = val;
1297 : : opt_num++;
1298 : : break;
1299 : : case 'c':
1300 : : val = atoi(state->optarg);
1301 : : if (val < 1) {
1302 : : shell_error(sh, "Invalid number of case iterations");
1303 : : return -ENOEXEC;
1304 : : }
1305 : : case_iter = val;
1306 : : opt_num++;
1307 : : break;
1308 : : default:
1309 : : shell_error(sh, "Invalid option or option usage: %s",
1310 : : argv[opt_index + 1]);
1311 : : return -ENOEXEC;
1312 : : }
1313 : : }
1314 : : ztest_reset_test_args();
1315 : : ztest_run_all(NULL, true, suite_iter, case_iter);
1316 : : end_report();
1317 : : return 0;
1318 : : }
1319 : : #endif
1320 : :
1321 : : static int cmd_run_suite(const struct shell *sh, size_t argc, char **argv)
1322 : : {
1323 : : struct getopt_state *state;
1324 : : int opt;
1325 : : static struct option long_options[] = {{"repeat_iter", required_argument, NULL, 'r'},
1326 : : {NULL, 0, NULL, 0}};
1327 : : int opt_index = 0;
1328 : : int val;
1329 : : int opt_num = 0;
1330 : : void *param = NULL;
1331 : : int repeat_iter = 1;
1332 : :
1333 : : while ((opt = getopt_long(argc, argv, "r:p:", long_options, &opt_index)) != -1) {
1334 : : state = getopt_state_get();
1335 : : switch (opt) {
1336 : : case 'r':
1337 : : val = atoi(state->optarg);
1338 : : if (val < 1) {
1339 : : shell_fprintf(sh, SHELL_ERROR,
1340 : : "Invalid number of suite interations\n");
1341 : : return -ENOEXEC;
1342 : : }
1343 : : repeat_iter = val;
1344 : : opt_num++;
1345 : : break;
1346 : : case 'p':
1347 : : param = state->optarg;
1348 : : opt_num++;
1349 : : break;
1350 : : default:
1351 : : shell_fprintf(sh, SHELL_ERROR,
1352 : : "Invalid option or option usage: %s\n", argv[opt_index + 1]);
1353 : : return -ENOEXEC;
1354 : : }
1355 : : }
1356 : : int count = 0;
1357 : : bool shuffle = false;
1358 : : const char *shell_command = argv[0];
1359 : :
1360 : : /*
1361 : : * This if statement determines which argv contains the test name.
1362 : : * If the optional argument is used, the test name is in the third
1363 : : * argv instead of the first.
1364 : : */
1365 : : if (opt_num == 1) {
1366 : : ztest_set_test_args(argv[3]);
1367 : : } else {
1368 : : ztest_set_test_args(argv[1]);
1369 : : }
1370 : :
1371 : : for (struct ztest_suite_node *ptr = _ztest_suite_node_list_start;
1372 : : ptr < _ztest_suite_node_list_end; ++ptr) {
1373 : : __ztest_init_unit_test_result_for_suite(ptr);
1374 : : if (strcmp(shell_command, "run-testcase") == 0) {
1375 : : count += __ztest_run_test_suite(ptr, NULL, shuffle, 1, repeat_iter, param);
1376 : : } else if (strcmp(shell_command, "run-testsuite") == 0) {
1377 : : count += __ztest_run_test_suite(ptr, NULL, shuffle, repeat_iter, 1, NULL);
1378 : : }
1379 : : if (test_status == ZTEST_STATUS_CRITICAL_ERROR ||
1380 : : (test_status == ZTEST_STATUS_HAS_FAILURE && FAIL_FAST)) {
1381 : : break;
1382 : : }
1383 : : }
1384 : : return 0;
1385 : : }
1386 : :
1387 : : static void testsuite_list_get(size_t idx, struct shell_static_entry *entry);
1388 : :
1389 : : SHELL_DYNAMIC_CMD_CREATE(testsuite_names, testsuite_list_get);
1390 : :
1391 : : static size_t testsuite_get_all_static(struct ztest_suite_node const **suites)
1392 : : {
1393 : : *suites = _ztest_suite_node_list_start;
1394 : : return _ztest_suite_node_list_end - _ztest_suite_node_list_start;
1395 : : }
1396 : :
1397 : : static const struct ztest_suite_node *suite_lookup(size_t idx, const char *prefix)
1398 : : {
1399 : : size_t match_idx = 0;
1400 : : const struct ztest_suite_node *suite;
1401 : : size_t len = testsuite_get_all_static(&suite);
1402 : : const struct ztest_suite_node *suite_end = suite + len;
1403 : :
1404 : : while (suite < suite_end) {
1405 : : if ((suite->name != NULL) && (strlen(suite->name) != 0) &&
1406 : : ((prefix == NULL) || (strncmp(prefix, suite->name, strlen(prefix)) == 0))) {
1407 : : if (match_idx == idx) {
1408 : : return suite;
1409 : : }
1410 : : ++match_idx;
1411 : : }
1412 : : ++suite;
1413 : : }
1414 : :
1415 : : return NULL;
1416 : : }
1417 : :
1418 : : static void testsuite_list_get(size_t idx, struct shell_static_entry *entry)
1419 : : {
1420 : : const struct ztest_suite_node *suite = suite_lookup(idx, "");
1421 : :
1422 : : entry->syntax = (suite != NULL) ? suite->name : NULL;
1423 : : entry->handler = NULL;
1424 : : entry->help = NULL;
1425 : : entry->subcmd = NULL;
1426 : : }
1427 : :
1428 : : /* clang-format off */
1429 : : SHELL_STATIC_SUBCMD_SET_CREATE(
1430 : : sub_ztest_cmds,
1431 : : SHELL_CMD_ARG(run-all, NULL, "Run all tests", cmd_runall, 0, 0),
1432 : : #ifdef CONFIG_ZTEST_SHUFFLE
1433 : : SHELL_COND_CMD_ARG(CONFIG_ZTEST_SHUFFLE, shuffle, NULL,
1434 : : "Shuffle tests", cmd_shuffle, 0, 2),
1435 : : #endif
1436 : : SHELL_CMD_ARG(list-testsuites, NULL,
1437 : : "List all test suites", cmd_list_suites, 0, 0),
1438 : : SHELL_CMD_ARG(list-testcases, NULL,
1439 : : "List all test cases", cmd_list_cases, 0, 0),
1440 : : SHELL_CMD_ARG(run-testsuite, &testsuite_names,
1441 : : "Run test suite", cmd_run_suite, 2, 2),
1442 : : SHELL_CMD_ARG(run-testcase, NULL, "Run testcase", cmd_run_suite, 2, 2),
1443 : : SHELL_SUBCMD_SET_END /* Array terminated. */
1444 : : );
1445 : : /* clang-format on */
1446 : :
1447 : : SHELL_CMD_REGISTER(ztest, &sub_ztest_cmds, "Ztest commands", NULL);
1448 : : #endif /* CONFIG_ZTEST_SHELL */
1449 : :
1450 : 1 : int main(void)
1451 : : {
1452 : : #ifdef CONFIG_USERSPACE
1453 : : /* Partition containing globals tagged with ZTEST_DMEM and ZTEST_BMEM
1454 : : * macros. Any variables that user code may reference need to be
1455 : : * placed in this partition if no other memory domain configuration
1456 : : * is made.
1457 : : */
1458 : : k_mem_domain_add_partition(&k_mem_domain_default, &ztest_mem_partition);
1459 : : #ifdef Z_MALLOC_PARTITION_EXISTS
1460 : : /* Allow access to malloc() memory */
1461 : : k_mem_domain_add_partition(&k_mem_domain_default, &z_malloc_partition);
1462 : : #endif
1463 : : #endif /* CONFIG_USERSPACE */
1464 : :
1465 : 1 : z_init_mock();
1466 : : #ifndef CONFIG_ZTEST_SHELL
1467 : 1 : test_main();
1468 : 1 : end_report();
1469 : : flush_log();
1470 : : LOG_PANIC();
1471 : : if (IS_ENABLED(CONFIG_ZTEST_RETEST_IF_PASSED)) {
1472 : : static __noinit struct {
1473 : : uint32_t magic;
1474 : : uint32_t boots;
1475 : : } state;
1476 : : const uint32_t magic = 0x152ac523;
1477 : :
1478 : : if (state.magic != magic) {
1479 : : state.magic = magic;
1480 : : state.boots = 0;
1481 : : }
1482 : : state.boots += 1;
1483 : : if (test_status == 0) {
1484 : : PRINT_DATA("Reset board #%u to test again\n", state.boots);
1485 : : k_msleep(10);
1486 : : sys_reboot(SYS_REBOOT_COLD);
1487 : : } else {
1488 : : PRINT_DATA("Failed after %u attempts\n", state.boots);
1489 : : state.boots = 0;
1490 : : }
1491 : : }
1492 : : #ifdef CONFIG_ZTEST_NO_YIELD
1493 : : /*
1494 : : * Rather than yielding to idle thread, keep the part awake so debugger can
1495 : : * still access it, since some SOCs cannot be debugged in low power states.
1496 : : */
1497 : : uint32_t key = irq_lock();
1498 : :
1499 : : while (1) {
1500 : : ; /* Spin */
1501 : : }
1502 : : irq_unlock(key);
1503 : : #endif /* CONFIG_ZTEST_NO_YIELD */
1504 : : #endif /* CONFIG_ZTEST_SHELL */
1505 : : return 0;
1506 : : }
1507 : : #endif
|
