mirror of
https://github.com/DarkFlippers/unleashed-firmware
synced 2025-01-20 00:33:54 +00:00
250 lines
8.8 KiB
C
250 lines
8.8 KiB
C
#include <stdio.h>
|
|
#include <furi.h>
|
|
#include <furi_hal.h>
|
|
#include "minunit_vars.h"
|
|
#include <notification/notification_messages.h>
|
|
#include <cli/cli.h>
|
|
#include <loader/loader.h>
|
|
#include <lib/toolbox/args.h>
|
|
|
|
#define TAG "UnitTests"
|
|
|
|
int run_minunit_test_furi();
|
|
int run_minunit_test_furi_hal();
|
|
int run_minunit_test_furi_string();
|
|
int run_minunit_test_infrared();
|
|
int run_minunit_test_rpc();
|
|
int run_minunit_test_manifest();
|
|
int run_minunit_test_flipper_format();
|
|
int run_minunit_test_flipper_format_string();
|
|
int run_minunit_test_stream();
|
|
int run_minunit_test_storage();
|
|
int run_minunit_test_subghz();
|
|
int run_minunit_test_subghz_app();
|
|
int run_minunit_test_dirwalk();
|
|
int run_minunit_test_power();
|
|
int run_minunit_test_protocol_dict();
|
|
int run_minunit_test_lfrfid_protocols();
|
|
int run_minunit_test_nfc();
|
|
int run_minunit_test_bit_lib();
|
|
int run_minunit_test_float_tools();
|
|
int run_minunit_test_bt();
|
|
|
|
typedef int (*UnitTestEntry)();
|
|
|
|
typedef struct {
|
|
const char* name;
|
|
const UnitTestEntry entry;
|
|
} UnitTest;
|
|
|
|
const UnitTest unit_tests[] = {
|
|
{.name = "furi", .entry = run_minunit_test_furi},
|
|
{.name = "furi_hal", .entry = run_minunit_test_furi_hal},
|
|
{.name = "furi_string", .entry = run_minunit_test_furi_string},
|
|
{.name = "storage", .entry = run_minunit_test_storage},
|
|
{.name = "stream", .entry = run_minunit_test_stream},
|
|
{.name = "dirwalk", .entry = run_minunit_test_dirwalk},
|
|
{.name = "manifest", .entry = run_minunit_test_manifest},
|
|
{.name = "flipper_format", .entry = run_minunit_test_flipper_format},
|
|
{.name = "flipper_format_string", .entry = run_minunit_test_flipper_format_string},
|
|
{.name = "rpc", .entry = run_minunit_test_rpc},
|
|
{.name = "subghz", .entry = run_minunit_test_subghz},
|
|
{.name = "subghz_app", .entry = run_minunit_test_subghz_app},
|
|
{.name = "infrared", .entry = run_minunit_test_infrared},
|
|
{.name = "nfc", .entry = run_minunit_test_nfc},
|
|
{.name = "power", .entry = run_minunit_test_power},
|
|
{.name = "protocol_dict", .entry = run_minunit_test_protocol_dict},
|
|
{.name = "lfrfid", .entry = run_minunit_test_lfrfid_protocols},
|
|
{.name = "bit_lib", .entry = run_minunit_test_bit_lib},
|
|
{.name = "float_tools", .entry = run_minunit_test_float_tools},
|
|
{.name = "bt", .entry = run_minunit_test_bt},
|
|
};
|
|
|
|
void minunit_print_progress() {
|
|
static const char progress[] = {'\\', '|', '/', '-'};
|
|
static uint8_t progress_counter = 0;
|
|
static TickType_t last_tick = 0;
|
|
TickType_t current_tick = xTaskGetTickCount();
|
|
if(current_tick - last_tick > 20) {
|
|
last_tick = current_tick;
|
|
printf("[%c]\033[3D", progress[++progress_counter % COUNT_OF(progress)]);
|
|
fflush(stdout);
|
|
}
|
|
}
|
|
|
|
void minunit_print_fail(const char* str) {
|
|
printf(FURI_LOG_CLR_E "%s\r\n" FURI_LOG_CLR_RESET, str);
|
|
}
|
|
|
|
void unit_tests_cli_logs_puts(const char* str) {
|
|
printf(str);
|
|
}
|
|
|
|
// by default there is no output from unit tests
|
|
// you have to enable them with this function
|
|
void unit_tests_cli_enable_logs(FuriLogLevel logLevel) {
|
|
furi_log_init();
|
|
furi_log_set_level(logLevel);
|
|
furi_log_set_puts(unit_tests_cli_logs_puts);
|
|
}
|
|
|
|
void unit_tests_cli_print_help() {
|
|
printf(
|
|
"Usage:\r\n"
|
|
" unit_tests [log level] [test_suit_name]\r\n"
|
|
" Arguments:\r\n"
|
|
" [log level]: optional, enables printing output from FURI_LOG_* macro in unit_tests\r\n"
|
|
" [test_suit_name]: a specific test suit to run. If not specified runs all tests\r\n"
|
|
" Warning: supports only 1 test suit to launch\r\n"
|
|
" Example:\r\n"
|
|
" unit_tests - run ALL tests wihtout log printing\r\n"
|
|
" unit_tests bt - run bt tests wihtout log printing\r\n"
|
|
" unit_tests log debug subghz - run subghz tests with logs at debug level abd above\r\n\r\n"
|
|
" unit_tests help [?]\r\n"
|
|
" prints this help\r\n");
|
|
}
|
|
|
|
bool unit_tests_cli_parse_log_level(FuriString* args) {
|
|
bool result = true;
|
|
FuriString* level = furi_string_alloc();
|
|
if(args_read_string_and_trim(args, level)) {
|
|
if(furi_string_cmpi_str(level, "default") == 0) {
|
|
unit_tests_cli_enable_logs(FuriLogLevelDefault);
|
|
} else if(furi_string_cmpi_str(level, "none") == 0) {
|
|
unit_tests_cli_enable_logs(FuriLogLevelNone);
|
|
} else if(furi_string_cmpi_str(level, "error") == 0) {
|
|
unit_tests_cli_enable_logs(FuriLogLevelError);
|
|
} else if(furi_string_cmpi_str(level, "warn") == 0) {
|
|
unit_tests_cli_enable_logs(FuriLogLevelWarn);
|
|
} else if(furi_string_cmpi_str(level, "info") == 0) {
|
|
unit_tests_cli_enable_logs(FuriLogLevelInfo);
|
|
} else if(furi_string_cmpi_str(level, "debug") == 0) {
|
|
unit_tests_cli_enable_logs(FuriLogLevelDebug);
|
|
} else if(furi_string_cmpi_str(level, "trace") == 0) {
|
|
unit_tests_cli_enable_logs(FuriLogLevelTrace);
|
|
} else {
|
|
printf("Error: Invalid log level: %s\r\n", furi_string_get_cstr(level));
|
|
result = false;
|
|
}
|
|
}
|
|
furi_string_free(level);
|
|
return result;
|
|
}
|
|
|
|
FuriString* unit_tests_cli_parse_test_suit(FuriString* args) {
|
|
FuriString* test_suit = furi_string_alloc();
|
|
|
|
if(!args_read_string_and_trim(args, test_suit)) {
|
|
furi_string_free(test_suit);
|
|
return NULL;
|
|
}
|
|
|
|
return test_suit;
|
|
}
|
|
|
|
void unit_tests_cli(Cli* cli, FuriString* args, void* context) {
|
|
UNUSED(cli);
|
|
UNUSED(args);
|
|
UNUSED(context);
|
|
minunit_run = 0;
|
|
minunit_assert = 0;
|
|
minunit_fail = 0;
|
|
minunit_status = 0;
|
|
|
|
if(furi_string_cmp_str(args, "help") == 0 || furi_string_cmp_str(args, "?") == 0) {
|
|
unit_tests_cli_print_help();
|
|
return;
|
|
}
|
|
|
|
FuriString* test_suit_to_run = NULL;
|
|
|
|
if(furi_string_size(args)) {
|
|
FuriString* arg = furi_string_alloc();
|
|
if(args_read_string_and_trim(args, arg)) {
|
|
if(furi_string_cmp_str(arg, "log") == 0) {
|
|
// read next argument - log level, if fail - show help and return
|
|
if(!unit_tests_cli_parse_log_level(args)) {
|
|
unit_tests_cli_print_help();
|
|
furi_string_free(arg);
|
|
return;
|
|
}
|
|
|
|
// next argument might be test suit
|
|
test_suit_to_run = unit_tests_cli_parse_test_suit(args);
|
|
} else {
|
|
// if first argument wasn't log - it was exact test suit to run
|
|
test_suit_to_run = unit_tests_cli_parse_test_suit(arg);
|
|
}
|
|
}
|
|
furi_string_free(arg);
|
|
}
|
|
|
|
Loader* loader = furi_record_open(RECORD_LOADER);
|
|
NotificationApp* notification = furi_record_open(RECORD_NOTIFICATION);
|
|
|
|
// TODO: lock device while test running
|
|
if(loader_is_locked(loader)) {
|
|
printf("RPC: stop all applications to run tests\r\n");
|
|
notification_message(notification, &sequence_blink_magenta_100);
|
|
} else {
|
|
notification_message_block(notification, &sequence_set_only_blue_255);
|
|
|
|
uint32_t heap_before = memmgr_get_free_heap();
|
|
uint32_t cycle_counter = furi_get_tick();
|
|
|
|
for(size_t i = 0; i < COUNT_OF(unit_tests); i++) {
|
|
if(cli_cmd_interrupt_received(cli)) {
|
|
break;
|
|
}
|
|
|
|
if(test_suit_to_run) {
|
|
if(furi_string_cmp_str(test_suit_to_run, unit_tests[i].name) == 0) {
|
|
unit_tests[i].entry();
|
|
} else {
|
|
printf("Skipping %s\r\n", unit_tests[i].name);
|
|
}
|
|
} else {
|
|
unit_tests[i].entry();
|
|
}
|
|
}
|
|
|
|
if(minunit_run != 0) {
|
|
printf("\r\nFailed tests: %u\r\n", minunit_fail);
|
|
|
|
// Time report
|
|
cycle_counter = (furi_get_tick() - cycle_counter);
|
|
printf("Consumed: %lu ms\r\n", cycle_counter);
|
|
|
|
// Wait for tested services and apps to deallocate memory
|
|
furi_delay_ms(200);
|
|
uint32_t heap_after = memmgr_get_free_heap();
|
|
printf("Leaked: %ld\r\n", heap_before - heap_after);
|
|
|
|
// Final Report
|
|
if(minunit_fail == 0) {
|
|
notification_message(notification, &sequence_success);
|
|
printf("Status: PASSED\r\n");
|
|
} else {
|
|
notification_message(notification, &sequence_error);
|
|
printf("Status: FAILED\r\n");
|
|
}
|
|
}
|
|
}
|
|
|
|
if(test_suit_to_run) {
|
|
furi_string_free(test_suit_to_run);
|
|
}
|
|
|
|
furi_record_close(RECORD_NOTIFICATION);
|
|
furi_record_close(RECORD_LOADER);
|
|
}
|
|
|
|
void unit_tests_on_system_start() {
|
|
#ifdef SRV_CLI
|
|
Cli* cli = furi_record_open(RECORD_CLI);
|
|
|
|
// We need to launch apps from tests, so we cannot lock loader
|
|
cli_add_command(cli, "unit_tests", CliCommandFlagParallelSafe, unit_tests_cli, NULL);
|
|
furi_record_close(RECORD_CLI);
|
|
#endif
|
|
}
|