granicus.if.org Git - esp-idf/blob - components/nvs_flash/test/test_nvs.cpp

   1 // Copyright 2015-2016 Espressif Systems (Shanghai) PTE LTD
   2 //
   3 // Licensed under the Apache License, Version 2.0 (the "License");
   4 // you may not use this file except in compliance with the License.
   5 // You may obtain a copy of the License at
   6
   7 //     http://www.apache.org/licenses/LICENSE-2.0
   8 //
   9 // Unless required by applicable law or agreed to in writing, software
  10 // distributed under the License is distributed on an "AS IS" BASIS,
  11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 // See the License for the specific language governing permissions and
  13 // limitations under the License.
  14 #include "catch.hpp"
  15 #include "nvs.hpp"
  16 #include "nvs_flash.h"
  17 #include "spi_flash_emulation.h"
  18 #include <sstream>
  19 #include <iostream>
  20
  21 using namespace std;
  22 using namespace nvs;
  23
  24 stringstream s_perf;
  25
  26 void dumpBytes(const uint8_t* data, size_t count)
  27 {
  28     for (uint32_t i = 0; i < count; ++i) {
  29         if (i % 32 == 0) {
  30             printf("%08x    ", i);
  31         }
  32         printf("%02x ", data[i]);
  33         if ((i + 1) % 32 == 0) {
  34             printf("\n");
  35         }
  36     }
  37 }
  38
  39 TEST_CASE("crc32 behaves as expected", "[nvs]")
  40 {
  41     Item item1;
  42     item1.datatype = ItemType::I32;
  43     item1.nsIndex = 1;
  44     item1.crc32 = 0;
  45     item1.reserved = 0xff;
  46     fill_n(item1.key, sizeof(item1.key), 0xbb);
  47     fill_n(item1.data, sizeof(item1.data), 0xaa);
  48
  49     auto crc32_1 = item1.calculateCrc32();
  50
  51     Item item2 = item1;
  52     item2.crc32 = crc32_1;
  53
  54     CHECK(crc32_1 == item2.calculateCrc32());
  55
  56     item2 = item1;
  57     item2.nsIndex = 2;
  58     CHECK(crc32_1 != item2.calculateCrc32());
  59
  60     item2 = item1;
  61     item2.datatype = ItemType::U32;
  62     CHECK(crc32_1 != item2.calculateCrc32());
  63
  64     item2 = item1;
  65     strlcpy(item2.key, "foo", Item::MAX_KEY_LENGTH);
  66     CHECK(crc32_1 != item2.calculateCrc32());
  67 }
  68
  69 TEST_CASE("starting with empty flash, page is in uninitialized state", "[nvs]")
  70 {
  71     SpiFlashEmulator emu(1);
  72     Page page;
  73     CHECK(page.state() == Page::PageState::INVALID);
  74     CHECK(page.load(0) == ESP_OK);
  75     CHECK(page.state() == Page::PageState::UNINITIALIZED);
  76 }
  77
  78 TEST_CASE("can distinguish namespaces", "[nvs]")
  79 {
  80     SpiFlashEmulator emu(1);
  81     Page page;
  82     CHECK(page.load(0) == ESP_OK);
  83     int32_t val1 = 0x12345678;
  84     CHECK(page.writeItem(1, ItemType::I32, "intval1", &val1, sizeof(val1)) == ESP_OK);
  85     int32_t val2 = 0x23456789;
  86     CHECK(page.writeItem(2, ItemType::I32, "intval1", &val2, sizeof(val2)) == ESP_OK);
  87
  88     int32_t readVal;
  89     CHECK(page.readItem(2, ItemType::I32, "intval1", &readVal, sizeof(readVal)) == ESP_OK);
  90     CHECK(readVal == val2);
  91
  92 }
  93
  94 TEST_CASE("reading with different type causes type mismatch error", "[nvs]")
  95 {
  96     SpiFlashEmulator emu(1);
  97     Page page;
  98     CHECK(page.load(0) == ESP_OK);
  99     int32_t val = 0x12345678;
 100     CHECK(page.writeItem(1, ItemType::I32, "intval1", &val, sizeof(val)) == ESP_OK);
 101     CHECK(page.readItem(1, ItemType::U32, "intval1", &val, sizeof(val)) == ESP_ERR_NVS_TYPE_MISMATCH);
 102 }
 103
 104 TEST_CASE("when page is erased, it's state becomes UNITIALIZED", "[nvs]")
 105 {
 106     SpiFlashEmulator emu(1);
 107     Page page;
 108     CHECK(page.load(0) == ESP_OK);
 109     int32_t val = 0x12345678;
 110     CHECK(page.writeItem(1, ItemType::I32, "intval1", &val, sizeof(val)) == ESP_OK);
 111     CHECK(page.erase() == ESP_OK);
 112     CHECK(page.state() == Page::PageState::UNINITIALIZED);
 113 }
 114
 115 TEST_CASE("when writing and erasing, used/erased counts are updated correctly", "[nvs]")
 116 {
 117     SpiFlashEmulator emu(1);
 118     Page page;
 119     CHECK(page.load(0) == ESP_OK);
 120     CHECK(page.getUsedEntryCount() == 0);
 121     CHECK(page.getErasedEntryCount() == 0);
 122     uint32_t foo1 = 0;
 123     CHECK(page.writeItem(1, "foo1", foo1) == ESP_OK);
 124     CHECK(page.getUsedEntryCount() == 1);
 125     CHECK(page.writeItem(2, "foo1", foo1) == ESP_OK);
 126     CHECK(page.getUsedEntryCount() == 2);
 127     CHECK(page.eraseItem<uint32_t>(2, "foo1") == ESP_OK);
 128     CHECK(page.getUsedEntryCount() == 1);
 129     CHECK(page.getErasedEntryCount() == 1);
 130     for (size_t i = 0; i < Page::ENTRY_COUNT - 2; ++i) {
 131         char name[16];
 132         snprintf(name, sizeof(name), "i%ld", i);
 133         CHECK(page.writeItem(1, name, i) == ESP_OK);
 134     }
 135     CHECK(page.getUsedEntryCount() == Page::ENTRY_COUNT - 1);
 136     CHECK(page.getErasedEntryCount() == 1);
 137     for (size_t i = 0; i < Page::ENTRY_COUNT - 2; ++i) {
 138         char name[16];
 139         snprintf(name, sizeof(name), "i%ld", i);
 140         CHECK(page.eraseItem(1, itemTypeOf<size_t>(), name) == ESP_OK);
 141     }
 142     CHECK(page.getUsedEntryCount() == 1);
 143     CHECK(page.getErasedEntryCount() == Page::ENTRY_COUNT - 1);
 144 }
 145
 146 TEST_CASE("when page is full, adding an element fails", "[nvs]")
 147 {
 148     SpiFlashEmulator emu(1);
 149     Page page;
 150     CHECK(page.load(0) == ESP_OK);
 151     for (size_t i = 0; i < Page::ENTRY_COUNT; ++i) {
 152         char name[16];
 153         snprintf(name, sizeof(name), "i%ld", i);
 154         CHECK(page.writeItem(1, name, i) == ESP_OK);
 155     }
 156     CHECK(page.state() == Page::PageState::FULL);
 157     CHECK(page.writeItem(1, "foo", 64UL) == ESP_ERR_NVS_PAGE_FULL);
 158     CHECK(page.state() == Page::PageState::FULL);
 159 }
 160
 161 TEST_CASE("page maintains its seq number")
 162 {
 163     SpiFlashEmulator emu(1);
 164     {
 165         Page page;
 166         CHECK(page.load(0) == ESP_OK);
 167         CHECK(page.setSeqNumber(123) == ESP_OK);
 168         int32_t val = 42;
 169         CHECK(page.writeItem(1, ItemType::I32, "dummy", &val, sizeof(val)) == ESP_OK);
 170     }
 171     {
 172         Page page;
 173         CHECK(page.load(0) == ESP_OK);
 174         uint32_t seqno;
 175         CHECK(page.getSeqNumber(seqno) == ESP_OK);
 176         CHECK(seqno == 123);
 177     }
 178 }
 179
 180 TEST_CASE("can write and read variable length data", "[nvs]")
 181 {
 182     SpiFlashEmulator emu(1);
 183     Page page;
 184     CHECK(page.load(0) == ESP_OK);
 185     const char str[] = "foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234";
 186     size_t len = strlen(str);
 187     CHECK(page.writeItem(1, "stuff1", 42) == ESP_OK);
 188     CHECK(page.writeItem(1, "stuff2", 1) == ESP_OK);
 189     CHECK(page.writeItem(1, ItemType::SZ, "foobaar", str, len + 1) == ESP_OK);
 190     CHECK(page.writeItem(1, "stuff3", 2) == ESP_OK);
 191     CHECK(page.writeItem(1, ItemType::BLOB, "baz", str, len) == ESP_OK);
 192     CHECK(page.writeItem(1, "stuff4", 0x7abbccdd) == ESP_OK);
 193
 194     char buf[sizeof(str) + 16];
 195     int32_t value;
 196     CHECK(page.readItem(1, "stuff1", value) == ESP_OK);
 197     CHECK(value == 42);
 198     CHECK(page.readItem(1, "stuff2", value) == ESP_OK);
 199     CHECK(value == 1);
 200     CHECK(page.readItem(1, "stuff3", value) == ESP_OK);
 201     CHECK(value == 2);
 202     CHECK(page.readItem(1, "stuff4", value) == ESP_OK);
 203     CHECK(value == 0x7abbccdd);
 204
 205     fill_n(buf, sizeof(buf), 0xff);
 206     CHECK(page.readItem(1, ItemType::SZ, "foobaar", buf, sizeof(buf)) == ESP_OK);
 207     CHECK(memcmp(buf, str, strlen(str) + 1) == 0);
 208
 209     fill_n(buf, sizeof(buf), 0xff);
 210     CHECK(page.readItem(1, ItemType::BLOB, "baz", buf, sizeof(buf)) == ESP_OK);
 211     CHECK(memcmp(buf, str, strlen(str)) == 0);
 212 }
 213
 214
 215 TEST_CASE("can init PageManager in empty flash", "[nvs]")
 216 {
 217     SpiFlashEmulator emu(4);
 218     PageManager pm;
 219     CHECK(pm.load(0, 4) == ESP_OK);
 220 }
 221
 222 TEST_CASE("PageManager adds page in the correct order", "[nvs]")
 223 {
 224     const size_t pageCount = 8;
 225     SpiFlashEmulator emu(pageCount);
 226     uint32_t pageNo[pageCount] = { -1U, 50, 11, -1U, 23, 22, 24, 49};
 227
 228     for (uint32_t i = 0; i < pageCount; ++i) {
 229         Page p;
 230         p.load(i);
 231         if (pageNo[i] != -1U) {
 232             p.setSeqNumber(pageNo[i]);
 233             p.writeItem(1, "foo", 10U);
 234         }
 235     }
 236
 237     PageManager pageManager;
 238     CHECK(pageManager.load(0, pageCount) == ESP_OK);
 239
 240     uint32_t lastSeqNo = 0;
 241     for (auto it = std::begin(pageManager); it != std::end(pageManager); ++it) {
 242         uint32_t seqNo;
 243         CHECK(it->getSeqNumber(seqNo) == ESP_OK);
 244         CHECK(seqNo > lastSeqNo);
 245     }
 246 }
 247
 248 TEST_CASE("can init storage in empty flash", "[nvs]")
 249 {
 250     SpiFlashEmulator emu(8);
 251     Storage storage;
 252     emu.setBounds(4, 8);
 253     CHECK(storage.init(4, 4) == ESP_OK);
 254     s_perf << "Time to init empty storage (4 sectors): " << emu.getTotalTime() << " us" << std::endl;
 255 }
 256
 257 TEST_CASE("storage doesn't add duplicates within one page", "[nvs]")
 258 {
 259     SpiFlashEmulator emu(8);
 260     Storage storage;
 261     emu.setBounds(4, 8);
 262     CHECK(storage.init(4, 4) == ESP_OK);
 263     int bar = 0;
 264     CHECK(storage.writeItem(1, "bar", bar) == ESP_OK);
 265     CHECK(storage.writeItem(1, "bar", bar) == ESP_OK);
 266
 267     Page page;
 268     page.load(4);
 269     CHECK(page.getUsedEntryCount() == 1);
 270     CHECK(page.getErasedEntryCount() == 1);
 271 }
 272
 273 TEST_CASE("can write one item a thousand times", "[nvs]")
 274 {
 275     SpiFlashEmulator emu(8);
 276     Storage storage;
 277     emu.setBounds(4, 8);
 278     CHECK(storage.init(4, 4) == ESP_OK);
 279     for (size_t i = 0; i < Page::ENTRY_COUNT * 4 * 2; ++i) {
 280         REQUIRE(storage.writeItem(1, "i", static_cast<int>(i)) == ESP_OK);
 281     }
 282     s_perf << "Time to write one item a thousand times: " << emu.getTotalTime() << " us (" << emu.getEraseOps() << " " << emu.getWriteOps() << " " << emu.getReadOps() << " " << emu.getWriteBytes() << " " << emu.getReadBytes() << ")" << std::endl;
 283 }
 284
 285 TEST_CASE("storage doesn't add duplicates within multiple pages", "[nvs]")
 286 {
 287     SpiFlashEmulator emu(8);
 288     Storage storage;
 289     emu.setBounds(4, 8);
 290     CHECK(storage.init(4, 4) == ESP_OK);
 291     int bar = 0;
 292     CHECK(storage.writeItem(1, "bar", bar) == ESP_OK);
 293     for (size_t i = 0; i < Page::ENTRY_COUNT; ++i) {
 294         CHECK(storage.writeItem(1, "foo", static_cast<int>(bar)) == ESP_OK);
 295     }
 296     CHECK(storage.writeItem(1, "bar", bar) == ESP_OK);
 297
 298     Page page;
 299     page.load(4);
 300     CHECK(page.findItem(1, itemTypeOf<int>(), "bar") == ESP_ERR_NVS_NOT_FOUND);
 301     page.load(5);
 302     CHECK(page.findItem(1, itemTypeOf<int>(), "bar") == ESP_OK);
 303 }
 304
 305 TEST_CASE("can write and read variable length data lots of times", "[nvs]")
 306 {
 307     SpiFlashEmulator emu(8);
 308     Storage storage;
 309     emu.setBounds(4, 8);
 310     CHECK(storage.init(4, 4) == ESP_OK);
 311     const char str[] = "foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234";
 312     char buf[sizeof(str) + 16];
 313     size_t len = strlen(str);
 314     for (size_t i = 0; i < Page::ENTRY_COUNT * 4 * 2; ++i) {
 315         CAPTURE(i);
 316         CHECK(storage.writeItem(1, ItemType::SZ, "foobaar", str, len + 1) == ESP_OK);
 317         CHECK(storage.writeItem(1, "foo", static_cast<uint32_t>(i)) == ESP_OK);
 318
 319         uint32_t value;
 320         CHECK(storage.readItem(1, "foo", value) == ESP_OK);
 321         CHECK(value == i);
 322
 323         fill_n(buf, sizeof(buf), 0xff);
 324         CHECK(storage.readItem(1, ItemType::SZ, "foobaar", buf, sizeof(buf)) == ESP_OK);
 325         CHECK(memcmp(buf, str, strlen(str) + 1) == 0);
 326     }
 327     s_perf << "Time to write one string and one integer a thousand times: " << emu.getTotalTime() << " us (" << emu.getEraseOps() << " " << emu.getWriteOps() << " " << emu.getReadOps() << " " << emu.getWriteBytes() << " " << emu.getReadBytes() << ")" << std::endl;
 328 }
 329
 330
 331 TEST_CASE("can get length of variable length data", "[nvs]")
 332 {
 333     SpiFlashEmulator emu(8);
 334     emu.randomize(200);
 335     Storage storage;
 336     emu.setBounds(4, 8);
 337     CHECK(storage.init(4, 4) == ESP_OK);
 338     const char str[] = "foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234foobar1234";
 339     size_t len = strlen(str);
 340     CHECK(storage.writeItem(1, ItemType::SZ, "foobaar", str, len + 1) == ESP_OK);
 341     size_t dataSize;
 342     CHECK(storage.getItemDataSize(1, ItemType::SZ, "foobaar", dataSize) == ESP_OK);
 343     CHECK(dataSize == len + 1);
 344
 345     CHECK(storage.writeItem(2, ItemType::BLOB, "foobaar", str, len) == ESP_OK);
 346     CHECK(storage.getItemDataSize(2, ItemType::BLOB, "foobaar", dataSize) == ESP_OK);
 347     CHECK(dataSize == len);
 348 }
 349
 350
 351 TEST_CASE("can create namespaces", "[nvs]")
 352 {
 353     SpiFlashEmulator emu(8);
 354     Storage storage;
 355     emu.setBounds(4, 8);
 356     CHECK(storage.init(4, 4) == ESP_OK);
 357     uint8_t nsi;
 358     CHECK(storage.createOrOpenNamespace("wifi", false, nsi) == ESP_ERR_NVS_NOT_FOUND);
 359
 360     CHECK(storage.createOrOpenNamespace("wifi", true, nsi) == ESP_OK);
 361     Page page;
 362     page.load(4);
 363     CHECK(page.findItem(Page::NS_INDEX, ItemType::U8, "wifi") == ESP_OK);
 364 }
 365
 366 TEST_CASE("storage may become full", "[nvs]")
 367 {
 368     SpiFlashEmulator emu(8);
 369     Storage storage;
 370     emu.setBounds(4, 8);
 371     CHECK(storage.init(4, 4) == ESP_OK);
 372     for (size_t i = 0; i < Page::ENTRY_COUNT * 3; ++i) {
 373         char name[Item::MAX_KEY_LENGTH + 1];
 374         snprintf(name, sizeof(name), "key%05d", static_cast<int>(i));
 375         REQUIRE(storage.writeItem(1, name, static_cast<int>(i)) == ESP_OK);
 376     }
 377     REQUIRE(storage.writeItem(1, "foo", 10) == ESP_ERR_NVS_NOT_ENOUGH_SPACE);
 378 }
 379
 380 TEST_CASE("can modify an item on a page which will be erased", "[nvs]")
 381 {
 382     SpiFlashEmulator emu(2);
 383     Storage storage;
 384     CHECK(storage.init(0, 2) == ESP_OK);
 385     for (size_t i = 0; i < Page::ENTRY_COUNT * 3 + 1; ++i) {
 386         REQUIRE(storage.writeItem(1, "foo", 42U) == ESP_OK);
 387     }
 388 }
 389
 390
 391 #define TEST_ESP_ERR(rc, res) CHECK((rc) == (res))
 392 #define TEST_ESP_OK(rc) CHECK((rc) == ESP_OK)
 393
 394 TEST_CASE("nvs api tests", "[nvs]")
 395 {
 396     SpiFlashEmulator emu(10);
 397     emu.randomize(100);
 398
 399     nvs_handle handle_1;
 400     const uint32_t NVS_FLASH_SECTOR = 6;
 401     const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3;
 402     emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN);
 403
 404
 405     TEST_ESP_ERR(nvs_open("namespace1", NVS_READWRITE, &handle_1), ESP_ERR_NVS_NOT_INITIALIZED);
 406     for (uint16_t i = NVS_FLASH_SECTOR; i <NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN; ++i) {
 407         spi_flash_erase_sector(i);
 408     }
 409     TEST_ESP_OK(nvs_flash_init(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN));
 410
 411     TEST_ESP_ERR(nvs_open("namespace1", NVS_READONLY, &handle_1), ESP_ERR_NVS_NOT_FOUND);
 412
 413     // TEST_ESP_ERR(nvs_set_i32(handle_1, "foo", 0x12345678), ESP_ERR_NVS_READ_ONLY);
 414     // nvs_close(handle_1);
 415
 416     TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle_1));
 417     TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x12345678));
 418     TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x23456789));
 419
 420     nvs_handle handle_2;
 421     TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2));
 422     TEST_ESP_OK(nvs_set_i32(handle_2, "foo", 0x3456789a));
 423     const char* str = "value 0123456789abcdef0123456789abcdef";
 424     TEST_ESP_OK(nvs_set_str(handle_2, "key", str));
 425
 426     int32_t v1;
 427     TEST_ESP_OK(nvs_get_i32(handle_1, "foo", &v1));
 428     CHECK(0x23456789 == v1);
 429
 430     int32_t v2;
 431     TEST_ESP_OK(nvs_get_i32(handle_2, "foo", &v2));
 432     CHECK(0x3456789a == v2);
 433
 434     char buf[strlen(str) + 1];
 435     size_t buf_len = sizeof(buf);
 436
 437     TEST_ESP_OK(nvs_get_str(handle_2, "key", buf, &buf_len));
 438
 439     CHECK(0 == strcmp(buf, str));
 440 }
 441
 442
 443 TEST_CASE("wifi test", "[nvs]")
 444 {
 445     SpiFlashEmulator emu(10);
 446     emu.randomize(10);
 447
 448     nvs_handle handle;
 449     const uint32_t NVS_FLASH_SECTOR = 5;
 450     const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3;
 451     emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN);
 452     TEST_ESP_OK(nvs_flash_init(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN));
 453
 454     TEST_ESP_OK(nvs_open("nvs.net80211", NVS_READWRITE, &handle));
 455
 456     uint8_t opmode = 2;
 457     if (nvs_get_u8(handle, "wifi.opmode", &opmode) != ESP_OK) {
 458         TEST_ESP_OK(nvs_set_u8(handle, "wifi.opmode", opmode));
 459     }
 460 }
 461
 462
 463 TEST_CASE("can init storage from flash with random contents", "[nvs]")
 464 {
 465     SpiFlashEmulator emu(10);
 466     emu.randomize(42);
 467
 468     nvs_handle handle;
 469     const uint32_t NVS_FLASH_SECTOR = 5;
 470     const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3;
 471     emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN);
 472     TEST_ESP_OK(nvs_flash_init(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN));
 473
 474     TEST_ESP_OK(nvs_open("nvs.net80211", NVS_READWRITE, &handle));
 475
 476     uint8_t opmode = 2;
 477     if (nvs_get_u8(handle, "wifi.opmode", &opmode) != ESP_OK) {
 478         TEST_ESP_OK(nvs_set_u8(handle, "wifi.opmode", opmode));
 479     }
 480 }
 481
 482
 483 TEST_CASE("nvs api tests, starting with random data in flash", "[nvs][.][long]")
 484 {
 485     for (size_t count = 0; count < 10000; ++count) {
 486         SpiFlashEmulator emu(10);
 487         emu.randomize(static_cast<uint32_t>(count));
 488
 489         const uint32_t NVS_FLASH_SECTOR = 6;
 490         const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3;
 491         emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN);
 492
 493         TEST_ESP_OK(nvs_flash_init(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN));
 494
 495         nvs_handle handle_1;
 496         TEST_ESP_ERR(nvs_open("namespace1", NVS_READONLY, &handle_1), ESP_ERR_NVS_NOT_FOUND);
 497
 498         TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle_1));
 499         TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x12345678));
 500         for (size_t i = 0; i < 500; ++i) {
 501             nvs_handle handle_2;
 502             TEST_ESP_OK(nvs_open("namespace2", NVS_READWRITE, &handle_2));
 503             TEST_ESP_OK(nvs_set_i32(handle_1, "foo", 0x23456789 % (i + 1)));
 504             TEST_ESP_OK(nvs_set_i32(handle_2, "foo", static_cast<int32_t>(i)));
 505             const char* str = "value 0123456789abcdef0123456789abcdef %09d";
 506             char str_buf[128];
 507             snprintf(str_buf, sizeof(str_buf), str, i + count * 1024);
 508             TEST_ESP_OK(nvs_set_str(handle_2, "key", str_buf));
 509
 510             int32_t v1;
 511             TEST_ESP_OK(nvs_get_i32(handle_1, "foo", &v1));
 512             CHECK(0x23456789 % (i + 1) == v1);
 513
 514             int32_t v2;
 515             TEST_ESP_OK(nvs_get_i32(handle_2, "foo", &v2));
 516             CHECK(static_cast<int32_t>(i) == v2);
 517
 518             char buf[128];
 519             size_t buf_len = sizeof(buf);
 520
 521             TEST_ESP_OK(nvs_get_str(handle_2, "key", buf, &buf_len));
 522
 523             CHECK(0 == strcmp(buf, str_buf));
 524             nvs_close(handle_2);
 525         }
 526         nvs_close(handle_1);
 527     }
 528 }
 529
 530 template<typename TGen>
 531 esp_err_t doRandomThings(nvs_handle handle, TGen gen, size_t count) {
 532
 533     const char* keys[] = {"foo", "bar", "longkey_0123456", "another key", "param1", "param2", "param3", "param4", "param5"};
 534     const ItemType types[] = {ItemType::I32, ItemType::I32, ItemType::U64, ItemType::U64, ItemType::SZ, ItemType::SZ, ItemType::SZ, ItemType::SZ, ItemType::SZ};
 535
 536     int32_t v1 = 0, v2 = 0;
 537     uint64_t v3 = 0, v4 = 0;
 538     const size_t strBufLen = 1024;
 539     char v5[strBufLen], v6[strBufLen], v7[strBufLen], v8[strBufLen], v9[strBufLen];
 540
 541     void* values[] = {&v1, &v2, &v3, &v4, &v5, &v6, &v7, &v8, &v9};
 542
 543     const size_t nKeys = sizeof(keys) / sizeof(keys[0]);
 544     static_assert(nKeys == sizeof(types) / sizeof(types[0]), "");
 545     static_assert(nKeys == sizeof(values) / sizeof(values[0]), "");
 546
 547     bool written[nKeys];
 548     std::fill_n(written, nKeys, false);
 549
 550     auto generateRandomString = [](char* dst, size_t size) {
 551         size_t len = 0;
 552     };
 553
 554     auto randomRead = [&](size_t index) -> esp_err_t {
 555         switch (types[index]) {
 556             case ItemType::I32:
 557             {
 558                 int32_t val;
 559                 auto err = nvs_get_i32(handle, keys[index], &val);
 560                 if (err == ESP_ERR_FLASH_OP_FAIL) {
 561                     return err;
 562                 }
 563                 if (!written[index]) {
 564                     REQUIRE(err == ESP_ERR_NVS_NOT_FOUND);
 565                 }
 566                 else {
 567                     REQUIRE(val == *reinterpret_cast<int32_t*>(values[index]));
 568                 }
 569                 break;
 570             }
 571
 572             case ItemType::U64:
 573             {
 574                 uint64_t val;
 575                 auto err = nvs_get_u64(handle, keys[index], &val);
 576                 if (err == ESP_ERR_FLASH_OP_FAIL) {
 577                     return err;
 578                 }
 579                 if (!written[index]) {
 580                     REQUIRE(err == ESP_ERR_NVS_NOT_FOUND);
 581                 }
 582                 else {
 583                     REQUIRE(val == *reinterpret_cast<uint64_t*>(values[index]));
 584                 }
 585                 break;
 586             }
 587
 588             case ItemType::SZ:
 589             {
 590                 char buf[strBufLen];
 591                 size_t len = strBufLen;
 592                 auto err = nvs_get_str(handle, keys[index], buf, &len);
 593                 if (err == ESP_ERR_FLASH_OP_FAIL) {
 594                     return err;
 595                 }
 596                 if (!written[index]) {
 597                     REQUIRE(err == ESP_ERR_NVS_NOT_FOUND);
 598                 }
 599                 else {
 600                     REQUIRE(strncmp(buf, reinterpret_cast<const char*>(values[index]), strBufLen));
 601                 }
 602                 break;
 603             }
 604
 605             default:
 606                 assert(0);
 607         }
 608         return ESP_OK;
 609     };
 610
 611     auto randomWrite = [&](size_t index) -> esp_err_t {
 612         switch (types[index]) {
 613             case ItemType::I32:
 614             {
 615                 int32_t val = static_cast<int32_t>(gen());
 616                 *reinterpret_cast<int32_t*>(values[index]) = val;
 617
 618                 auto err = nvs_set_i32(handle, keys[index], val);
 619                 if (err == ESP_ERR_FLASH_OP_FAIL) {
 620                     return err;
 621                 }
 622                 REQUIRE(err == ESP_OK);
 623                 written[index] = true;
 624                 break;
 625             }
 626
 627             case ItemType::U64:
 628             {
 629                 uint64_t val = static_cast<uint64_t>(gen());
 630                 *reinterpret_cast<uint64_t*>(values[index]) = val;
 631
 632                 auto err = nvs_set_u64(handle, keys[index], val);
 633                 if (err == ESP_ERR_FLASH_OP_FAIL) {
 634                     return err;
 635                 }
 636                 REQUIRE(err == ESP_OK);
 637                 written[index] = true;
 638                 break;
 639             }
 640
 641             case ItemType::SZ:
 642             {
 643                 char buf[strBufLen];
 644                 size_t len = strBufLen;
 645
 646                 size_t strLen = gen() % (strBufLen - 1);
 647                 std::generate_n(buf, strLen, [&]() -> char {
 648                     const char c = static_cast<char>(gen() % 127);
 649                     return (c < 32) ? 32 : c;
 650                 });
 651
 652                 auto err = nvs_set_str(handle, keys[index], buf);
 653                 if (err == ESP_ERR_FLASH_OP_FAIL) {
 654                     return err;
 655                 }
 656                 REQUIRE(err == ESP_OK);
 657                 written[index] = true;
 658                 break;
 659             }
 660
 661             default:
 662                 assert(0);
 663         }
 664         return ESP_OK;
 665     };
 666
 667
 668     for (size_t i = 0; i < count; ++i) {
 669         size_t index = gen() % nKeys;
 670         switch (gen() % 3) {
 671             case 0:  // read, 1/3
 672                 if (randomRead(index) == ESP_ERR_FLASH_OP_FAIL) {
 673                     return ESP_ERR_FLASH_OP_FAIL;
 674                 }
 675                 break;
 676
 677             default: // write, 2/3
 678                 if (randomWrite(index) == ESP_ERR_FLASH_OP_FAIL) {
 679                     return ESP_ERR_FLASH_OP_FAIL;
 680                 }
 681                 break;
 682         }
 683     }
 684     return ESP_OK;
 685 }
 686
 687 TEST_CASE("monkey test", "[nvs][monkey]")
 688 {
 689     std::random_device rd;
 690     std::mt19937 gen(rd());
 691     uint32_t seed = 3;
 692     gen.seed(seed);
 693
 694     SpiFlashEmulator emu(10);
 695     emu.randomize(seed);
 696
 697     const uint32_t NVS_FLASH_SECTOR = 6;
 698     const uint32_t NVS_FLASH_SECTOR_COUNT_MIN = 3;
 699     emu.setBounds(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR + NVS_FLASH_SECTOR_COUNT_MIN);
 700
 701     TEST_ESP_OK(nvs_flash_init(NVS_FLASH_SECTOR, NVS_FLASH_SECTOR_COUNT_MIN));
 702
 703     nvs_handle handle;
 704     TEST_ESP_OK(nvs_open("namespace1", NVS_READWRITE, &handle));
 705
 706     CHECK(doRandomThings(handle, gen, 10000) == ESP_OK);
 707
 708 }
 709
 710 TEST_CASE("dump all performance data", "[nvs]")
 711 {
 712     std::cout << "====================" << std::endl << "Dumping benchmarks" << std::endl;
 713     std::cout << s_perf.str() << std::endl;
 714     std::cout << "====================" << std::endl;
 715 }