michaelh/zephyr
1
0
Fork 0
Code Releases Activity

tests: fs: Add test of fs_mkfs

Browse source 
Test is added to common directory and used in LittleFS tests.

Signed-off-by: Franciszek Zdobylak <fzdobylak@internships.antmicro.com>
This commit is contained in:
Franciszek Zdobylak 2022-10-24 08:38:48 +02:00 • committed by Carles Cufí
commit 659c2143b5
10 changed files with 310 additions and 2 deletions
Download patch file Download diff file Expand all files Collapse all files

96
tests/subsys/fs/common/test_fs_mkfs.c Normal file
View file

@ -0,0 +1,96 @@
/*
* Copyright (c) 2022 Antmicro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/kernel.h>
#include <zephyr/ztest.h>
#include <zephyr/fs/fs.h>
/* Mount point and paths must be provided by test runner. */
extern struct fs_mount_t *fs_mkfs_mp;
extern const int fs_mkfs_type;
extern uintptr_t fs_mkfs_dev_id;
extern int fs_mkfs_flags;
extern const char *some_file_path;
extern const char *other_dir_path;
/* This test assumes that storage device is erased. */
void test_fs_mkfs_simple(void)
{
int ret = 0;
TC_PRINT("Mount with flag no format\n");
fs_mkfs_mp->flags = FS_MOUNT_FLAG_NO_FORMAT;
ret = fs_mount(fs_mkfs_mp);
if (fs_mkfs_mp->type == FS_LITTLEFS) {
zassert_equal(ret, -EILSEQ, "Expected EILSEQ got %d", ret);
} else if (fs_mkfs_mp->type == FS_FATFS) {
zassert_equal(ret, -ENODEV, "Expected ENODEV got %d", ret);
}
TC_PRINT("Try mkfs with RW access\n");
ret = fs_mkfs(fs_mkfs_type, fs_mkfs_dev_id, NULL, fs_mkfs_dev_id);
zassert_equal(ret, 0, "Expected successful mkfs (%d)", ret);
TC_PRINT("Mount created file system without formatting\n");
fs_mkfs_mp->flags = FS_MOUNT_FLAG_NO_FORMAT;
ret = fs_mount(fs_mkfs_mp);
zassert_equal(ret, 0, "Expected successful mount (%d)", ret);
ret = fs_unmount(fs_mkfs_mp);
zassert_equal(ret, 0, "Expected fs_unmount success (%d)", ret);
}
/* This test assumes that storage device is erased. */
void test_fs_mkfs_ops(void)
{
int ret = 0;
struct fs_file_t fs;
struct fs_dir_t dir;
struct fs_dirent entry;
fs_file_t_init(&fs);
fs_dir_t_init(&dir);
/* Format volume and add some files/dirs */
TC_PRINT("Mount to prepare tests\n");
fs_mkfs_mp->flags = 0;
ret = fs_mount(fs_mkfs_mp);
zassert_equal(ret, 0, "Expected success (%d)", ret);
TC_PRINT("Create some file\n");
ret = fs_open(&fs, some_file_path, FS_O_CREATE);
zassert_equal(ret, 0, "Expected success fs_open(FS_O_CREATE) (%d)",
ret);
ret = fs_close(&fs);
zassert_equal(ret, 0, "Expected fs_close success (%d)", ret);
TC_PRINT("Create other directory\n");
ret = fs_mkdir(other_dir_path);
zassert_equal(ret, 0, "Expected fs_mkdir success (%d)", ret);
ret = fs_unmount(fs_mkfs_mp);
zassert_equal(ret, 0, "Expected fs_umount success (%d)", ret);
/* Format file system using fs_mkfs and check if it was formatted */
TC_PRINT("Try mkfs\n");
ret = fs_mkfs(fs_mkfs_type, fs_mkfs_dev_id, NULL, fs_mkfs_dev_id);
zassert_equal(ret, 0, "Expected successful format (%d)", ret);
fs_mkfs_mp->flags = FS_MOUNT_FLAG_NO_FORMAT;
ret = fs_mount(fs_mkfs_mp);
zassert_equal(ret, 0, "Expected successful mount (%d)", ret);
ret = fs_stat(some_file_path, &entry);
zassert_equal(ret, -ENOENT, "Expected ENOENT got %d", ret);
ret = fs_stat(other_dir_path, &entry);
zassert_equal(ret, -ENOENT, "Expected ENOENT got %d", ret);
TC_PRINT("Create some file\n");
ret = fs_open(&fs, some_file_path, FS_O_CREATE);
zassert_equal(ret, 0, "Expected success fs_open(FS_O_CREATE) (%d)",
ret);
ret = fs_close(&fs);
zassert_equal(ret, 0, "Expected fs_close success (%d)", ret);
TC_PRINT("Create other directory\n");
ret = fs_mkdir(other_dir_path);
zassert_equal(ret, 0, "Expected fs_mkdir success (%d)", ret);
ret = fs_unmount(fs_mkfs_mp);
zassert_equal(ret, 0, "Expected fs_unmount success (%d)", ret);
}

