espressif/esp-idf
1
0
Fork 1
mirror of https://github.com/espressif/esp-idf.git synced 2025-10-02 18:10:57 +02:00
Code Issues Packages Projects Releases Wiki Activity

fix(nvs_flash): Host test adopted to the new clang initializer rules

Browse Source
This commit is contained in:
radek.tandler
2025-06-23 09:38:21 +02:00
parent 233a76e808
commit 0f5c963a03
1 changed files with 30 additions and 20 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
components/nvs_flash/host_test/nvs_host_test/main/test_nvs.cpp
View File

@@ -608,7 +608,7 @@ TEST_CASE("nvs api tests", "[nvs]")
nvs_handle_t handle_2; nvs_handle_t handle_2;
TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2)); TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2));
TEST_ESP_OK(nvs_set_i32(handle_2, "foo", 0x3456789a)); TEST_ESP_OK(nvs_set_i32(handle_2, "foo", 0x3456789a));
const char *str = "value 0123456789abcdef0123456789abcdef"; char str[] = "value 0123456789abcdef0123456789abcdef";
TEST_ESP_OK(nvs_set_str(handle_2, "key", str)); TEST_ESP_OK(nvs_set_str(handle_2, "key", str));
int32_t v1; int32_t v1;
@@ -619,7 +619,7 @@ TEST_CASE("nvs api tests", "[nvs]")
TEST_ESP_OK(nvs_get_i32(handle_2, "foo", &v2)); TEST_ESP_OK(nvs_get_i32(handle_2, "foo", &v2));
CHECK(0x3456789a == v2); CHECK(0x3456789a == v2);
char buf[strlen(str) + 1]; char buf[sizeof(str)];
size_t buf_len = sizeof(buf); size_t buf_len = sizeof(buf);
size_t buf_len_needed; size_t buf_len_needed;
@@ -1270,13 +1270,15 @@ public:
} else { } else {
blobBufLen = largeBlobLen ; blobBufLen = largeBlobLen ;
} }
uint8_t buf[blobBufLen]; uint8_t* buf = new uint8_t[blobBufLen];
memset(buf, 0, blobBufLen); memset(buf, 0, blobBufLen);
size_t len = blobBufLen; size_t len = blobBufLen;
auto err = nvs_get_blob(handle, keys[index], buf, &len); auto err = nvs_get_blob(handle, keys[index], buf, &len);
auto eval_result = evaluate(delayCount, err, types[index], written[index], potentially_written[index], buf, values[index], future_values[index], blobBufLen);
delete [] buf;
REQUIRE(evaluate(delayCount, err, types[index], written[index], potentially_written[index], buf, values[index], future_values[index], blobBufLen) == true); REQUIRE(eval_result == true);
break; break;
} }
@@ -1371,7 +1373,7 @@ public:
} else { } else {
blobBufLen = largeBlobLen ; blobBufLen = largeBlobLen ;
} }
uint8_t buf[blobBufLen]; uint8_t* buf = new uint8_t[blobBufLen];
memset(buf, 0, blobBufLen); memset(buf, 0, blobBufLen);
size_t blobLen = gen() % blobBufLen; size_t blobLen = gen() % blobBufLen;
std::generate_n(buf, blobLen, [&]() -> uint8_t { std::generate_n(buf, blobLen, [&]() -> uint8_t {
@@ -1386,16 +1388,19 @@ public:
if (err == ESP_ERR_FLASH_OP_FAIL) { if (err == ESP_ERR_FLASH_OP_FAIL) {
// mark potentially written // mark potentially written
potentially_written[index] = true; potentially_written[index] = true;
delete [] buf;
return err; return err;
} }
if (err == ESP_ERR_NVS_REMOVE_FAILED) { if (err == ESP_ERR_NVS_REMOVE_FAILED) {
written[index] = true; written[index] = true;
memcpy(reinterpret_cast<uint8_t *>(values[index]), buf, blobBufLen); memcpy(reinterpret_cast<uint8_t *>(values[index]), buf, blobBufLen);
delete [] buf;
return ESP_ERR_FLASH_OP_FAIL; return ESP_ERR_FLASH_OP_FAIL;
} }
REQUIRE(err == ESP_OK); REQUIRE(err == ESP_OK);
written[index] = true; written[index] = true;
memcpy(reinterpret_cast<char *>(values[index]), buf, blobBufLen); memcpy(reinterpret_cast<char *>(values[index]), buf, blobBufLen);
delete [] buf;
break; break;
} }
@@ -2889,16 +2894,20 @@ TEST_CASE("inconsistent fields in item header with correct crc are handled for m
// initial values // initial values
uint32_t uval1 = 1; uint32_t uval1 = 1;
uint32_t uval2 = 2; uint32_t uval2 = 2;
uint8_t blob_data1[blob_key1_chunk_0_len + blob_key1_chunk_1_len]; size_t blob_data1_len = blob_key1_chunk_0_len + blob_key1_chunk_1_len;
uint8_t blob_data2[blob_key2_chunk_len]; size_t blob_data2_len = blob_key2_chunk_len;
uint8_t* blob_data1 = new uint8_t[blob_data1_len];
uint8_t* blob_data2 = new uint8_t[blob_data2_len];
// value buffers // value buffers
uint32_t read_u32_1; uint32_t read_u32_1;
uint32_t read_u32_2; uint32_t read_u32_2;
uint8_t read_blob1[sizeof(blob_data1)];
uint8_t read_blob2[sizeof(blob_data2)]; size_t read_blob1_size = blob_data1_len;
size_t read_blob1_size = sizeof(read_blob1); size_t read_blob2_size = blob_data2_len;
size_t read_blob2_size = sizeof(read_blob2); uint8_t* read_blob1 = new uint8_t[read_blob1_size];
uint8_t* read_blob2 = new uint8_t[read_blob2_size];
// Skip one page, 2 entries of page header and 3 entries of valueblob1's BLOB_DATA entries // Skip one page, 2 entries of page header and 3 entries of valueblob1's BLOB_DATA entries
const size_t blob_index_offset = 4096 + 32 * 2 + 32 * 3; const size_t blob_index_offset = 4096 + 32 * 2 + 32 * 3;
@@ -2921,10 +2930,10 @@ TEST_CASE("inconsistent fields in item header with correct crc are handled for m
// initialize buffers // initialize buffers
read_u32_1 = 0; read_u32_1 = 0;
read_u32_2 = 0; read_u32_2 = 0;
memset(blob_data1, 0x55, sizeof(blob_data1)); memset(blob_data1, 0x55, blob_data1_len);
memset(blob_data2, 0xaa, sizeof(blob_data2)); memset(blob_data2, 0xaa, blob_data2_len);
memset(read_blob1, 0, sizeof(read_blob1)); memset(read_blob1, 0, read_blob1_size);
memset(read_blob2, 0, sizeof(read_blob2)); memset(read_blob2, 0, read_blob2_size);
// Write initial data to the nvs partition // Write initial data to the nvs partition
{ {
@@ -2933,8 +2942,8 @@ TEST_CASE("inconsistent fields in item header with correct crc are handled for m
nvs_handle_t handle; nvs_handle_t handle;
TEST_ESP_OK(nvs_open("test", NVS_READWRITE, &handle)); TEST_ESP_OK(nvs_open("test", NVS_READWRITE, &handle));
TEST_ESP_OK(nvs_set_u32(handle, ukey1, uval1)); TEST_ESP_OK(nvs_set_u32(handle, ukey1, uval1));
TEST_ESP_OK(nvs_set_blob(handle, blob_key1, blob_data1, sizeof(blob_data1))); TEST_ESP_OK(nvs_set_blob(handle, blob_key1, blob_data1, blob_data1_len));
TEST_ESP_OK(nvs_set_blob(handle, blob_key2, blob_data2, sizeof(blob_data2))); TEST_ESP_OK(nvs_set_blob(handle, blob_key2, blob_data2, blob_data2_len));
TEST_ESP_OK(nvs_set_u32(handle, ukey2, uval2)); TEST_ESP_OK(nvs_set_u32(handle, ukey2, uval2));
nvs_close(handle); nvs_close(handle);
@@ -3067,8 +3076,8 @@ TEST_CASE("inconsistent fields in item header with correct crc are handled for m
nvs_handle_t handle; nvs_handle_t handle;
TEST_ESP_OK(nvs_open("test", NVS_READWRITE, &handle)); TEST_ESP_OK(nvs_open("test", NVS_READWRITE, &handle));
TEST_ESP_OK(nvs_get_u32(handle, ukey1, &read_u32_1)); TEST_ESP_OK(nvs_get_u32(handle, ukey1, &read_u32_1));
TEST_ESP_ERR(nvs_get_blob(handle, blob_key1, &read_blob1, &read_blob1_size), ESP_ERR_NVS_NOT_FOUND); TEST_ESP_ERR(nvs_get_blob(handle, blob_key1, read_blob1, &read_blob1_size), ESP_ERR_NVS_NOT_FOUND);
TEST_ESP_OK(nvs_get_blob(handle, blob_key2, &read_blob2, &read_blob2_size)); TEST_ESP_OK(nvs_get_blob(handle, blob_key2, read_blob2, &read_blob2_size));
TEST_ESP_OK(nvs_get_u32(handle, ukey2, &read_u32_2)); TEST_ESP_OK(nvs_get_u32(handle, ukey2, &read_u32_2));
nvs_close(handle); nvs_close(handle);
TEST_ESP_OK(nvs_flash_deinit_partition(f.part()->get_partition_name())); TEST_ESP_OK(nvs_flash_deinit_partition(f.part()->get_partition_name()));
@@ -3076,7 +3085,8 @@ TEST_CASE("inconsistent fields in item header with correct crc are handled for m
// validate the data // validate the data
CHECK(read_u32_1 == uval1); CHECK(read_u32_1 == uval1);
CHECK(read_u32_2 == uval2); CHECK(read_u32_2 == uval2);
CHECK(memcmp(read_blob2, blob_data2, sizeof(blob_data2)) == 0); CHECK(read_blob2_size == blob_data2_len);
CHECK(memcmp(read_blob2, blob_data2, read_blob2_size) == 0);
} }
} }