inbetween

src/test_check.c

@@ -0,0 +1,418 @@
+/*
+ * test_dev.c
+ *
+ *  Created on: Jul 14, 2013
+ *      Author: petera
+ */
+
+
+#include "testrunner.h"
+#include "test_spiffs.h"
+#include "spiffs_nucleus.h"
+#include "spiffs.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <unistd.h>
+
+
+SUITE(check_tests)
+void setup() {
+  _setup();
+}
+void teardown() {
+  _teardown();
+}
+
+TEST(evil_write) {
+  fs_set_validate_flashing(0);
+  printf("writing corruption to block 1 data range (leaving lu intact)\n");
+  u32_t data_range = SPIFFS_CFG_LOG_BLOCK_SZ(FS) -
+      SPIFFS_CFG_LOG_PAGE_SZ(FS) * (SPIFFS_OBJ_LOOKUP_PAGES(FS));
+  u8_t *corruption = malloc(data_range);
+  memrand(corruption, data_range);
+  u32_t addr = 0 * SPIFFS_CFG_LOG_PAGE_SZ(FS) * SPIFFS_OBJ_LOOKUP_PAGES(FS);
+  area_write(addr, corruption, data_range);
+  free(corruption);
+
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+
+  printf("CHECK1-----------------\n");
+  SPIFFS_check(FS);
+  printf("CHECK2-----------------\n");
+  SPIFFS_check(FS);
+  printf("CHECK3-----------------\n");
+  SPIFFS_check(FS);
+
+  res = test_create_and_write_file("file2", size, size);
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(evil_write)
+
+
+TEST(lu_check1) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify lu entry data page index 1
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id & ~SPIFFS_OBJ_ID_IX_FLAG, 1, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  // reset lu entry to being erased, but keep page data
+  spiffs_obj_id obj_id = SPIFFS_OBJ_ID_DELETED;
+  spiffs_block_ix bix = SPIFFS_BLOCK_FOR_PAGE(FS, pix);
+  int entry = SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(FS, pix);
+  u32_t addr = SPIFFS_BLOCK_TO_PADDR(FS, bix) + entry*sizeof(spiffs_obj_id);
+
+  area_write(addr, (u8_t*)&obj_id, sizeof(spiffs_obj_id));
+
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+  SPIFFS_check(FS);
+
+  return TEST_RES_OK;
+} TEST_END(lu_check1)
+
+
+TEST(page_cons1) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify object index, find object index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  // set object index entry 2 to a bad page
+  u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + sizeof(spiffs_page_object_ix_header) + 0 * sizeof(spiffs_page_ix);
+  spiffs_page_ix bad_pix_ref = 0x55;
+  area_write(addr, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+  area_write(addr+2, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+
+  // delete all cache
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+
+  SPIFFS_check(FS);
+
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(page_cons1)
+
+
+TEST(page_cons2) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify object index, find object index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  // find data page span index 0
+  spiffs_page_ix dpix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id & ~SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &dpix);
+  TEST_CHECK(res >= 0);
+
+  // set object index entry 1+2 to a data page 0
+  u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + sizeof(spiffs_page_object_ix_header) + 1 * sizeof(spiffs_page_ix);
+  spiffs_page_ix bad_pix_ref = dpix;
+  area_write(addr, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+  area_write(addr+sizeof(spiffs_page_ix), (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+
+  // delete all cache
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+
+  SPIFFS_check(FS);
+
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(page_cons2)
+
+
+
+TEST(page_cons3) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify object index, find object index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  // set object index entry 1+2 lookup page
+  u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + sizeof(spiffs_page_object_ix_header) + 1 * sizeof(spiffs_page_ix);
+  spiffs_page_ix bad_pix_ref = SPIFFS_PAGES_PER_BLOCK(FS) * (*FS.block_count - 2);
+  area_write(addr, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+  area_write(addr+sizeof(spiffs_page_ix), (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+
+  // delete all cache
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+
+  SPIFFS_check(FS);
+
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(page_cons3)
+
+
+TEST(page_cons_final) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify page header, make unfinalized
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id & ~SPIFFS_OBJ_ID_IX_FLAG, 1, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  // set page span ix 1 as unfinalized
+  u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + offsetof(spiffs_page_header, flags);
+  u8_t flags;
+  area_read(addr, (u8_t*)&flags, 1);
+  flags |= SPIFFS_PH_FLAG_FINAL;
+  area_write(addr, (u8_t*)&flags, 1);
+
+  // delete all cache
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+
+  SPIFFS_check(FS);
+
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(page_cons_final)
+
+
+TEST(index_cons1) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*SPIFFS_PAGES_PER_BLOCK(FS);
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify lu entry data page index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  printf("  deleting lu entry pix %04x\n", pix);
+  // reset lu entry to being erased, but keep page data
+  spiffs_obj_id obj_id = SPIFFS_OBJ_ID_DELETED;
+  spiffs_block_ix bix = SPIFFS_BLOCK_FOR_PAGE(FS, pix);
+  int entry = SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(FS, pix);
+  u32_t addr = SPIFFS_BLOCK_TO_PADDR(FS, bix) + entry * sizeof(spiffs_obj_id);
+
+  area_write(addr, (u8_t*)&obj_id, sizeof(spiffs_obj_id));
+
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+  SPIFFS_check(FS);
+
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(index_cons1)
+
+
+TEST(index_cons2) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*SPIFFS_PAGES_PER_BLOCK(FS);
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify lu entry data page index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  printf("  writing lu entry for index page, ix %04x, as data page\n", pix);
+  spiffs_obj_id obj_id = 0x1234;
+  spiffs_block_ix bix = SPIFFS_BLOCK_FOR_PAGE(FS, pix);
+  int entry = SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(FS, pix);
+  u32_t addr = SPIFFS_BLOCK_TO_PADDR(FS, bix) + entry * sizeof(spiffs_obj_id);
+
+  area_write(addr, (u8_t*)&obj_id, sizeof(spiffs_obj_id));
+
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+  SPIFFS_check(FS);
+
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(index_cons2)
+
+
+TEST(index_cons3) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*SPIFFS_PAGES_PER_BLOCK(FS);
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify lu entry data page index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  printf("  setting lu entry pix %04x to another index page\n", pix);
+  // reset lu entry to being erased, but keep page data
+  spiffs_obj_id obj_id = 1234 | SPIFFS_OBJ_ID_IX_FLAG;
+  spiffs_block_ix bix = SPIFFS_BLOCK_FOR_PAGE(FS, pix);
+  int entry = SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(FS, pix);
+  u32_t addr = SPIFFS_BLOCK_TO_PADDR(FS, bix) + entry * sizeof(spiffs_obj_id);
+
+  area_write(addr, (u8_t*)&obj_id, sizeof(spiffs_obj_id));
+
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+  SPIFFS_check(FS);
+
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  return TEST_RES_OK;
+} TEST_END(index_cons3)
+
+TEST(index_cons4) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*SPIFFS_PAGES_PER_BLOCK(FS);
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify lu entry data page index header, flags
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  printf("  cue objix hdr deletion in page %04x\n", pix);
+  // set flags as deleting ix header
+  u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + offsetof(spiffs_page_header, flags);
+  u8_t flags = 0xff & ~(SPIFFS_PH_FLAG_FINAL | SPIFFS_PH_FLAG_USED | SPIFFS_PH_FLAG_INDEX | SPIFFS_PH_FLAG_IXDELE);
+
+  area_write(addr, (u8_t*)&flags, 1);
+
+#if SPIFFS_CACHE
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+  SPIFFS_check(FS);
+
+  return TEST_RES_OK;
+} TEST_END(index_cons4)
+
+
+
+SUITE_END(check_tests)

src/test_dev.c

@@ -0,0 +1,28 @@
+/*
+ * test_dev.c
+ *
+ *  Created on: Jul 14, 2013
+ *      Author: petera
+ */
+
+
+#include "testrunner.h"
+#include "test_spiffs.h"
+#include "spiffs_nucleus.h"
+#include "spiffs.h"
+#include <sys/types.h>
+#include <sys/stat.h>
+#include <fcntl.h>
+#include <dirent.h>
+#include <unistd.h>
+
+
+SUITE(dev_tests)
+void setup() {
+  _setup();
+}
+void teardown() {
+  _teardown();
+}
+
+SUITE_END(dev_tests)

src/test_hydrogen.c

@@ -20,6 +20,10 @@
 
 static void test_on_stop(test *t) {
   printf("  spiffs errno:%i\n", SPIFFS_errno(&__fs));
+#if SPIFFS_TEST_VISUALISATION
+  SPIFFS_vis(FS);
+#endif
+
 }
 
 #define CHECK(r) if (!(r)) return -1;
@@ -56,8 +60,14 @@ int test_create_and_write_file(char *name, int size, int chunk_size) {
   spiffs_file fd;
   printf("    create and write %s", name);
   res = test_create_file(name);
+  if (res < 0) {
+    printf(" failed creation, %i\n",res);
+  }
   CHECK(res >= 0);
   fd = SPIFFS_open(FS, name, 0, SPIFFS_APPEND | SPIFFS_RDWR);
+  if (res < 0) {
+    printf(" failed open, %i\n",res);
+  }
   CHECK(fd >= 0);
   int pfd = open(make_test_fname(name), O_APPEND | O_TRUNC | O_CREAT | O_RDWR);
   int offset = 0;
@@ -85,7 +95,13 @@ int test_create_and_write_file(char *name, int size, int chunk_size) {
 
   spiffs_stat stat;
   res = SPIFFS_fstat(FS, fd, &stat);
+  if (res < 0) {
+    printf(" failed fstat, %i\n",res);
+  }
   CHECK(res >= 0);
+  if (stat.size != size) {
+    printf(" failed size, %i != %i\n", stat.size, size);
+  }
   CHECK(stat.size == size);
 
   SPIFFS_close(FS, fd);
@@ -101,11 +117,11 @@ static u32_t cmiss_tot = 0;
 
 void _setup() {
   fs_reset();
+  fs_set_validate_flashing(1);
   test_init(test_on_stop);
 }
 
 void _teardown() {
-  clear_test_path();
   printf("  free blocks     : %i of %i\n", (FS)->free_blocks, (FS)->block_count);
   printf("  pages allocated : %i\n", (FS)->stats_p_allocated);
   printf("  pages deleted   : %i\n", (FS)->stats_p_deleted);
@@ -121,8 +137,13 @@ void _teardown() {
   printf("  cache utiliz    : %f\n", ((float)chits_tot/(float)(chits_tot + cmiss_tot)));
 #endif
 #endif
-
-
+#if SPIFFS_GC_STATS
+  if ((FS)->stats_gc_runs > 0)
+#endif
+  dump_erase_counts(FS);
+  printf("  fs consistency check:\n");
+  SPIFFS_check(FS);
+  clear_test_path();
 }
 
 typedef enum {
@@ -508,7 +529,7 @@ TEST(list_dir)
 
   SPIFFS_opendir(FS, "/", &d);
   while ((pe = SPIFFS_readdir(&d, pe))) {
-    printf("  %s\n", pe->name);
+    printf("  %s [%04x] size:%i\n", pe->name, pe->obj_id, pe->size);
     // TODO verify
   }
   SPIFFS_closedir(&d);
@@ -693,13 +714,103 @@ TEST(truncate_big_file)
 TEST_END(truncate_big_file)
 
 
+TEST(simultaneous_write) {
+  int res = SPIFFS_creat(FS, "simul1", 0);
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd1 = SPIFFS_open(FS, "simul1", 0, SPIFFS_RDWR);
+  TEST_CHECK(fd1 > 0);
+  spiffs_file fd2 = SPIFFS_open(FS, "simul1", 0, SPIFFS_RDWR);
+  TEST_CHECK(fd2 > 0);
+  spiffs_file fd3 = SPIFFS_open(FS, "simul1", 0, SPIFFS_RDWR);
+  TEST_CHECK(fd3 > 0);
+
+  u8_t data1 = 1;
+  u8_t data2 = 2;
+  u8_t data3 = 3;
+
+  res = SPIFFS_write(FS, fd1, &data1, 1);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd1);
+  res = SPIFFS_write(FS, fd2, &data2, 1);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd2);
+  res = SPIFFS_write(FS, fd3, &data3, 1);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd3);
+
+  spiffs_stat s;
+  res = SPIFFS_stat(FS, "simul1", &s);
+  TEST_CHECK(res >= 0);
+
+  TEST_CHECK(s.size == 1);
+
+  u8_t rdata;
+  spiffs_file fd = SPIFFS_open(FS, "simul1", 0, SPIFFS_RDONLY);
+  TEST_CHECK(fd > 0);
+  res = SPIFFS_read(FS, fd, &rdata, 1);
+  TEST_CHECK(res >= 0);
+
+  TEST_CHECK(rdata == data3);
+
+  return TEST_RES_OK;
+}
+TEST_END(simultaneous_write)
+
+
+TEST(simultaneous_write_append) {
+  int res = SPIFFS_creat(FS, "simul2", 0);
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd1 = SPIFFS_open(FS, "simul2", 0, SPIFFS_RDWR | SPIFFS_APPEND);
+  TEST_CHECK(fd1 > 0);
+  spiffs_file fd2 = SPIFFS_open(FS, "simul2", 0, SPIFFS_RDWR | SPIFFS_APPEND);
+  TEST_CHECK(fd2 > 0);
+  spiffs_file fd3 = SPIFFS_open(FS, "simul2", 0, SPIFFS_RDWR | SPIFFS_APPEND);
+  TEST_CHECK(fd3 > 0);
+
+  u8_t data1 = 1;
+  u8_t data2 = 2;
+  u8_t data3 = 3;
+
+  res = SPIFFS_write(FS, fd1, &data1, 1);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd1);
+  res = SPIFFS_write(FS, fd2, &data2, 1);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd2);
+  res = SPIFFS_write(FS, fd3, &data3, 1);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd3);
+
+  spiffs_stat s;
+  res = SPIFFS_stat(FS, "simul2", &s);
+  TEST_CHECK(res >= 0);
+
+  TEST_CHECK(s.size == 3);
+
+  u8_t rdata[3];
+  spiffs_file fd = SPIFFS_open(FS, "simul2", 0, SPIFFS_RDONLY);
+  TEST_CHECK(fd > 0);
+  res = SPIFFS_read(FS, fd, &rdata, 3);
+  TEST_CHECK(res >= 0);
+
+  TEST_CHECK(rdata[0] == data1);
+  TEST_CHECK(rdata[1] == data2);
+  TEST_CHECK(rdata[2] == data3);
+
+  return TEST_RES_OK;
+}
+TEST_END(simultaneous_write_append)
+
 
 TEST(file_uniqueness)
 {
   int res;
   spiffs_file fd;
   char fname[32];
-  int files = (FS_PURE_DATA_PAGES(FS) / 2) - SPIFFS_PAGES_PER_BLOCK(FS)*3;
+  int files = ((SPIFFS_CFG_PHYS_SZ(FS) * 75) / 100) / 2 / SPIFFS_CFG_LOG_PAGE_SZ(FS);
+      //(FS_PURE_DATA_PAGES(FS) / 2) - SPIFFS_PAGES_PER_BLOCK(FS)*8;
   int i;
   printf("  creating %i files\n", files);
   for (i = 0; i < files; i++) {
@@ -849,6 +960,80 @@ TEST(read_chunk_huge)
 TEST_END(read_chunk_huge)
 
 
+TEST(bad_index_1) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify object index, find object index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  // set object index entry 2 to a bad page, free
+  u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + sizeof(spiffs_page_object_ix_header) + 2 * sizeof(spiffs_page_ix);
+  spiffs_page_ix bad_pix_ref = (spiffs_page_ix)-1;
+  area_write(addr, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+
+#if SPIFFS_CACHE
+  // delete all cache
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+
+  res = read_and_verify("file");
+  TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_INDEX_REF_FREE);
+
+  return TEST_RES_OK;
+} TEST_END(bad_index_1)
+
+
+TEST(bad_index_2) {
+  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
+  int res = test_create_and_write_file("file", size, size);
+  TEST_CHECK(res >= 0);
+  res = read_and_verify("file");
+  TEST_CHECK(res >= 0);
+
+  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
+  TEST_CHECK(fd > 0);
+  spiffs_stat s;
+  res = SPIFFS_fstat(FS, fd, &s);
+  TEST_CHECK(res >= 0);
+  SPIFFS_close(FS, fd);
+
+  // modify object index, find object index header
+  spiffs_page_ix pix;
+  res = spiffs_obj_lu_find_id_and_span(FS, s.obj_id | SPIFFS_OBJ_ID_IX_FLAG, 0, 0, &pix);
+  TEST_CHECK(res >= 0);
+
+  // set object index entry 2 to a bad page, lu
+  u32_t addr = SPIFFS_PAGE_TO_PADDR(FS, pix) + sizeof(spiffs_page_object_ix_header) + 2 * sizeof(spiffs_page_ix);
+  spiffs_page_ix bad_pix_ref = SPIFFS_OBJ_LOOKUP_PAGES(FS)-1;
+  area_write(addr, (u8_t*)&bad_pix_ref, sizeof(spiffs_page_ix));
+
+#if SPIFFS_CACHE
+  // delete all cache
+  spiffs_cache *cache = spiffs_get_cache(FS);
+  cache->cpage_use_map = 0;
+#endif
+
+  res = read_and_verify("file");
+  TEST_CHECK(SPIFFS_errno(FS) == SPIFFS_ERR_INDEX_REF_LU);
+
+  return TEST_RES_OK;
+} TEST_END(bad_index_2)
+
+
 TEST(lseek_simple_modification) {
   int res;
   spiffs_file fd;
@@ -1011,7 +1196,7 @@ TEST(lseek_read) {
     }
     offs += sizeof(buf);
 
-    res = SPIFFS_lseek(FS, fd, -(sizeof(buf)+11), SPIFFS_SEEK_CUR);
+    res = SPIFFS_lseek(FS, fd, -((u32_t)sizeof(buf)+11), SPIFFS_SEEK_CUR);
     TEST_CHECK(res >= 0);
     offs -= (sizeof(buf)+11);
     res = SPIFFS_read(FS, fd, buf, sizeof(buf));
@@ -1345,7 +1530,7 @@ TEST(long_run)
       },
   };
 
-  int macro_runs = 500;
+  int macro_runs = 1000;
   printf("  ");
   while (macro_runs--) {
     //printf("  ---- run %i ----\n", macro_runs);
@@ -1357,54 +1542,13 @@ TEST(long_run)
     TEST_CHECK(res >= 0);
   }
   printf("\n");
-  return TEST_RES_OK;
-}
-TEST_END(long_run)
-
-SUITE_END(hydrogen_tests)
-
-SUITE(dev_tests)
-void setup() {
-  _setup();
-}
-void teardown() {
-  _teardown();
-}
-TEST(check1) {
-  int size = SPIFFS_DATA_PAGE_SIZE(FS)*3;
-  int res = test_create_and_write_file("file", size, size);
-  TEST_CHECK(res >= 0);
-  res = read_and_verify("file");
-  TEST_CHECK(res >= 0);
-
-  spiffs_file fd = SPIFFS_open(FS, "file", 0, 0);
-  TEST_CHECK(fd > 0);
-  spiffs_stat s;
-  res = SPIFFS_fstat(FS, fd, &s);
-  TEST_CHECK(res >= 0);
-  SPIFFS_close(FS, fd);
 
-  // modify lu entry data page index 1
-  spiffs_page_ix pix;
-  res = spiffs_obj_lu_find_id_and_index(FS, s.obj_id & ~SPIFFS_OBJ_ID_IX_FLAG, 1, &pix);
+  int res = SPIFFS_check(FS);
   TEST_CHECK(res >= 0);
 
-  // reset lu entry to being erased, but keep page data
-  spiffs_obj_id obj_id = SPIFFS_OBJ_ID_ERASED;
-  spiffs_block_ix bix = SPIFFS_BLOCK_FOR_PAGE(FS, pix);
-  int entry = SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(FS, pix);
-  u32_t addr = SPIFFS_BLOCK_TO_PADDR(FS, bix) + entry*sizeof(spiffs_obj_id);
-
-  area_write(addr, (u8_t*)&obj_id, sizeof(spiffs_obj_id));
-
-  spiffs_cache *cache = get_cache(FS);
-  cache->cpage_use_map = 0;
-
-  SPIFFS_check(FS);
-
-
   return TEST_RES_OK;
-} TEST_END(check1)
+}
+TEST_END(long_run)
 
-SUITE_END(dev_tests)
+SUITE_END(hydrogen_tests)
 

src/test_spiffs.c

@@ -24,22 +24,26 @@
 #include <dirent.h>
 #include <unistd.h>
 
+
+
 #define SECTOR_SIZE 65536  //(0x10000)
 #define PAGE_SIZE   256    //256
-#define LOG_BLOCK   65536
-#define LOG_PAGE    PAGE_SIZE
+#define LOG_BLOCK   1*65536
+#define LOG_PAGE    1*PAGE_SIZE
 
-static unsigned char area[1024*1024*1];
+static unsigned char area[1*1024*1024];
 
 static int erases[sizeof(area)/SECTOR_SIZE];
 static char _path[256];
 
 spiffs __fs;
 static u8_t _work[LOG_PAGE*2];
-static u8_t _fds[256+128];
-static u8_t _cache[256*5];
+static u8_t _fds[LOG_PAGE+LOG_PAGE/2];
+static u8_t _cache[LOG_PAGE*5];
+
+static int check_valid_flash = 1;
 
-#define TEST_PATH "/home/petera/proj/spiffs_test_/test_data/"
+#define TEST_PATH "../test_data/"
 
 char *make_test_fname(const char *name) {
   sprintf(_path, "%s%s", TEST_PATH, name);
@@ -72,7 +76,7 @@ static s32_t _write(u32_t addr, u32_t size, u8_t *src) {
   //printf("wr %08x %i\n", addr, size);
   for (i = 0; i < size; i++) {
     if (((addr + i) & (PAGE_SIZE-1)) != offsetof(spiffs_page_header, flags)) {
-      if (((area[addr + i] ^ src[i]) & src[i])) {
+      if (check_valid_flash && ((area[addr + i] ^ src[i]) & src[i])) {
         printf("trying to write %02x to %02x at addr %08x\n", src[i], area[addr + i], addr+i);
         spiffs_page_ix pix = (addr + i) / PAGE_SIZE;
         dump_page(&__fs, pix);
@@ -149,14 +153,18 @@ void dump_page(spiffs *fs, spiffs_page_ix p) {
     // obj lu page
     printf("OBJ_LU");
   } else {
+    u32_t obj_id_addr = SPIFFS_BLOCK_TO_PADDR(fs, SPIFFS_BLOCK_FOR_PAGE(fs , p)) +
+        SPIFFS_OBJ_LOOKUP_ENTRY_FOR_PAGE(fs, p) * sizeof(spiffs_obj_id);
+    spiffs_obj_id obj_id = *((spiffs_obj_id *)&area[obj_id_addr]);
     // data page
     spiffs_page_header *ph = (spiffs_page_header *)&area[addr];
-    printf("DATA %04x:%04x  ", ph->obj_id & ~SPIFFS_OBJ_ID_IX_FLAG, ph->span_ix);
-    printf("%s", ((ph->flags & SPIFFS_PH_FLAG_FINAL) == 0) ? "F" : "f");
-    printf("%s", ((ph->flags & SPIFFS_PH_FLAG_DELET) == 0) ? "D" : "d");
-    printf("%s", ((ph->flags & SPIFFS_PH_FLAG_INDEX) == 0) ? "I" : "i");
-    printf("%s  ", ((ph->flags & SPIFFS_PH_FLAG_CORRU) == 0) ? "C" : "c");
-    if (ph->obj_id & SPIFFS_OBJ_ID_IX_FLAG) {
+    printf("DATA %04x:%04x  ", obj_id, ph->span_ix);
+    printf("%s", ((ph->flags & SPIFFS_PH_FLAG_FINAL) == 0) ? "FIN " : "fin ");
+    printf("%s", ((ph->flags & SPIFFS_PH_FLAG_DELET) == 0) ? "DEL " : "del ");
+    printf("%s", ((ph->flags & SPIFFS_PH_FLAG_INDEX) == 0) ? "IDX " : "idx ");
+    printf("%s", ((ph->flags & SPIFFS_PH_FLAG_USED) == 0) ? "USD " : "usd ");
+    printf("%s  ", ((ph->flags & SPIFFS_PH_FLAG_IXDELE) == 0) ? "IDL " : "idl ");
+    if (obj_id & SPIFFS_OBJ_ID_IX_FLAG) {
       // object index
       printf("OBJ_IX");
       if (ph->span_ix == 0) {
@@ -251,6 +259,54 @@ void area_write(u32_t addr, u8_t *buf, u32_t size) {
   }
 }
 
+void area_read(u32_t addr, u8_t *buf, u32_t size) {
+  int i;
+  for (i = 0; i < size; i++) {
+    *buf++ = area[addr + i];
+  }
+}
+
+void dump_erase_counts(spiffs *fs) {
+  spiffs_block_ix bix;
+  printf("  BLOCK     |\n");
+  printf("   AGE COUNT|\n");
+  for (bix = 0; bix < fs->block_count; bix++) {
+    printf("----%3i ----|", bix);
+  }
+  printf("\n");
+  for (bix = 0; bix < fs->block_count; bix++) {
+    spiffs_obj_id erase_mark;
+    _spiffs_rd(fs, 0, 0, SPIFFS_ERASE_COUNT_PADDR(fs, bix), sizeof(spiffs_obj_id), (u8_t *)&erase_mark);
+    if (erases[bix] == 0) {
+      printf("            |", bix);
+    } else {
+      printf("%7i %4i|", (fs->max_erase_count - erase_mark), erases[bix]);
+    }
+  }
+  printf("\n");
+}
+
+static u32_t old_perc = 999;
+static void spiffs_check_cb_f(spiffs_check_type type, spiffs_check_report report,
+    u32_t arg1, u32_t arg2) {
+/*  if (report == SPIFFS_CHECK_PROGRESS && old_perc != arg1) {
+    old_perc = arg1;
+    printf("CHECK REPORT: ");
+    switch(type) {
+    case SPIFFS_CHECK_LOOKUP:
+      printf("LU "); break;
+    case SPIFFS_CHECK_INDEX:
+      printf("IX "); break;
+    case SPIFFS_CHECK_PAGE:
+      printf("PA "); break;
+    }
+    printf("%i%%\n", arg1 * 100 / 256);
+  }*/
+  if (report != SPIFFS_CHECK_PROGRESS) {
+    printf("   check cb f: %i %i %08x (%i) %08x\n", type, report, arg1, arg1, arg2);
+  }
+}
+
 void fs_reset() {
   memset(area, 0xff, sizeof(area));
   spiffs_config c;
@@ -264,7 +320,11 @@ void fs_reset() {
   c.phys_size = sizeof(area);
   memset(erases,0,sizeof(erases));
   memset(_cache,0,sizeof(_cache));
-  SPIFFS_mount(&__fs, &c, _work, _fds, sizeof(_fds), _cache, sizeof(_cache));
+  SPIFFS_mount(&__fs, &c, _work, _fds, sizeof(_fds), _cache, sizeof(_cache), spiffs_check_cb_f);
+}
+
+void fs_set_validate_flashing(int i) {
+  check_valid_flash = i;
 }
 
 void real_assert(int c, const char *n, const char *file, int l) {