tests: subsys/fs/nvs: Move to new ztest api
Convert nvs tests to use new ztest API
related: zephyrproject-rtos#47002
Signed-off-by: Simon Hein <SHein@baumer.com>
diff --git a/tests/subsys/fs/nvs/prj.conf b/tests/subsys/fs/nvs/prj.conf
index 7d7f4ae..b4b8502 100644
--- a/tests/subsys/fs/nvs/prj.conf
+++ b/tests/subsys/fs/nvs/prj.conf
@@ -1,5 +1,6 @@
CONFIG_ZTEST=y
CONFIG_ZTEST_STACK_SIZE=4096
+CONFIG_ZTEST_NEW_API=y
CONFIG_STDOUT_CONSOLE=y
CONFIG_FLASH=y
diff --git a/tests/subsys/fs/nvs/src/main.c b/tests/subsys/fs/nvs/src/main.c
index d95f2ca..dcf61f7 100644
--- a/tests/subsys/fs/nvs/src/main.c
+++ b/tests/subsys/fs/nvs/src/main.c
@@ -34,64 +34,85 @@
#define TEST_SECTOR_COUNT 5U
static const struct device *flash_dev = DEVICE_DT_GET(TEST_NVS_FLASH_DEV_NODE);
-static struct nvs_fs fs;
-struct stats_hdr *sim_stats;
-struct stats_hdr *sim_thresholds;
-void setup(void)
-{
- sim_stats = stats_group_find("flash_sim_stats");
- sim_thresholds = stats_group_find("flash_sim_thresholds");
+struct nvs_fixture {
+ struct nvs_fs fs;
+ struct stats_hdr *sim_stats;
+ struct stats_hdr *sim_thresholds;
+};
- /* Verify if NVS is initialized. */
- if (fs.ready) {
- int err;
-
- err = nvs_clear(&fs);
- zassert_true(err == 0, "nvs_clear call failure: %d", err);
- }
-}
-
-void teardown(void)
-{
- if (sim_stats) {
- stats_reset(sim_stats);
- }
- if (sim_thresholds) {
- stats_reset(sim_thresholds);
- }
-}
-
-void test_nvs_mount(void)
+static void *setup(void)
{
int err;
const struct flash_area *fa;
struct flash_pages_info info;
+ static struct nvs_fixture fixture;
+
+ __ASSERT_NO_MSG(device_is_ready(flash_dev));
err = flash_area_open(FLASH_AREA_ID(TEST_NVS_FLASH_AREA), &fa);
zassert_true(err == 0, "flash_area_open() fail: %d", err);
- fs.offset = TEST_NVS_FLASH_OFFSET;
- err = flash_get_page_info_by_offs(flash_area_get_device(fa), fs.offset,
+ fixture.fs.offset = TEST_NVS_FLASH_OFFSET;
+ err = flash_get_page_info_by_offs(flash_area_get_device(fa), fixture.fs.offset,
&info);
zassert_true(err == 0, "Unable to get page info: %d", err);
- fs.sector_size = info.size;
- fs.sector_count = TEST_SECTOR_COUNT;
- fs.flash_device = flash_area_get_device(fa);
+ fixture.fs.sector_size = info.size;
+ fixture.fs.sector_count = TEST_SECTOR_COUNT;
+ fixture.fs.flash_device = flash_area_get_device(fa);
- err = nvs_mount(&fs);
+ return &fixture;
+}
+
+static void before(void *data)
+{
+ struct nvs_fixture *fixture = (struct nvs_fixture *)data;
+
+ fixture->sim_stats = stats_group_find("flash_sim_stats");
+ fixture->sim_thresholds = stats_group_find("flash_sim_thresholds");
+
+ /* Verify if NVS is initialized. */
+ if (fixture->fs.ready) {
+ int err;
+
+ err = nvs_clear(&fixture->fs);
+ zassert_true(err == 0, "nvs_clear call failure: %d", err);
+ }
+}
+
+static void after(void *data)
+{
+ struct nvs_fixture *fixture = (struct nvs_fixture *)data;
+
+ if (fixture->sim_stats) {
+ stats_reset(fixture->sim_stats);
+ }
+ if (fixture->sim_thresholds) {
+ stats_reset(fixture->sim_thresholds);
+ }
+
+ fixture->fs.sector_count = TEST_SECTOR_COUNT;
+}
+
+ZTEST_SUITE(nvs, NULL, setup, before, after, NULL);
+
+ZTEST_F(nvs, test_nvs_mount)
+{
+ int err;
+
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
}
-static void execute_long_pattern_write(uint16_t id)
+static void execute_long_pattern_write(uint16_t id, struct nvs_fs *fs)
{
char rd_buf[512];
char wr_buf[512];
char pattern[] = {0xDE, 0xAD, 0xBE, 0xEF};
size_t len;
- len = nvs_read(&fs, id, rd_buf, sizeof(rd_buf));
+ len = nvs_read(fs, id, rd_buf, sizeof(rd_buf));
zassert_true(len == -ENOENT, "nvs_read unexpected failure: %d", len);
BUILD_ASSERT((sizeof(wr_buf) % sizeof(pattern)) == 0);
@@ -99,24 +120,24 @@
memcpy(wr_buf + i, pattern, sizeof(pattern));
}
- len = nvs_write(&fs, id, wr_buf, sizeof(wr_buf));
+ len = nvs_write(fs, id, wr_buf, sizeof(wr_buf));
zassert_true(len == sizeof(wr_buf), "nvs_write failed: %d", len);
- len = nvs_read(&fs, id, rd_buf, sizeof(rd_buf));
+ len = nvs_read(fs, id, rd_buf, sizeof(rd_buf));
zassert_true(len == sizeof(rd_buf), "nvs_read unexpected failure: %d",
len);
zassert_mem_equal(wr_buf, rd_buf, sizeof(rd_buf),
"RD buff should be equal to the WR buff");
}
-void test_nvs_write(void)
+ZTEST_F(nvs, test_nvs_write)
{
int err;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- execute_long_pattern_write(TEST_DATA_ID);
+ execute_long_pattern_write(TEST_DATA_ID, &fixture->fs);
}
static int flash_sim_write_calls_find(struct stats_hdr *hdr, void *arg,
@@ -141,7 +162,7 @@
return 0;
}
-void test_nvs_corrupted_write(void)
+ZTEST_F(nvs, test_nvs_corrupted_write)
{
int err;
size_t len;
@@ -153,10 +174,10 @@
uint32_t *flash_write_stat;
uint32_t *flash_max_write_calls;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- err = nvs_read(&fs, TEST_DATA_ID, rd_buf, sizeof(rd_buf));
+ err = nvs_read(&fixture->fs, TEST_DATA_ID, rd_buf, sizeof(rd_buf));
zassert_true(err == -ENOENT, "nvs_read unexpected failure: %d", err);
BUILD_ASSERT((sizeof(wr_buf_1) % sizeof(pattern_1)) == 0);
@@ -164,10 +185,10 @@
memcpy(wr_buf_1 + i, pattern_1, sizeof(pattern_1));
}
- len = nvs_write(&fs, TEST_DATA_ID, wr_buf_1, sizeof(wr_buf_1));
+ len = nvs_write(&fixture->fs, TEST_DATA_ID, wr_buf_1, sizeof(wr_buf_1));
zassert_true(len == sizeof(wr_buf_1), "nvs_write failed: %d", len);
- len = nvs_read(&fs, TEST_DATA_ID, rd_buf, sizeof(rd_buf));
+ len = nvs_read(&fixture->fs, TEST_DATA_ID, rd_buf, sizeof(rd_buf));
zassert_true(len == sizeof(rd_buf), "nvs_read unexpected failure: %d",
len);
zassert_mem_equal(wr_buf_1, rd_buf, sizeof(rd_buf),
@@ -181,9 +202,9 @@
/* Set the maximum number of writes that the flash simulator can
* execute.
*/
- stats_walk(sim_thresholds, flash_sim_max_write_calls_find,
+ stats_walk(fixture->sim_thresholds, flash_sim_max_write_calls_find,
&flash_max_write_calls);
- stats_walk(sim_stats, flash_sim_write_calls_find, &flash_write_stat);
+ stats_walk(fixture->sim_stats, flash_sim_write_calls_find, &flash_write_stat);
*flash_max_write_calls = *flash_write_stat - 1;
*flash_write_stat = 0;
@@ -192,14 +213,16 @@
* This should simulate power down during flash write. The written data
* are corrupted at this point and should be discarded by the NVS.
*/
- len = nvs_write(&fs, TEST_DATA_ID, wr_buf_2, sizeof(wr_buf_2));
+ len = nvs_write(&fixture->fs, TEST_DATA_ID, wr_buf_2, sizeof(wr_buf_2));
zassert_true(len == sizeof(wr_buf_2), "nvs_write failed: %d", len);
/* Reinitialize the NVS. */
- memset(&fs, 0, sizeof(fs));
- test_nvs_mount();
+ memset(&fixture->fs, 0, sizeof(fixture->fs));
+ (void)setup();
+ err = nvs_mount(&fixture->fs);
+ zassert_true(err == 0, "nvs_mount call failure: %d", err);
- len = nvs_read(&fs, TEST_DATA_ID, rd_buf, sizeof(rd_buf));
+ len = nvs_read(&fixture->fs, TEST_DATA_ID, rd_buf, sizeof(rd_buf));
zassert_true(len == sizeof(rd_buf), "nvs_read unexpected failure: %d",
len);
zassert_true(memcmp(wr_buf_2, rd_buf, sizeof(rd_buf)) != 0,
@@ -210,7 +233,7 @@
"write operation has failed");
}
-void test_nvs_gc(void)
+ZTEST_F(nvs, test_nvs_gc)
{
int err;
int len;
@@ -221,9 +244,9 @@
/* 25th write will trigger GC. */
const uint16_t max_writes = 26;
- fs.sector_count = 2;
+ fixture->fs.sector_count = 2;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
for (uint16_t i = 0; i < max_writes; i++) {
@@ -232,12 +255,12 @@
memset(buf, id_data, sizeof(buf));
- len = nvs_write(&fs, id, buf, sizeof(buf));
+ len = nvs_write(&fixture->fs, id, buf, sizeof(buf));
zassert_true(len == sizeof(buf), "nvs_write failed: %d", len);
}
for (uint16_t id = 0; id < max_id; id++) {
- len = nvs_read(&fs, id, rd_buf, sizeof(buf));
+ len = nvs_read(&fixture->fs, id, rd_buf, sizeof(buf));
zassert_true(len == sizeof(rd_buf),
"nvs_read unexpected failure: %d", len);
@@ -250,11 +273,11 @@
}
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
for (uint16_t id = 0; id < max_id; id++) {
- len = nvs_read(&fs, id, rd_buf, sizeof(buf));
+ len = nvs_read(&fixture->fs, id, rd_buf, sizeof(buf));
zassert_true(len == sizeof(rd_buf),
"nvs_read unexpected failure: %d", len);
@@ -309,7 +332,7 @@
/**
* Full round of GC over 3 sectors
*/
-void test_nvs_gc_3sectors(void)
+ZTEST_F(nvs, test_nvs_gc_3sectors)
{
int err;
@@ -323,72 +346,72 @@
/* 125th write will trigger 4st GC. */
const uint16_t max_writes_4 = 51 + 25 + 25 + 25;
- fs.sector_count = 3;
+ fixture->fs.sector_count = 3;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 0,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 0,
"unexpected write sector");
/* Trigger 1st GC */
- write_content(max_id, 0, max_writes, &fs);
+ write_content(max_id, 0, max_writes, &fixture->fs);
/* sector sequence: empty,closed, write */
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 2,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 2,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 2,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 2,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
/* Trigger 2nd GC */
- write_content(max_id, max_writes, max_writes_2, &fs);
+ write_content(max_id, max_writes, max_writes_2, &fixture->fs);
/* sector sequence: write, empty, closed */
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 0,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 0,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 0,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 0,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
/* Trigger 3rd GC */
- write_content(max_id, max_writes_2, max_writes_3, &fs);
+ write_content(max_id, max_writes_2, max_writes_3, &fixture->fs);
/* sector sequence: closed, write, empty */
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 1,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 1,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 1,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 1,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
/* Trigger 4th GC */
- write_content(max_id, max_writes_3, max_writes_4, &fs);
+ write_content(max_id, max_writes_3, max_writes_4, &fixture->fs);
/* sector sequence: empty,closed, write */
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 2,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 2,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- zassert_equal(fs.ate_wra >> ADDR_SECT_SHIFT, 2,
+ zassert_equal(fixture->fs.ate_wra >> ADDR_SECT_SHIFT, 2,
"unexpected write sector");
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
}
static int flash_sim_erase_calls_find(struct stats_hdr *hdr, void *arg,
@@ -424,7 +447,7 @@
return 0;
}
-void test_nvs_corrupted_sector_close_operation(void)
+ZTEST_F(nvs, test_nvs_corrupted_sector_close_operation)
{
int err;
int len;
@@ -440,16 +463,16 @@
const uint16_t max_writes = 26;
/* Get the address of simulator parameters. */
- stats_walk(sim_thresholds, flash_sim_max_write_calls_find,
+ stats_walk(fixture->sim_thresholds, flash_sim_max_write_calls_find,
&flash_max_write_calls);
- stats_walk(sim_thresholds, flash_sim_max_erase_calls_find,
+ stats_walk(fixture->sim_thresholds, flash_sim_max_erase_calls_find,
&flash_max_erase_calls);
- stats_walk(sim_thresholds, flash_sim_max_len_find,
+ stats_walk(fixture->sim_thresholds, flash_sim_max_len_find,
&flash_max_len);
- stats_walk(sim_stats, flash_sim_write_calls_find, &flash_write_stat);
- stats_walk(sim_stats, flash_sim_erase_calls_find, &flash_erase_stat);
+ stats_walk(fixture->sim_stats, flash_sim_write_calls_find, &flash_write_stat);
+ stats_walk(fixture->sim_stats, flash_sim_erase_calls_find, &flash_erase_stat);
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
for (uint16_t i = 0; i < max_writes; i++) {
@@ -472,7 +495,7 @@
*flash_max_len = 4;
}
- len = nvs_write(&fs, id, buf, sizeof(buf));
+ len = nvs_write(&fixture->fs, id, buf, sizeof(buf));
zassert_true(len == sizeof(buf), "nvs_write failed: %d", len);
}
@@ -481,32 +504,32 @@
*flash_max_erase_calls = 0;
*flash_max_len = 0;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- check_content(max_id, &fs);
+ check_content(max_id, &fixture->fs);
/* Ensure that the NVS is able to store new content. */
- execute_long_pattern_write(max_id);
+ execute_long_pattern_write(max_id, &fixture->fs);
}
/**
* @brief Test case when storage become full, so only deletion is possible.
*/
-void test_nvs_full_sector(void)
+ZTEST_F(nvs, test_nvs_full_sector)
{
int err;
ssize_t len;
uint16_t filling_id = 0;
uint16_t i, data_read;
- fs.sector_count = 3;
+ fixture->fs.sector_count = 3;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
while (1) {
- len = nvs_write(&fs, filling_id, &filling_id,
+ len = nvs_write(&fixture->fs, filling_id, &filling_id,
sizeof(filling_id));
if (len == -ENOSPC) {
break;
@@ -517,19 +540,19 @@
}
/* check whether can delete whatever from full storage */
- err = nvs_delete(&fs, 1);
+ err = nvs_delete(&fixture->fs, 1);
zassert_true(err == 0, "nvs_delete call failure: %d", err);
/* the last sector is full now, test re-initialization */
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
- len = nvs_write(&fs, filling_id, &filling_id, sizeof(filling_id));
+ len = nvs_write(&fixture->fs, filling_id, &filling_id, sizeof(filling_id));
zassert_true(len == sizeof(filling_id), "nvs_write failed: %d", len);
/* sanitycheck on NVS content */
for (i = 0; i <= filling_id; i++) {
- len = nvs_read(&fs, i, &data_read, sizeof(data_read));
+ len = nvs_read(&fixture->fs, i, &data_read, sizeof(data_read));
if (i == 1) {
zassert_true(len == -ENOENT,
"nvs_read shouldn't found the entry: %d",
@@ -544,20 +567,20 @@
}
}
-void test_delete(void)
+ZTEST_F(nvs, test_delete)
{
int err;
ssize_t len;
uint16_t filling_id, data_read;
uint32_t ate_wra, data_wra;
- fs.sector_count = 3;
+ fixture->fs.sector_count = 3;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
for (filling_id = 0; filling_id < 10; filling_id++) {
- len = nvs_write(&fs, filling_id, &filling_id,
+ len = nvs_write(&fixture->fs, filling_id, &filling_id,
sizeof(filling_id));
zassert_true(len == sizeof(filling_id), "nvs_write failed: %d",
@@ -568,36 +591,36 @@
}
/* delete the first entry while it is the most recent one */
- err = nvs_delete(&fs, filling_id);
+ err = nvs_delete(&fixture->fs, filling_id);
zassert_true(err == 0, "nvs_delete call failure: %d", err);
- len = nvs_read(&fs, filling_id, &data_read, sizeof(data_read));
+ len = nvs_read(&fixture->fs, filling_id, &data_read, sizeof(data_read));
zassert_true(len == -ENOENT,
"nvs_read shouldn't found the entry: %d", len);
}
/* delete existing entry */
- err = nvs_delete(&fs, 1);
+ err = nvs_delete(&fixture->fs, 1);
zassert_true(err == 0, "nvs_delete call failure: %d", err);
- len = nvs_read(&fs, 1, &data_read, sizeof(data_read));
+ len = nvs_read(&fixture->fs, 1, &data_read, sizeof(data_read));
zassert_true(len == -ENOENT, "nvs_read shouldn't found the entry: %d",
len);
- ate_wra = fs.ate_wra;
- data_wra = fs.data_wra;
+ ate_wra = fixture->fs.ate_wra;
+ data_wra = fixture->fs.data_wra;
/* delete already deleted entry */
- err = nvs_delete(&fs, 1);
+ err = nvs_delete(&fixture->fs, 1);
zassert_true(err == 0, "nvs_delete call failure: %d", err);
- zassert_true(ate_wra == fs.ate_wra && data_wra == fs.data_wra,
+ zassert_true(ate_wra == fixture->fs.ate_wra && data_wra == fixture->fs.data_wra,
"delete already deleted entry should not make"
" any footprint in the storage");
/* delete nonexisting entry */
- err = nvs_delete(&fs, filling_id);
+ err = nvs_delete(&fixture->fs, filling_id);
zassert_true(err == 0, "nvs_delete call failure: %d", err);
- zassert_true(ate_wra == fs.ate_wra && data_wra == fs.data_wra,
+ zassert_true(ate_wra == fixture->fs.ate_wra && data_wra == fixture->fs.data_wra,
"delete nonexistent entry should not make"
" any footprint in the storage");
}
@@ -609,7 +632,7 @@
* has an invalid crc8, the offset should not be used and a recover of the
* last ate should be done instead.
*/
-void test_nvs_gc_corrupt_close_ate(void)
+ZTEST_F(nvs, test_nvs_gc_corrupt_close_ate)
{
struct nvs_ate ate, close_ate;
uint32_t data;
@@ -617,7 +640,7 @@
int err;
close_ate.id = 0xffff;
- close_ate.offset = fs.sector_size - sizeof(struct nvs_ate) * 5;
+ close_ate.offset = fixture->fs.sector_size - sizeof(struct nvs_ate) * 5;
close_ate.len = 0;
close_ate.crc8 = 0xff; /* Incorrect crc8 */
@@ -628,34 +651,35 @@
offsetof(struct nvs_ate, crc8));
/* Mark sector 0 as closed */
- err = flash_write(flash_dev, fs.offset + fs.sector_size -
+ err = flash_write(fixture->fs.flash_device, fixture->fs.offset + fixture->fs.sector_size -
sizeof(struct nvs_ate), &close_ate,
sizeof(close_ate));
zassert_true(err == 0, "flash_write failed: %d", err);
/* Write valid ate at -6 */
- err = flash_write(flash_dev, fs.offset + fs.sector_size -
+ err = flash_write(fixture->fs.flash_device, fixture->fs.offset + fixture->fs.sector_size -
sizeof(struct nvs_ate) * 6, &ate, sizeof(ate));
zassert_true(err == 0, "flash_write failed: %d", err);
/* Write data for previous ate */
data = 0xaa55aa55;
- err = flash_write(flash_dev, fs.offset, &data, sizeof(data));
+ err = flash_write(fixture->fs.flash_device, fixture->fs.offset, &data, sizeof(data));
zassert_true(err == 0, "flash_write failed: %d", err);
/* Mark sector 1 as closed */
- err = flash_write(flash_dev, fs.offset + (2 * fs.sector_size) -
+ err = flash_write(fixture->fs.flash_device,
+ fixture->fs.offset + (2 * fixture->fs.sector_size) -
sizeof(struct nvs_ate), &close_ate,
sizeof(close_ate));
zassert_true(err == 0, "flash_write failed: %d", err);
- fs.sector_count = 3;
+ fixture->fs.sector_count = 3;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
data = 0;
- len = nvs_read(&fs, 1, &data, sizeof(data));
+ len = nvs_read(&fixture->fs, 1, &data, sizeof(data));
zassert_true(len == sizeof(data),
"nvs_read should have read %d bytes", sizeof(data));
zassert_true(data == 0xaa55aa55, "unexpected value %d", data);
@@ -664,13 +688,13 @@
/*
* Test that garbage-collection correctly handles corrupt ate's.
*/
-void test_nvs_gc_corrupt_ate(void)
+ZTEST_F(nvs, test_nvs_gc_corrupt_ate)
{
struct nvs_ate corrupt_ate, close_ate;
int err;
close_ate.id = 0xffff;
- close_ate.offset = fs.sector_size / 2;
+ close_ate.offset = fixture->fs.sector_size / 2;
close_ate.len = 0;
close_ate.crc8 = crc8_ccitt(0xff, &close_ate,
offsetof(struct nvs_ate, crc8));
@@ -681,36 +705,38 @@
corrupt_ate.crc8 = 0xff; /* Incorrect crc8 */
/* Mark sector 0 as closed */
- err = flash_write(flash_dev, fs.offset + fs.sector_size -
+ err = flash_write(fixture->fs.flash_device, fixture->fs.offset + fixture->fs.sector_size -
sizeof(struct nvs_ate), &close_ate,
sizeof(close_ate));
zassert_true(err == 0, "flash_write failed: %d", err);
/* Write a corrupt ate */
- err = flash_write(flash_dev, fs.offset + (fs.sector_size / 2),
+ err = flash_write(fixture->fs.flash_device,
+ fixture->fs.offset + (fixture->fs.sector_size / 2),
&corrupt_ate, sizeof(corrupt_ate));
zassert_true(err == 0, "flash_write failed: %d", err);
/* Mark sector 1 as closed */
- err = flash_write(flash_dev, fs.offset + (2 * fs.sector_size) -
+ err = flash_write(fixture->fs.flash_device,
+ fixture->fs.offset + (2 * fixture->fs.sector_size) -
sizeof(struct nvs_ate), &close_ate,
sizeof(close_ate));
zassert_true(err == 0, "flash_write failed: %d", err);
- fs.sector_count = 3;
+ fixture->fs.sector_count = 3;
- err = nvs_mount(&fs);
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_mount call failure: %d", err);
}
#ifdef CONFIG_NVS_LOOKUP_CACHE
-static size_t num_matching_cache_entries(uint32_t addr, bool compare_sector_only)
+static size_t num_matching_cache_entries(uint32_t addr, bool compare_sector_only, struct nvs_fs *fs)
{
size_t i, num = 0;
uint32_t mask = compare_sector_only ? ADDR_SECT_MASK : UINT32_MAX;
for (i = 0; i < CONFIG_NVS_LOOKUP_CACHE_SIZE; i++) {
- if ((fs.lookup_cache[i] & mask) == addr) {
+ if ((fs->lookup_cache[i] & mask) == addr) {
num++;
}
}
@@ -723,7 +749,7 @@
* Test that NVS lookup cache is properly rebuilt on nvs_mount(), or initialized
* to NVS_LOOKUP_CACHE_NO_ADDR if the store is empty.
*/
-void test_nvs_cache_init(void)
+ZTEST_F(nvs, test_nvs_cache_init)
{
#ifdef CONFIG_NVS_LOOKUP_CACHE
int err;
@@ -733,35 +759,35 @@
/* Test cache initialization when the store is empty */
- fs.sector_count = 3;
- err = nvs_mount(&fs);
+ fixture->fs.sector_count = 3;
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_init call failure: %d", err);
- num = num_matching_cache_entries(NVS_LOOKUP_CACHE_NO_ADDR, false);
+ num = num_matching_cache_entries(NVS_LOOKUP_CACHE_NO_ADDR, false, &fixture->fs);
zassert_equal(num, CONFIG_NVS_LOOKUP_CACHE_SIZE, "uninitialized cache");
/* Test cache update after nvs_write() */
- ate_addr = fs.ate_wra;
- err = nvs_write(&fs, 1, &data, sizeof(data));
+ ate_addr = fixture->fs.ate_wra;
+ err = nvs_write(&fixture->fs, 1, &data, sizeof(data));
zassert_equal(err, sizeof(data), "nvs_write call failure: %d", err);
- num = num_matching_cache_entries(NVS_LOOKUP_CACHE_NO_ADDR, false);
+ num = num_matching_cache_entries(NVS_LOOKUP_CACHE_NO_ADDR, false, &fixture->fs);
zassert_equal(num, CONFIG_NVS_LOOKUP_CACHE_SIZE - 1, "cache not updated after write");
- num = num_matching_cache_entries(ate_addr, false);
+ num = num_matching_cache_entries(ate_addr, false, &fixture->fs);
zassert_equal(num, 1, "invalid cache entry after write");
/* Test cache initialization when the store is non-empty */
- memset(fs.lookup_cache, 0xAA, sizeof(fs.lookup_cache));
- err = nvs_mount(&fs);
+ memset(fixture->fs.lookup_cache, 0xAA, sizeof(fixture->fs.lookup_cache));
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_init call failure: %d", err);
- num = num_matching_cache_entries(NVS_LOOKUP_CACHE_NO_ADDR, false);
+ num = num_matching_cache_entries(NVS_LOOKUP_CACHE_NO_ADDR, false, &fixture->fs);
zassert_equal(num, CONFIG_NVS_LOOKUP_CACHE_SIZE - 1, "uninitialized cache after restart");
- num = num_matching_cache_entries(ate_addr, false);
+ num = num_matching_cache_entries(ate_addr, false, &fixture->fs);
zassert_equal(num, 1, "invalid cache entry after restart");
#endif
}
@@ -770,25 +796,25 @@
* Test that even after writing more NVS IDs than the number of NVS lookup cache
* entries they all can be read correctly.
*/
-void test_nvs_cache_collission(void)
+ZTEST_F(nvs, test_nvs_cache_collission)
{
#ifdef CONFIG_NVS_LOOKUP_CACHE
int err;
uint16_t id;
uint16_t data;
- fs.sector_count = 3;
- err = nvs_mount(&fs);
+ fixture->fs.sector_count = 3;
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_init call failure: %d", err);
for (id = 0; id < CONFIG_NVS_LOOKUP_CACHE_SIZE + 1; id++) {
data = id;
- err = nvs_write(&fs, id, &data, sizeof(data));
+ err = nvs_write(&fixture->fs, id, &data, sizeof(data));
zassert_equal(err, sizeof(data), "nvs_write call failure: %d", err);
}
for (id = 0; id < CONFIG_NVS_LOOKUP_CACHE_SIZE + 1; id++) {
- err = nvs_read(&fs, id, &data, sizeof(data));
+ err = nvs_read(&fixture->fs, id, &data, sizeof(data));
zassert_equal(err, sizeof(data), "nvs_read call failure: %d", err);
zassert_equal(data, id, "incorrect data read");
}
@@ -798,35 +824,35 @@
/*
* Test that NVS lookup cache does not contain any address from gc-ed sector
*/
-void test_nvs_cache_gc(void)
+ZTEST_F(nvs, test_nvs_cache_gc)
{
#ifdef CONFIG_NVS_LOOKUP_CACHE
int err;
size_t num;
uint16_t data = 0;
- fs.sector_count = 3;
- err = nvs_mount(&fs);
+ fixture->fs.sector_count = 3;
+ err = nvs_mount(&fixture->fs);
zassert_true(err == 0, "nvs_init call failure: %d", err);
/* Fill the first sector with writes of ID 1 */
- while (fs.data_wra + sizeof(data) <= fs.ate_wra) {
+ while (fixture->fs.data_wra + sizeof(data) <= fixture->fs.ate_wra) {
++data;
- err = nvs_write(&fs, 1, &data, sizeof(data));
+ err = nvs_write(&fixture->fs, 1, &data, sizeof(data));
zassert_equal(err, sizeof(data), "nvs_write call failure: %d", err);
}
/* Verify that cache contains a single entry for sector 0 */
- num = num_matching_cache_entries(0 << ADDR_SECT_SHIFT, true);
+ num = num_matching_cache_entries(0 << ADDR_SECT_SHIFT, true, &fixture->fs);
zassert_equal(num, 1, "invalid cache content after filling sector 0");
/* Fill the second sector with writes of ID 2 */
- while ((fs.ate_wra >> ADDR_SECT_SHIFT) != 2) {
+ while ((fixture->fs.ate_wra >> ADDR_SECT_SHIFT) != 2) {
++data;
- err = nvs_write(&fs, 2, &data, sizeof(data));
+ err = nvs_write(&fixture->fs, 2, &data, sizeof(data));
zassert_equal(err, sizeof(data), "nvs_write call failure: %d", err);
}
@@ -835,47 +861,10 @@
* reflected by the cache content.
*/
- num = num_matching_cache_entries(0 << ADDR_SECT_SHIFT, true);
+ num = num_matching_cache_entries(0 << ADDR_SECT_SHIFT, true, &fixture->fs);
zassert_equal(num, 0, "not invalidated cache entries aftetr gc");
- num = num_matching_cache_entries(2 << ADDR_SECT_SHIFT, true);
+ num = num_matching_cache_entries(2 << ADDR_SECT_SHIFT, true, &fixture->fs);
zassert_equal(num, 2, "invalid cache content after gc");
#endif
}
-
-void test_main(void)
-{
- __ASSERT_NO_MSG(device_is_ready(flash_dev));
-
- ztest_test_suite(test_nvs,
- ztest_unit_test_setup_teardown(test_nvs_mount, setup,
- teardown),
- ztest_unit_test_setup_teardown(test_nvs_write, setup,
- teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_corrupted_write, setup, teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_gc, setup, teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_gc_3sectors, setup, teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_corrupted_sector_close_operation,
- setup, teardown),
- ztest_unit_test_setup_teardown(test_nvs_full_sector,
- setup, teardown),
- ztest_unit_test_setup_teardown(test_delete, setup,
- teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_gc_corrupt_close_ate, setup, teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_gc_corrupt_ate, setup, teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_cache_init, setup, teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_cache_collission, setup, teardown),
- ztest_unit_test_setup_teardown(
- test_nvs_cache_gc, setup, teardown)
- );
-
- ztest_run_test_suite(test_nvs);
-}