5
tests/subsys/fs/fat_fs_api/CMakeLists.txt
View file

@ -5,4 +5,7 @@ find_package(Zephyr REQUIRED HINTS $ENV{ZEPHYR_BASE})
project(fat_fs_api)
FILE(GLOB app_sources src/*.c)
target_sources(app PRIVATE ${app_sources} ../common/test_fs_open_flags.c)
target_sources(app PRIVATE
${app_sources}
../common/test_fs_open_flags.c
../common/test_fs_mkfs.c)

3
tests/subsys/fs/fat_fs_api/prj.conf
View file

@ -1,4 +1,5 @@
CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_MKFS=y
CONFIG_LOG=y
CONFIG_FAT_FILESYSTEM_ELM=y
CONFIG_DISK_DRIVER_FLASH=y
@ -6,3 +7,5 @@ CONFIG_SPI=y
CONFIG_GPIO=y
CONFIG_ZTEST=y
CONFIG_ZTEST_NEW_API=y
CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

3
tests/subsys/fs/fat_fs_api/prj_lfn.conf
View file

@ -1,7 +1,10 @@
CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_MKFS=y
CONFIG_LOG=y
CONFIG_FAT_FILESYSTEM_ELM=y
CONFIG_FS_FATFS_LFN=y
CONFIG_DISK_DRIVER_FLASH=y
CONFIG_ZTEST=y
CONFIG_ZTEST_NEW_API=y
CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

3
tests/subsys/fs/fat_fs_api/prj_native_posix.conf
View file

@ -1,6 +1,9 @@
CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_MKFS=y
CONFIG_LOG=y
CONFIG_FAT_FILESYSTEM_ELM=y
CONFIG_DISK_DRIVER_FLASH=y
CONFIG_ZTEST=y
CONFIG_ZTEST_NEW_API=y
CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

3
tests/subsys/fs/fat_fs_api/prj_native_posix_64.conf
View file

@ -1,6 +1,9 @@
CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_MKFS=y
CONFIG_LOG=y
CONFIG_FAT_FILESYSTEM_ELM=y
CONFIG_DISK_DRIVER_FLASH=y
CONFIG_ZTEST=y
CONFIG_ZTEST_NEW_API=y
CONFIG_FLASH=y
CONFIG_FLASH_MAP=y

113
tests/subsys/fs/fat_fs_api/src/test_fat_mkfs.c Normal file
View file

@ -0,0 +1,113 @@
/*
* Copyright (c) 2022 Antmicro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include "test_fat.h"
#include <ff.h>
#include <zephyr/storage/flash_map.h>
/* FatFs work area */
static FATFS fat_fs;
/* mounting info */
static struct fs_mount_t fatfs_mnt = {
.type = FS_FATFS,
.mnt_point = "/NAND:",
.fs_data = &fat_fs,
};
void test_fs_mkfs_simple(void);
void test_fs_mkfs_ops(void);
struct fs_mount_t *fs_mkfs_mp = &fatfs_mnt;
const int fs_mkfs_type = FS_FATFS;
uintptr_t fs_mkfs_dev_id = (uintptr_t) "NAND:";
int fs_mkfs_flags;
const char *some_file_path = "/NAND:/SOME";
const char *other_dir_path = "/NAND:/OTHER";
static int wipe_partition(void)
{
/* In this test the first partition on flash device is used for FAT */
unsigned int id = 0;
const struct flash_area *pfa;
int rc = flash_area_open(id, &pfa);
if (rc < 0) {
TC_PRINT("Error accessing flash area %u [%d]\n",
id, rc);
return TC_FAIL;
}
TC_PRINT("Erasing %zu (0x%zx) bytes\n", pfa->fa_size, pfa->fa_size);
rc = flash_area_erase(pfa, 0, pfa->fa_size);
(void)flash_area_close(pfa);
if (rc < 0) {
TC_PRINT("Error wiping flash area %u [%d]\n",
id, rc);
return TC_FAIL;
}
return TC_PASS;
}
ZTEST(fat_fs_mkfs, test_mkfs_simple)
{
int ret;
ret = wipe_partition();
zassert_equal(ret, TC_PASS, "wipe partition failed %d", ret);
test_fs_mkfs_simple();
}
ZTEST(fat_fs_mkfs, test_mkfs_ops)
{
int ret;
ret = wipe_partition();
zassert_equal(ret, TC_PASS, "wipe partition failed %d", ret);
test_fs_mkfs_ops();
}
static MKFS_PARM custom_cfg = {
.fmt = FM_ANY | FM_SFD, /* Any suitable FAT */
.n_fat = 1, /* One FAT fs table */
.align = 0, /* Get sector size via diskio query */
.n_root = CONFIG_FS_FATFS_MAX_ROOT_ENTRIES,
.au_size = 0 /* Auto calculate cluster size */
};
ZTEST(fat_fs_mkfs, test_mkfs_custom)
{
int ret;
struct fs_mount_t mp = fatfs_mnt;
struct fs_statvfs sbuf;
ret = wipe_partition();
zassert_equal(ret, 0, "wipe partition failed %d", ret);
ret = fs_mkfs(FS_FATFS, fs_mkfs_dev_id, &custom_cfg, 0);
zassert_equal(ret, 0, "mkfs failed %d", ret);
mp.flags = FS_MOUNT_FLAG_NO_FORMAT;
ret = fs_mount(&mp);
zassert_equal(ret, 0, "mount failed %d", ret);
ret = fs_statvfs(mp.mnt_point, &sbuf);
zassert_equal(ret, 0, "statvfs failed %d", ret);
TC_PRINT("statvfs: %lu %lu %lu %lu",
sbuf.f_bsize, sbuf.f_frsize, sbuf.f_blocks, sbuf.f_bfree);
ret = fs_unmount(&mp);
zassert_equal(ret, 0, "unmount failed %d", ret);
}
ZTEST_SUITE(fat_fs_mkfs, NULL, NULL, NULL, NULL, NULL);

5
tests/subsys/fs/littlefs/CMakeLists.txt
View file

@ -12,4 +12,7 @@ target_compile_definitions(app PRIVATE
BYPASS_FS_OPEN_FLAGS_LFS_ASSERT_CRASH
BYPASS_FS_OPEN_FLAGS_LFS_RW_IS_DEFAULT
)
target_sources(app PRIVATE ${app_sources} ../common/test_fs_open_flags.c)
target_sources(app PRIVATE
${app_sources}
../common/test_fs_open_flags.c
../common/test_fs_mkfs.c)

1
tests/subsys/fs/littlefs/prj.conf
View file

@ -1,4 +1,5 @@
CONFIG_FILE_SYSTEM=y
CONFIG_FILE_SYSTEM_MKFS=y
CONFIG_FILE_SYSTEM_LITTLEFS=y
CONFIG_ZTEST_NEW_API=y
CONFIG_MAIN_STACK_SIZE=4096

80
tests/subsys/fs/littlefs/src/testfs_mkfs.c Normal file
View file

@ -0,0 +1,80 @@
/*
* Copyright (c) 2022 Antmicro
*
* SPDX-License-Identifier: Apache-2.0
*/
#include <zephyr/ztest.h>
#include <zephyr/fs/littlefs.h>
#include "testfs_tests.h"
#include "testfs_lfs.h"
void test_fs_mkfs_ops(void);
void test_fs_mkfs_simple(void);
/* Using smallest partition for this tests as they do not write
* a lot of data, basically they just check flags.
*/
struct fs_mount_t *fs_mkfs_mp = &testfs_small_mnt;
const int fs_mkfs_type = FS_LITTLEFS;
uintptr_t fs_mkfs_dev_id;
int fs_mkfs_flags;
const char *some_file_path = "/sml/some";
const char *other_dir_path = "/sml/other";
static void cleanup(struct fs_mount_t *mp)
{
TC_PRINT("Clean %s\n", mp->mnt_point);
zassert_equal(testfs_lfs_wipe_partition(mp), TC_PASS,
"Failed to clean partition");
}
ZTEST(littlefs, test_fs_mkfs_simple_lfs)
{
cleanup(fs_mkfs_mp);
fs_mkfs_dev_id = (uintptr_t) testfs_small_mnt.storage_dev;
test_fs_mkfs_simple();
}
ZTEST(littlefs, test_fs_mkfs_ops_lfs)
{
cleanup(fs_mkfs_mp);
fs_mkfs_dev_id = (uintptr_t) testfs_small_mnt.storage_dev;
test_fs_mkfs_ops();
}
/* Custom config with doubled the prog size */
FS_LITTLEFS_DECLARE_CUSTOM_CONFIG(custom_cfg,
CONFIG_FS_LITTLEFS_READ_SIZE,
CONFIG_FS_LITTLEFS_PROG_SIZE * 2,
CONFIG_FS_LITTLEFS_CACHE_SIZE,
CONFIG_FS_LITTLEFS_LOOKAHEAD_SIZE);
ZTEST(littlefs, test_fs_mkfs_custom)
{
int ret = 0;
struct fs_statvfs sbuf;
struct fs_mount_t mnt = testfs_small_mnt;
cleanup(fs_mkfs_mp);
ret = fs_mkfs(FS_LITTLEFS, (uintptr_t)testfs_small_mnt.storage_dev, &custom_cfg, 0);
zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
mnt.flags = FS_MOUNT_FLAG_NO_FORMAT;
mnt.fs_data = &custom_cfg;
ret = fs_mount(&mnt);
zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
ret = fs_statvfs(mnt.mnt_point, &sbuf);
zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
TC_PRINT("f_bsize= %lu", sbuf.f_bsize);
/* Prog size is returned in f_bsize field. */
zassert_equal(sbuf.f_bsize, 2 * CONFIG_FS_LITTLEFS_PROG_SIZE);
ret = fs_unmount(&mnt);
zassert_equal(ret, 0, "Expected success (ret=%d)", ret);
}