fac4391af7
* Toolbox: dir_walk concept (like os.walk) * Storage CLI: tree command * Storage: fix folders copying, stage 1 * UnitTest: proper delays in subghz tests * Toolbox: dir_walk, recursive and filter options * dir_walk: unit tests * Merge: Fix unused param * SubGhz: cleaned up data parsing routine * SubGhz unit test: cleaned up logs, yield data load * SubGhz unit test: naming Co-authored-by: Aleksandr Kutuzov <alleteam@gmail.com>
272 lines
7.7 KiB
C
272 lines
7.7 KiB
C
#include "../minunit.h"
|
|
#include <furi.h>
|
|
#include <m-dict.h>
|
|
#include <toolbox/dir_walk.h>
|
|
|
|
static const char* const storage_test_dirwalk_paths[] = {
|
|
"1",
|
|
"11",
|
|
"111",
|
|
"1/2",
|
|
"1/22",
|
|
"1/222",
|
|
"11/2",
|
|
"111/2",
|
|
"111/22",
|
|
"111/22/33",
|
|
};
|
|
|
|
static const char* const storage_test_dirwalk_files[] = {
|
|
"file1.test",
|
|
"file2.test",
|
|
"file3.ext_test",
|
|
"1/file1.test",
|
|
"111/22/33/file1.test",
|
|
"111/22/33/file2.test",
|
|
"111/22/33/file3.ext_test",
|
|
"111/22/33/file4.ext_test",
|
|
};
|
|
|
|
typedef struct {
|
|
const char* const path;
|
|
bool is_dir;
|
|
} StorageTestPathDesc;
|
|
|
|
const StorageTestPathDesc storage_test_dirwalk_full[] = {
|
|
{.path = "1", .is_dir = true},
|
|
{.path = "11", .is_dir = true},
|
|
{.path = "111", .is_dir = true},
|
|
{.path = "1/2", .is_dir = true},
|
|
{.path = "1/22", .is_dir = true},
|
|
{.path = "1/222", .is_dir = true},
|
|
{.path = "11/2", .is_dir = true},
|
|
{.path = "111/2", .is_dir = true},
|
|
{.path = "111/22", .is_dir = true},
|
|
{.path = "111/22/33", .is_dir = true},
|
|
{.path = "file1.test", .is_dir = false},
|
|
{.path = "file2.test", .is_dir = false},
|
|
{.path = "file3.ext_test", .is_dir = false},
|
|
{.path = "1/file1.test", .is_dir = false},
|
|
{.path = "111/22/33/file1.test", .is_dir = false},
|
|
{.path = "111/22/33/file2.test", .is_dir = false},
|
|
{.path = "111/22/33/file3.ext_test", .is_dir = false},
|
|
{.path = "111/22/33/file4.ext_test", .is_dir = false},
|
|
};
|
|
|
|
const StorageTestPathDesc storage_test_dirwalk_no_recursive[] = {
|
|
{.path = "1", .is_dir = true},
|
|
{.path = "11", .is_dir = true},
|
|
{.path = "111", .is_dir = true},
|
|
{.path = "file1.test", .is_dir = false},
|
|
{.path = "file2.test", .is_dir = false},
|
|
{.path = "file3.ext_test", .is_dir = false},
|
|
};
|
|
|
|
const StorageTestPathDesc storage_test_dirwalk_filter[] = {
|
|
{.path = "file1.test", .is_dir = false},
|
|
{.path = "file2.test", .is_dir = false},
|
|
{.path = "1/file1.test", .is_dir = false},
|
|
{.path = "111/22/33/file1.test", .is_dir = false},
|
|
{.path = "111/22/33/file2.test", .is_dir = false},
|
|
};
|
|
|
|
typedef struct {
|
|
bool is_dir;
|
|
bool visited;
|
|
} StorageTestPath;
|
|
|
|
DICT_DEF2(StorageTestPathDict, string_t, STRING_OPLIST, StorageTestPath, M_POD_OPLIST)
|
|
|
|
static StorageTestPathDict_t*
|
|
storage_test_paths_alloc(const StorageTestPathDesc paths[], size_t paths_count) {
|
|
StorageTestPathDict_t* data = malloc(sizeof(StorageTestPathDict_t));
|
|
StorageTestPathDict_init(*data);
|
|
|
|
for(size_t i = 0; i < paths_count; i++) {
|
|
string_t key;
|
|
string_init_set(key, paths[i].path);
|
|
StorageTestPath value = {
|
|
.is_dir = paths[i].is_dir,
|
|
.visited = false,
|
|
};
|
|
|
|
StorageTestPathDict_set_at(*data, key, value);
|
|
string_clear(key);
|
|
}
|
|
|
|
return data;
|
|
}
|
|
|
|
static void storage_test_paths_free(StorageTestPathDict_t* data) {
|
|
StorageTestPathDict_clear(*data);
|
|
free(data);
|
|
}
|
|
|
|
static bool storage_test_paths_mark(StorageTestPathDict_t* data, string_t path, bool is_dir) {
|
|
bool found = false;
|
|
|
|
StorageTestPath* record = StorageTestPathDict_get(*data, path);
|
|
if(record) {
|
|
if(is_dir == record->is_dir) {
|
|
if(record->visited == false) {
|
|
record->visited = true;
|
|
found = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return found;
|
|
}
|
|
|
|
static bool storage_test_paths_check(StorageTestPathDict_t* data) {
|
|
bool error = false;
|
|
|
|
StorageTestPathDict_it_t it;
|
|
for(StorageTestPathDict_it(it, *data); !StorageTestPathDict_end_p(it);
|
|
StorageTestPathDict_next(it)) {
|
|
const StorageTestPathDict_itref_t* itref = StorageTestPathDict_cref(it);
|
|
|
|
if(itref->value.visited == false) {
|
|
error = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return error;
|
|
}
|
|
|
|
static bool write_file_13DA(Storage* storage, const char* path) {
|
|
File* file = storage_file_alloc(storage);
|
|
bool result = false;
|
|
if(storage_file_open(file, path, FSAM_WRITE, FSOM_CREATE_ALWAYS)) {
|
|
result = storage_file_write(file, "13DA", 4) == 4;
|
|
}
|
|
storage_file_close(file);
|
|
storage_file_free(file);
|
|
|
|
return result;
|
|
}
|
|
|
|
static void storage_dirs_create(Storage* storage, const char* base) {
|
|
string_t path;
|
|
string_init(path);
|
|
|
|
storage_common_mkdir(storage, base);
|
|
|
|
for(size_t i = 0; i < COUNT_OF(storage_test_dirwalk_paths); i++) {
|
|
string_printf(path, "%s/%s", base, storage_test_dirwalk_paths[i]);
|
|
storage_common_mkdir(storage, string_get_cstr(path));
|
|
}
|
|
|
|
for(size_t i = 0; i < COUNT_OF(storage_test_dirwalk_files); i++) {
|
|
string_printf(path, "%s/%s", base, storage_test_dirwalk_files[i]);
|
|
write_file_13DA(storage, string_get_cstr(path));
|
|
}
|
|
|
|
string_clear(path);
|
|
}
|
|
|
|
MU_TEST_1(test_dirwalk_full, Storage* storage) {
|
|
string_t path;
|
|
string_init(path);
|
|
FileInfo fileinfo;
|
|
|
|
StorageTestPathDict_t* paths =
|
|
storage_test_paths_alloc(storage_test_dirwalk_full, COUNT_OF(storage_test_dirwalk_full));
|
|
|
|
DirWalk* dir_walk = dir_walk_alloc(storage);
|
|
mu_check(dir_walk_open(dir_walk, "/ext/dirwalk"));
|
|
|
|
while(dir_walk_read(dir_walk, path, &fileinfo) == DirWalkOK) {
|
|
string_right(path, strlen("/ext/dirwalk/"));
|
|
mu_check(storage_test_paths_mark(paths, path, (fileinfo.flags & FSF_DIRECTORY)));
|
|
}
|
|
|
|
dir_walk_free(dir_walk);
|
|
string_clear(path);
|
|
|
|
mu_check(storage_test_paths_check(paths) == false);
|
|
|
|
storage_test_paths_free(paths);
|
|
}
|
|
|
|
MU_TEST_1(test_dirwalk_no_recursive, Storage* storage) {
|
|
string_t path;
|
|
string_init(path);
|
|
FileInfo fileinfo;
|
|
|
|
StorageTestPathDict_t* paths = storage_test_paths_alloc(
|
|
storage_test_dirwalk_no_recursive, COUNT_OF(storage_test_dirwalk_no_recursive));
|
|
|
|
DirWalk* dir_walk = dir_walk_alloc(storage);
|
|
dir_walk_set_recursive(dir_walk, false);
|
|
mu_check(dir_walk_open(dir_walk, "/ext/dirwalk"));
|
|
|
|
while(dir_walk_read(dir_walk, path, &fileinfo) == DirWalkOK) {
|
|
string_right(path, strlen("/ext/dirwalk/"));
|
|
mu_check(storage_test_paths_mark(paths, path, (fileinfo.flags & FSF_DIRECTORY)));
|
|
}
|
|
|
|
dir_walk_free(dir_walk);
|
|
string_clear(path);
|
|
|
|
mu_check(storage_test_paths_check(paths) == false);
|
|
|
|
storage_test_paths_free(paths);
|
|
}
|
|
|
|
static bool test_dirwalk_filter_no_folder_ext(const char* name, FileInfo* fileinfo, void* ctx) {
|
|
UNUSED(ctx);
|
|
|
|
// only files
|
|
if(!(fileinfo->flags & FSF_DIRECTORY)) {
|
|
// with ".test" in name
|
|
if(strstr(name, ".test") != NULL) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
MU_TEST_1(test_dirwalk_filter, Storage* storage) {
|
|
string_t path;
|
|
string_init(path);
|
|
FileInfo fileinfo;
|
|
|
|
StorageTestPathDict_t* paths = storage_test_paths_alloc(
|
|
storage_test_dirwalk_filter, COUNT_OF(storage_test_dirwalk_filter));
|
|
|
|
DirWalk* dir_walk = dir_walk_alloc(storage);
|
|
dir_walk_set_filter_cb(dir_walk, test_dirwalk_filter_no_folder_ext, NULL);
|
|
mu_check(dir_walk_open(dir_walk, "/ext/dirwalk"));
|
|
|
|
while(dir_walk_read(dir_walk, path, &fileinfo) == DirWalkOK) {
|
|
string_right(path, strlen("/ext/dirwalk/"));
|
|
mu_check(storage_test_paths_mark(paths, path, (fileinfo.flags & FSF_DIRECTORY)));
|
|
}
|
|
|
|
dir_walk_free(dir_walk);
|
|
string_clear(path);
|
|
|
|
mu_check(storage_test_paths_check(paths) == false);
|
|
|
|
storage_test_paths_free(paths);
|
|
}
|
|
|
|
MU_TEST_SUITE(test_dirwalk_suite) {
|
|
Storage* storage = furi_record_open("storage");
|
|
storage_dirs_create(storage, "/ext/dirwalk");
|
|
|
|
MU_RUN_TEST_1(test_dirwalk_full, storage);
|
|
MU_RUN_TEST_1(test_dirwalk_no_recursive, storage);
|
|
MU_RUN_TEST_1(test_dirwalk_filter, storage);
|
|
|
|
storage_simply_remove_recursive(storage, "/ext/dirwalk");
|
|
furi_record_close("storage");
|
|
}
|
|
|
|
int run_minunit_test_dirwalk() {
|
|
MU_RUN_SUITE(test_dirwalk_suite);
|
|
return MU_EXIT_CODE;
|
|
} |