load / save mock spiffs

Author: d-a-v

tests/host/common/spiffs_mock.cpp

@@ -22,6 +22,13 @@
 
 #include <spiffs_api.h>
 
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#define SPIFFS_FILE_NAME "spiffs.bin"
+
 extern "C"
 {
     static uint32_t s_phys_addr = 0;
@@ -33,32 +40,89 @@ extern "C"
 
 FS SPIFFS(nullptr);
 
-SpiffsMock::SpiffsMock(size_t fs_size, size_t fs_block, size_t fs_page)
+SpiffsMock::SpiffsMock(size_t fs_size, size_t fs_block, size_t fs_page, bool storage)
 {
-    m_fs.resize(fs_size, 0xff);
+    fprintf(stderr, "SPIFFS: %d bytes\n", (int)fs_size);
+
+    m_storage = storage;
+    m_fs = new uint8_t[m_fs_size = fs_size];
+    memset(&m_fs[0], 0xff, m_fs_size);
+
     s_phys_addr  = 0;
     s_phys_size  = static_cast<uint32_t>(fs_size);
     s_phys_page  = static_cast<uint32_t>(fs_page);
     s_phys_block = static_cast<uint32_t>(fs_block);
-    s_phys_data  = m_fs.data();
+    s_phys_data  = &m_fs[0];
     reset();
 }
 
 void SpiffsMock::reset()
 {
     SPIFFS = FS(FSImplPtr(new SPIFFSImpl(0, s_phys_size, s_phys_page, s_phys_block, 5)));
+    if (m_storage)
+        load();
 }
 
 SpiffsMock::~SpiffsMock()
 {
+    if (m_storage)
+        save();
     s_phys_addr  = 0;
     s_phys_size  = 0;
     s_phys_page  = 0;
     s_phys_block = 0;
     s_phys_data  = nullptr;
+    delete [] m_fs;
+    m_fs = nullptr;
+    m_fs_size = 0;
     SPIFFS = FS(FSImplPtr(nullptr));
 }
 
+void SpiffsMock::load ()
+{
+    if (!m_fs_size)
+        return;
+
+    const char* fname = getenv("SPIFFS_PATH");
+    if (!fname)
+        fname = DEFAULT_SPIFFS_FILE_NAME;
+    int fs = ::open(SPIFFS_FILE_NAME, O_RDONLY);
+    if (fs == -1)
+    {
+        fprintf(stderr, "SPIFFS: loading '%s': %s\n", fname, strerror(errno));
+        return;
+    }
+    fprintf(stderr, "SPIFFS: loading %i bytes from '%s'\n", (int)m_fs_size, fname);
+    if (::read(fs, &m_fs[0], m_fs_size) != (ssize_t)m_fs_size)
+        fprintf(stderr, "SPIFFS: reading %i bytes: %s\n", (int)m_fs_size, strerror(errno));
+    ::close(fs);
+}
+
+void SpiffsMock::save ()
+{
+    if (!m_fs_size)
+        return;
+
+    const char* fname = getenv("SPIFFS_PATH");
+    if (!fname)
+        fname = DEFAULT_SPIFFS_FILE_NAME;
+    int fs = ::open(SPIFFS_FILE_NAME, O_CREAT | O_TRUNC | O_WRONLY, 0644);
+    if (fs == -1)
+    {
+        fprintf(stderr, "SPIFFS: saving '%s': %s\n", fname, strerror(errno));
+        return;
+    }
+    fprintf(stderr, "SPIFFS: saving %i bytes to '%s'\n", (int)m_fs_size, fname);
+
+// this can be a valgrind error, I don't understand how it happens
+//for (size_t i = 0; i < m_fs_size; i++) printf("\r%d:%d   ",(int)i, (int)m_fs[i]);
+
+    if (::write(fs, &m_fs[0], m_fs_size) != (ssize_t)m_fs_size)
+        fprintf(stderr, "SPIFFS: writing %i bytes: %s\n", (int)m_fs_size, strerror(errno));
+    if (::close(fs) == -1)
+        fprintf(stderr, "SPIFFS: closing %s: %s\n", fname, strerror(errno));
+}
+
 int32_t spiffs_hal_read(uint32_t addr, uint32_t size, uint8_t *dst) {
     memcpy(dst, s_phys_data + addr, size);
     return SPIFFS_OK;

tests/host/common/spiffs_mock.h

@@ -21,17 +21,32 @@
 #include <vector>
 #include <FS.h>
 
+#define DEFAULT_SPIFFS_FILE_NAME "spiffs.bin"
+
 class SpiffsMock {
 public:
-    SpiffsMock(size_t fs_size, size_t fs_block, size_t fs_page);
+    SpiffsMock(size_t fs_size, size_t fs_block, size_t fs_page, bool storage = true);
     void reset();
     ~SpiffsMock();
 
 protected:
-    std::vector<uint8_t> m_fs;
+    void load ();
+    void save ();
+
+    // it was a vector, but CI tests & valgrind complain with:
+    // Syscall param write(buf) points to uninitialised byte(s)
+    //    by 0x43E9FF: SpiffsMock::save() (spiffs_mock.cpp:116)
+    //    = if (::write(fs, &m_fs[0], m_fs_size) != (ssize_t)m_fs_size)
+    // so switched to a regular array
+    // and that bug is still here
+    // XXXWIPTODO
+
+    uint8_t* m_fs;
+    size_t m_fs_size;
+    bool m_storage;
 };
 
-#define SPIFFS_MOCK_DECLARE(size_kb, block_kb, page_b) SpiffsMock spiffs_mock(size_kb * 1024, block_kb * 1024, page_b)
+#define SPIFFS_MOCK_DECLARE(size_kb, block_kb, page_b, storage) SpiffsMock spiffs_mock(size_kb * 1024, block_kb * 1024, page_b, storage)
 #define SPIFFS_MOCK_RESET() spiffs_mock.reset()
 
 

tests/host/fs/test_fs.cpp

@@ -50,33 +50,33 @@ static std::set<String> listDir (const char* path)
 
 TEST_CASE("FS can begin","[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
 }
 
 TEST_CASE("FS can't begin with zero size","[fs]")
 {
-    SPIFFS_MOCK_DECLARE(0, 8, 512);
+    SPIFFS_MOCK_DECLARE(0, 8, 512, false);
     REQUIRE_FALSE(SPIFFS.begin());
 }
 
 TEST_CASE("Before begin is called, open will fail","[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE_FALSE(SPIFFS.open("/foo", "w"));
 }
 
 TEST_CASE("FS can create file","[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
     createFile("/test", "");
     REQUIRE(SPIFFS.exists("/test"));
 }
 
 TEST_CASE("Files can be written and appended to","[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
     {
         File f = SPIFFS.open("config1.txt", "w");
@@ -100,7 +100,7 @@ TEST_CASE("Files can be written and appended to","[fs]")
 
 TEST_CASE("Files persist after reset", "[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
     createFile("config1.txt", "file 1");
 
@@ -112,7 +112,7 @@ TEST_CASE("Files persist after reset", "[fs]")
 
 TEST_CASE("Filesystem is empty after format", "[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.format());
     REQUIRE(SPIFFS.begin());
     createFile("/1", "first");
@@ -128,7 +128,7 @@ TEST_CASE("Filesystem is empty after format", "[fs]")
 
 TEST_CASE("Dir lists all files", "[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
     createFile("/empty", "");
     createFile("/not_empty", "some text");
@@ -146,7 +146,7 @@ TEST_CASE("Dir lists all files", "[fs]")
 
 TEST_CASE("File names which are too long are rejected", "[fs]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
     const char* emptyName = "";
     const char* longName_31 = "/234567890123456789012345678901";
@@ -164,7 +164,7 @@ TEST_CASE("File names which are too long are rejected", "[fs]")
 
 TEST_CASE("#1685 Duplicate files", "[fs][bugreport]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
     createFile("/config", "some text");
     createFile("/data", "");
@@ -175,7 +175,7 @@ TEST_CASE("#1685 Duplicate files", "[fs][bugreport]")
 
 TEST_CASE("#1819 Can list all files with openDir(\"\")", "[fs][bugreport]")
 {
-    SPIFFS_MOCK_DECLARE(64, 8, 512);
+    SPIFFS_MOCK_DECLARE(64, 8, 512, false);
     REQUIRE(SPIFFS.begin());
     createFile("/file1", "some text");
     createFile("/file2", "other text");