Switched to separate-tag encoding of forward-looking CRCs

Previously forward-looking CRCs was just two new CRC types, one for
commits with forward-looking CRCs, one without. These both contained the
CRC needed to complete the current commit (note that the commit CRC
must come last!).

         [--   32   --|--   32   --|--   32   --|--   32   --]
with:    [  crc3 tag  | nprog size |  nprog crc | commit crc ]
without: [  crc2 tag  | commit crc ]

This meant there had to be several checks for the two possible structure
sizes, messying up the implementation.

         [--   32   --|--   32   --|--   32   --|--   32   --|--   32   --]
with:    [nprogcrc tag| nprog size |  nprog crc | commit tag | commit crc ]
without: [ commit tag | commit crc ]

But we already have a mechanism for storing optional metadata! The
different metadata tags! So why not use a separate tage for the
forward-looking CRC, separate from the commit CRC?

I wasn't sure this would actually help that much, there are still
necessary conditions for wether or not a forward-looking CRC is there,
but in the end it simplified the code quite nicely, and resulted in a ~200 byte
code-cost saving.

bd/lfs_filebd.c

@@ -80,11 +80,6 @@ int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
     LFS_ASSERT(size % cfg->read_size == 0);
     LFS_ASSERT(block < cfg->block_count);
 
-    // zero for reproducability (in case file is truncated)
-    if (bd->cfg->erase_value != -1) {
-        memset(buffer, bd->cfg->erase_value, size);
-    }
-
     // read
     off_t res1 = lseek(bd->fd,
             (off_t)block*cfg->block_size + (off_t)off, SEEK_SET);
@@ -101,6 +96,11 @@ int lfs_filebd_read(const struct lfs_config *cfg, lfs_block_t block,
         return err;
     }
 
+    // file truncated? zero for reproducability
+    if ((lfs_size_t)res2 < size) {
+        memset((uint8_t*)buffer + res2, 0, size-res2);
+    }
+
     LFS_FILEBD_TRACE("lfs_filebd_read -> %d", 0);
     return 0;
 }

bd/lfs_rambd.c

@@ -32,11 +32,8 @@ int lfs_rambd_createcfg(const struct lfs_config *cfg,
         }
     }
 
-    // zero for reproducability?
-    if (bd->cfg->erase_value != -1) {
-        memset(bd->buffer, bd->cfg->erase_value,
-                cfg->block_size * cfg->block_count);
-    }
+    // zero for reproducability (this matches filebd)
+    memset(bd->buffer, 0, cfg->block_size * cfg->block_count);
 
     LFS_RAMBD_TRACE("lfs_rambd_createcfg -> %d", 0);
     return 0;

lfs.h

@@ -113,6 +113,8 @@ enum lfs_type {
     LFS_TYPE_SOFTTAIL       = 0x600,
     LFS_TYPE_HARDTAIL       = 0x601,
     LFS_TYPE_MOVESTATE      = 0x7ff,
+    LFS_TYPE_COMMITCRC      = 0x502,
+    LFS_TYPE_NPROGCRC       = 0x5ff,
 
     // internal chip sources
     LFS_FROM_NOOP           = 0x000,
@@ -123,30 +125,26 @@ enum lfs_type {
 // File open flags
 enum lfs_open_flags {
     // open flags
-    LFS_O_RDONLY    = 1,        // Open a file as read only
+    LFS_O_RDONLY = 1,         // Open a file as read only
 #ifndef LFS_READONLY
-    LFS_O_WRONLY    = 2,        // Open a file as write only
-    LFS_O_RDWR      = 3,        // Open a file as read and write
-#endif
-
-#ifndef LFS_READONLY
-    LFS_O_CREAT     = 0x0100,   // Create a file if it does not exist
-    LFS_O_EXCL      = 0x0200,   // Fail if a file already exists
-    LFS_O_TRUNC     = 0x0400,   // Truncate the existing file to zero size
-    LFS_O_APPEND    = 0x0800,   // Move to end of file on every write
-    LFS_O_SNAPSHOT  = 0x1000,   // Open a temporary snapshot, ignore changes
+    LFS_O_WRONLY = 2,         // Open a file as write only
+    LFS_O_RDWR   = 3,         // Open a file as read and write
+    LFS_O_CREAT  = 0x0100,    // Create a file if it does not exist
+    LFS_O_EXCL   = 0x0200,    // Fail if a file already exists
+    LFS_O_TRUNC  = 0x0400,    // Truncate the existing file to zero size
+    LFS_O_APPEND = 0x0800,    // Move to end of file on every write
 #endif
 
     // internally used flags
 #ifndef LFS_READONLY
-    LFS_F_DIRTY     = 0x010000, // File does not match storage
+    LFS_F_DIRTY   = 0x010000, // File does not match storage
+    LFS_F_WRITING = 0x020000, // File has been written since last flush
 #endif
-    LFS_F_READING   = 0x020000, // File has been read since last flush
+    LFS_F_READING = 0x040000, // File has been read since last flush
 #ifndef LFS_READONLY
-    LFS_F_WRITING   = 0x040000, // File has been written since last flush
-    LFS_F_ZOMBIE    = 0x080000, // An error occurred during write
+    LFS_F_ERRED   = 0x080000, // An error occurred during write
 #endif
-    LFS_F_INLINE    = 0x100000, // Currently inlined in directory entry
+    LFS_F_INLINE  = 0x100000, // Currently inlined in directory entry
 };
 
 // File seek flags
@@ -298,15 +296,16 @@ struct lfs_file_config {
     void *buffer;
 
     // Optional list of custom attributes related to the file. If the file
-    // is opened for reading, these attributes will be read from disk during
-    // open. If the file is open for writing, these attribute will be atomically
-    // written to disk when the file is written to disk. Note that these
-    // attributes are not written unless the file is modified.
+    // is opened with read access, these attributes will be read from disk
+    // during the open call. If the file is opened with write access, the
+    // attributes will be written to disk every file sync or close. This
+    // write occurs atomically with update to the file's contents.
     //
     // Custom attributes are uniquely identified by an 8-bit type and limited
-    // to LFS_ATTR_MAX bytes. If the stored attribute is larger than the
-    // provided buffer, it will be silently truncated. If no attribute is
-    // found, and the file is open for writing, it will be created implicitly.
+    // to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller
+    // than the buffer, it will be padded with zeros. If the stored attribute
+    // is larger, then it will be silently truncated. If the attribute is not
+    // found, it will be created implicitly.
     struct lfs_attr *attrs;
 
     // Number of custom attributes in the list
@@ -474,9 +473,10 @@ int lfs_stat(lfs_t *lfs, const char *path, struct lfs_info *info);
 // Get a custom attribute
 //
 // Custom attributes are uniquely identified by an 8-bit type and limited
-// to LFS_ATTR_MAX bytes. If the stored attribute is larger than the
-// provided buffer, it will be silently truncated. If no attribute is found,
-// the error LFS_ERR_NOATTR is returned and the buffer is filled with zeros.
+// to LFS_ATTR_MAX bytes. When read, if the stored attribute is smaller than
+// the buffer, it will be padded with zeros. If the stored attribute is larger,
+// then it will be silently truncated. If no attribute is found, the error
+// LFS_ERR_NOATTR is returned and the buffer is filled with zeros.
 //
 // Returns the size of the attribute, or a negative error code on failure.
 // Note, the returned size is the size of the attribute on disk, irrespective

scripts/readmdir.py

@@ -24,6 +24,7 @@ TAG_TYPES = {
     'gstate':       (0x700, 0x700),
     'movestate':    (0x7ff, 0x7ff),
     'crc':          (0x700, 0x500),
+    'nprogcrc':     (0x7ff, 0x5ff),
 }
 
 class Tag:
@@ -99,7 +100,16 @@ class Tag:
         return struct.unpack('b', struct.pack('B', self.chunk))[0]
 
     def is_(self, type):
-        return (self.type & TAG_TYPES[type][0]) == TAG_TYPES[type][1]
+        try:
+            if ' ' in type:
+                type1, type3 = type.split()
+                return (self.is_(type1) and
+                    (self.type & ~TAG_TYPES[type1][0]) == int(type3, 0))
+
+            return self.type == int(type, 0)
+
+        except (ValueError, KeyError):
+            return (self.type & TAG_TYPES[type][0]) == TAG_TYPES[type][1]
 
     def mkmask(self):
         return Tag(
@@ -109,14 +119,20 @@ class Tag:
 
     def chid(self, nid):
         ntag = Tag(self.type, nid, self.size)
-        if hasattr(self, 'off'):  ntag.off  = self.off
-        if hasattr(self, 'data'): ntag.data = self.data
-        if hasattr(self, 'crc'):  ntag.crc  = self.crc
+        if hasattr(self, 'off'):    ntag.off    = self.off
+        if hasattr(self, 'data'):   ntag.data   = self.data
+        if hasattr(self, 'crc'):    ntag.crc    = self.crc
+        if hasattr(self, 'erased'): ntag.erased = self.erased
         return ntag
 
     def typerepr(self):
-        if self.is_('crc') and getattr(self, 'crc', 0xffffffff) != 0xffffffff:
-            return 'crc (bad)'
+        if (self.is_('crc') and not self.is_('nprogcrc') and
+                getattr(self, 'crc', 0xffffffff) != 0xffffffff):
+            crc_status = ' (bad)'
+        elif self.is_('nprogcrc') and getattr(self, 'erased', False):
+            crc_status = ' (era)'
+        else:
+            crc_status = ''
 
         reverse_types = {v: k for k, v in TAG_TYPES.items()}
         for prefix in range(12):
@@ -124,12 +140,12 @@ class Tag:
             if (mask, self.type & mask) in reverse_types:
                 type = reverse_types[mask, self.type & mask]
                 if prefix > 0:
-                    return '%s %#0*x' % (
-                        type, prefix//4, self.type & ((1 << prefix)-1))
+                    return '%s %#x%s' % (
+                        type, self.type & ((1 << prefix)-1), crc_status)
                 else:
-                    return type
+                    return '%s%s' % (type, crc_status)
         else:
-            return '%02x' % self.type
+            return '%02x%s' % (self.type, crc_status)
 
     def idrepr(self):
         return repr(self.id) if self.id != 0x3ff else '.'
@@ -172,6 +188,8 @@ class MetadataPair:
 
         self.rev, = struct.unpack('<I', block[0:4])
         crc = binascii.crc32(block[0:4])
+        etag = None
+        estate = None
 
         # parse tags
         corrupt = False
@@ -182,11 +200,11 @@ class MetadataPair:
         while len(block) - off >= 4:
             ntag, = struct.unpack('>I', block[off:off+4])
 
-            tag = Tag(int(tag) ^ ntag)
+            tag = Tag((int(tag) ^ ntag) & 0x7fffffff)
             tag.off = off + 4
             tag.data = block[off+4:off+tag.dsize]
-            if tag.is_('crc'):
-                crc = binascii.crc32(block[off:off+4+4], crc)
+            if tag.is_('crc') and not tag.is_('nprogcrc'):
+                crc = binascii.crc32(block[off:off+2*4], crc)
             else:
                 crc = binascii.crc32(block[off:off+tag.dsize], crc)
             tag.crc = crc
@@ -194,16 +212,29 @@ class MetadataPair:
 
             self.all_.append(tag)
 
-            if tag.is_('crc'):
+            if tag.is_('nprogcrc') and len(tag.data) == 8:
+                etag = tag
+                estate = struct.unpack('<II', tag.data)
+            elif tag.is_('crc'):
                 # is valid commit?
                 if crc != 0xffffffff:
                     corrupt = True
                 if not corrupt:
                     self.log = self.all_.copy()
+                    # end of commit?
+                    if estate:
+                        esize, ecrc = estate
+                        dcrc = 0xffffffff ^ binascii.crc32(block[off:off+esize])
+                        if ecrc == dcrc:
+                            etag.erased = True
+                            corrupt = True
+                    elif not (tag.is_('crc 0x0') or tag.is_('crc 0x1')):
+                        corrupt = True
 
                 # reset tag parsing
                 crc = 0
-                tag = Tag(int(tag) ^ ((tag.type & 1) << 31))
+                etag = None
+                estate = None
 
         # find active ids
         self.ids = list(it.takewhile(
@@ -280,7 +311,7 @@ class MetadataPair:
         f.write('\n')
 
         for tag in tags:
-            f.write("%08x: %08x  %-13s %4s %4s" % (
+            f.write("%08x: %08x  %-14s %3s %4s" % (
                 tag.off, tag,
                 tag.typerepr(), tag.idrepr(), tag.sizerepr()))
             if truncate:

tests/test_attrs.toml

@@ -16,39 +16,41 @@ code = '''
     lfs_getattr(&lfs, "hello", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "hello", 'B', buffer+4,  6) => 6;
     lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",   4) == 0);
-    assert(memcmp(buffer+4,  "bbbbbb", 6) == 0);
-    assert(memcmp(buffer+10, "ccccc",  5) == 0);
+    memcmp(buffer,    "aaaa",   4) => 0;
+    memcmp(buffer+4,  "bbbbbb", 6) => 0;
+    memcmp(buffer+10, "ccccc",  5) => 0;
 
     lfs_setattr(&lfs, "hello", 'B', "", 0) => 0;
     lfs_getattr(&lfs, "hello", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "hello", 'B', buffer+4,  6) => 0;
     lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",         4) == 0);
-    assert(memcmp(buffer+10, "ccccc",        5) == 0);
+    memcmp(buffer,    "aaaa",         4) => 0;
+    memcmp(buffer+4,  "\0\0\0\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",        5) => 0;
 
     lfs_removeattr(&lfs, "hello", 'B') => 0;
     lfs_getattr(&lfs, "hello", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "hello", 'B', buffer+4,  6) => LFS_ERR_NOATTR;
     lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",         4) == 0);
-    assert(memcmp(buffer+10, "ccccc",        5) == 0);
+    memcmp(buffer,    "aaaa",         4) => 0;
+    memcmp(buffer+4,  "\0\0\0\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",        5) => 0;
 
     lfs_setattr(&lfs, "hello", 'B', "dddddd", 6) => 0;
     lfs_getattr(&lfs, "hello", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "hello", 'B', buffer+4,  6) => 6;
     lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",   4) == 0);
-    assert(memcmp(buffer+4,  "dddddd", 6) == 0);
-    assert(memcmp(buffer+10, "ccccc",  5) == 0);
+    memcmp(buffer,    "aaaa",   4) => 0;
+    memcmp(buffer+4,  "dddddd", 6) => 0;
+    memcmp(buffer+10, "ccccc",  5) => 0;
 
     lfs_setattr(&lfs, "hello", 'B', "eee", 3) => 0;
     lfs_getattr(&lfs, "hello", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "hello", 'B', buffer+4,  6) => 3;
     lfs_getattr(&lfs, "hello", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",  4) == 0);
-    assert(memcmp(buffer+4,  "eee",   3) == 0);
-    assert(memcmp(buffer+10, "ccccc", 5) == 0);
+    memcmp(buffer,    "aaaa",      4) => 0;
+    memcmp(buffer+4,  "eee\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",     5) => 0;
 
     lfs_setattr(&lfs, "hello", 'A', buffer, LFS_ATTR_MAX+1) => LFS_ERR_NOSPC;
     lfs_setattr(&lfs, "hello", 'B', "fffffffff", 9) => 0;
@@ -63,13 +65,13 @@ code = '''
     lfs_getattr(&lfs, "hello", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "hello", 'B', buffer+4,  9) => 9;
     lfs_getattr(&lfs, "hello", 'C', buffer+13, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",      4) == 0);
-    assert(memcmp(buffer+4,  "fffffffff", 9) == 0);
-    assert(memcmp(buffer+13, "ccccc",     5) == 0);
+    memcmp(buffer,    "aaaa",      4) => 0;
+    memcmp(buffer+4,  "fffffffff", 9) => 0;
+    memcmp(buffer+13, "ccccc",     5) => 0;
 
     lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
     lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
-    assert(memcmp(buffer, "hello", strlen("hello")) == 0);
+    memcmp(buffer, "hello", strlen("hello")) => 0;
     lfs_file_close(&lfs, &file);
     lfs_unmount(&lfs) => 0;
 '''
@@ -92,39 +94,41 @@ code = '''
     lfs_getattr(&lfs, "/", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "/", 'B', buffer+4,  6) => 6;
     lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",   4) == 0);
-    assert(memcmp(buffer+4,  "bbbbbb", 6) == 0);
-    assert(memcmp(buffer+10, "ccccc",  5) == 0);
+    memcmp(buffer,    "aaaa",   4) => 0;
+    memcmp(buffer+4,  "bbbbbb", 6) => 0;
+    memcmp(buffer+10, "ccccc",  5) => 0;
 
     lfs_setattr(&lfs, "/", 'B', "", 0) => 0;
     lfs_getattr(&lfs, "/", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "/", 'B', buffer+4,  6) => 0;
     lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",  4) == 0);
-    assert(memcmp(buffer+10, "ccccc", 5) == 0);
+    memcmp(buffer,    "aaaa",         4) => 0;
+    memcmp(buffer+4,  "\0\0\0\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",        5) => 0;
 
     lfs_removeattr(&lfs, "/", 'B') => 0;
     lfs_getattr(&lfs, "/", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "/", 'B', buffer+4,  6) => LFS_ERR_NOATTR;
     lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",  4) == 0);
-    assert(memcmp(buffer+10, "ccccc", 5) == 0);
+    memcmp(buffer,    "aaaa",         4) => 0;
+    memcmp(buffer+4,  "\0\0\0\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",        5) => 0;
 
     lfs_setattr(&lfs, "/", 'B', "dddddd", 6) => 0;
     lfs_getattr(&lfs, "/", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "/", 'B', buffer+4,  6) => 6;
     lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",   4) == 0);
-    assert(memcmp(buffer+4,  "dddddd", 6) == 0);
-    assert(memcmp(buffer+10, "ccccc",  5) == 0);
+    memcmp(buffer,    "aaaa",   4) => 0;
+    memcmp(buffer+4,  "dddddd", 6) => 0;
+    memcmp(buffer+10, "ccccc",  5) => 0;
 
     lfs_setattr(&lfs, "/", 'B', "eee", 3) => 0;
     lfs_getattr(&lfs, "/", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "/", 'B', buffer+4,  6) => 3;
     lfs_getattr(&lfs, "/", 'C', buffer+10, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",  4) == 0);
-    assert(memcmp(buffer+4,  "eee",   3) == 0);
-    assert(memcmp(buffer+10, "ccccc", 5) == 0);
+    memcmp(buffer,    "aaaa",      4) => 0;
+    memcmp(buffer+4,  "eee\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",     5) => 0;
 
     lfs_setattr(&lfs, "/", 'A', buffer, LFS_ATTR_MAX+1) => LFS_ERR_NOSPC;
     lfs_setattr(&lfs, "/", 'B', "fffffffff", 9) => 0;
@@ -138,13 +142,13 @@ code = '''
     lfs_getattr(&lfs, "/", 'A', buffer,    4) => 4;
     lfs_getattr(&lfs, "/", 'B', buffer+4,  9) => 9;
     lfs_getattr(&lfs, "/", 'C', buffer+13, 5) => 5;
-    assert(memcmp(buffer,    "aaaa",      4) == 0);
-    assert(memcmp(buffer+4,  "fffffffff", 9) == 0);
-    assert(memcmp(buffer+13, "ccccc",     5) == 0);
+    memcmp(buffer,    "aaaa",      4) => 0;
+    memcmp(buffer+4,  "fffffffff", 9) => 0;
+    memcmp(buffer+13, "ccccc",     5) => 0;
 
     lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
     lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
-    assert(memcmp(buffer, "hello", strlen("hello")) == 0);
+    memcmp(buffer, "hello", strlen("hello")) => 0;
     lfs_file_close(&lfs, &file);
     lfs_unmount(&lfs) => 0;
 '''
@@ -172,55 +176,52 @@ code = '''
     memcpy(buffer,    "aaaa",   4);
     memcpy(buffer+4,  "bbbbbb", 6);
     memcpy(buffer+10, "ccccc",  5);
-    lfs_file_write(&lfs, &file, "hi", 2) => 2;
     lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
     lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer,    "aaaa",   4) == 0);
-    assert(memcmp(buffer+4,  "bbbbbb", 6) == 0);
-    assert(memcmp(buffer+10, "ccccc",  5) == 0);
+    memcmp(buffer,    "aaaa",   4) => 0;
+    memcmp(buffer+4,  "bbbbbb", 6) => 0;
+    memcmp(buffer+10, "ccccc",  5) => 0;
 
     attrs1[1].size = 0;
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
-    lfs_file_write(&lfs, &file, "hi", 2) => 2;
     lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
     attrs1[1].size = 6;
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
     lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer,    "aaaa",  4) == 0);
-    assert(memcmp(buffer+10, "ccccc", 5) == 0);
+    memcmp(buffer,    "aaaa",         4) => 0;
+    memcmp(buffer+4,  "\0\0\0\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",        5) => 0;
 
     attrs1[1].size = 6;
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
     memcpy(buffer+4,  "dddddd", 6);
-    lfs_file_write(&lfs, &file, "hi", 2) => 2;
     lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
     attrs1[1].size = 6;
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
     lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer,    "aaaa",   4) == 0);
-    assert(memcmp(buffer+4,  "dddddd", 6) == 0);
-    assert(memcmp(buffer+10, "ccccc",  5) == 0);
+    memcmp(buffer,    "aaaa",   4) => 0;
+    memcmp(buffer+4,  "dddddd", 6) => 0;
+    memcmp(buffer+10, "ccccc",  5) => 0;
 
     attrs1[1].size = 3;
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1) => 0;
     memcpy(buffer+4,  "eee", 3);
-    lfs_file_write(&lfs, &file, "hi", 2) => 2;
     lfs_file_close(&lfs, &file) => 0;
     memset(buffer, 0, 15);
     attrs1[1].size = 6;
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
     lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer,    "aaaa",  4) == 0);
-    assert(memcmp(buffer+4,  "eee",   3) == 0);
-    assert(memcmp(buffer+10, "ccccc", 5) == 0);
+    memcmp(buffer,    "aaaa",      4) => 0;
+    memcmp(buffer+4,  "eee\0\0\0", 6) => 0;
+    memcmp(buffer+10, "ccccc",     5) => 0;
 
     attrs1[0].size = LFS_ATTR_MAX+1;
-    lfs_file_opencfg(&lfs, &file, "hello/hello2",
-            LFS_O_WRONLY | LFS_O_CREAT, &cfg1) => LFS_ERR_NOSPC;
+    lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_WRONLY, &cfg1)
+        => LFS_ERR_NOSPC;
 
     struct lfs_attr attrs2[] = {
         {'A', buffer,    4},
@@ -230,7 +231,6 @@ code = '''
     struct lfs_file_config cfg2 = {.attrs=attrs2, .attr_count=3};
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDWR, &cfg2) => 0;
     memcpy(buffer+4,  "fffffffff", 9);
-    lfs_file_write(&lfs, &file, "hi", 2) => 2;
     lfs_file_close(&lfs, &file) => 0;
     attrs1[0].size = 4;
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg1) => 0;
@@ -249,13 +249,13 @@ code = '''
 
     lfs_file_opencfg(&lfs, &file, "hello/hello", LFS_O_RDONLY, &cfg3) => 0;
     lfs_file_close(&lfs, &file) => 0;
-    assert(memcmp(buffer,    "aaaa",      4) == 0);
-    assert(memcmp(buffer+4,  "fffffffff", 9) == 0);
-    assert(memcmp(buffer+13, "ccccc",     5) == 0);
+    memcmp(buffer,    "aaaa",      4) => 0;
+    memcmp(buffer+4,  "fffffffff", 9) => 0;
+    memcmp(buffer+13, "ccccc",     5) => 0;
 
     lfs_file_open(&lfs, &file, "hello/hello", LFS_O_RDONLY) => 0;
     lfs_file_read(&lfs, &file, buffer, sizeof(buffer)) => strlen("hello");
-    assert(memcmp(buffer, "hillo", strlen("hello")) == 0);
+    memcmp(buffer, "hello", strlen("hello")) => 0;
     lfs_file_close(&lfs, &file);
     lfs_unmount(&lfs) => 0;
 '''
@@ -287,16 +287,17 @@ code = '''
     lfs_getattr(&lfs, "hello/hello", 'B', buffer,    9) => 9;
     lfs_getattr(&lfs, "hello/hello", 'C', buffer+9,  9) => 5;
     lfs_getattr(&lfs, "hello/hello", 'D', buffer+18, 9) => LFS_ERR_NOATTR;
-    assert(memcmp(buffer,    "fffffffff", 9) == 0);
-    assert(memcmp(buffer+9,  "ccccc",     5) == 0);
+    memcmp(buffer,    "fffffffff",          9) => 0;
+    memcmp(buffer+9,  "ccccc\0\0\0\0",      9) => 0;
+    memcmp(buffer+18, "\0\0\0\0\0\0\0\0\0", 9) => 0;
 
-    lfs_file_write(&lfs, &file, "hi", 2) => 2;
     lfs_file_sync(&lfs, &file) => 0;
     lfs_getattr(&lfs, "hello/hello", 'B', buffer,    9) => 4;
     lfs_getattr(&lfs, "hello/hello", 'C', buffer+9,  9) => 0;
     lfs_getattr(&lfs, "hello/hello", 'D', buffer+18, 9) => 4;
-    assert(memcmp(buffer,    "gggg", 4) == 0);
-    assert(memcmp(buffer+18, "hhhh", 4) == 0);
+    memcmp(buffer,    "gggg\0\0\0\0\0",     9) => 0;
+    memcmp(buffer+9,  "\0\0\0\0\0\0\0\0\0", 9) => 0;
+    memcmp(buffer+18, "hhhh\0\0\0\0\0",     9) => 0;
 
     lfs_file_close(&lfs, &file) => 0;
     lfs_unmount(&lfs) => 0;

tests/test_interspersed.toml

@@ -242,695 +242,3 @@ code = '''
     
     lfs_unmount(&lfs) => 0;
 '''
-
-[[case]] # open same file reading from separate file handles
-define.READERS = 3
-define.SIZE = [10, 100, 1000, 10000]
-define.RDMODE = ['LFS_O_RDONLY', 'LFS_O_RDWR']
-code = '''
-    const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
-    lfs_format(&lfs, &cfg) => 0;
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file, "shared", LFS_O_CREAT | LFS_O_WRONLY) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // open all files
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_t readers[READERS];
-    for (int i = 0; i < READERS; i++) {
-        lfs_file_open(&lfs, &readers[i], "shared", RDMODE) => 0;
-    }
-
-    // perform operations while all readers are open
-    for (int i = 0; i < READERS; i++) {
-        for (int j = 0; j < SIZE; j++) {
-            lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
-            assert(buffer[0] == alphas[j % 26]);
-        }
-    }
-
-    for (int i = 0; i < READERS; i++) {
-        lfs_file_close(&lfs, &readers[i]) => 0;
-    }
-    lfs_unmount(&lfs) => 0;
-'''
-
-[[case]] # open same file reading and writing from separate file handles
-define.READERS = 3
-define.SIZE = [10, 100, 1000, 10000]
-define.RDMODE = ['LFS_O_RDONLY', 'LFS_O_RDWR']
-define.WRMODE = ['LFS_O_WRONLY', 'LFS_O_RDWR']
-code = '''
-    const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
-    const char nums[] = "0123456789";
-    lfs_format(&lfs, &cfg) => 0;
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file, "shared", LFS_O_CREAT | LFS_O_WRONLY) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // open all files
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_t writer;
-    lfs_file_t readers[READERS];
-    lfs_file_open(&lfs, &writer, "shared", WRMODE) => 0;
-    for (int i = 0; i < READERS; i++) {
-        lfs_file_open(&lfs, &readers[i], "shared", RDMODE) => 0;
-    }
-
-    // perform operations while all readers are open
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &writer, &nums[j % 10], 1) => 1;
-    }
-
-    for (int i = 0; i < READERS; i++) {
-        for (int j = 0; j < SIZE/2; j++) {
-            lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
-            assert(buffer[0] == alphas[j % 26]);
-        }
-    }
-
-    // sync, now write should reflect in all open files
-    lfs_file_sync(&lfs, &writer) => 0;
-
-    for (int i = 0; i < READERS; i++) {
-        for (int j = SIZE/2; j < SIZE; j++) {
-            lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
-            assert(buffer[0] == nums[j % 10]);
-        }
-    }
-
-    // double check our writer reflects its own changes
-    if (WRMODE == LFS_O_RDWR) {
-        lfs_file_rewind(&lfs, &writer) => 0;
-        for (int j = 0; j < SIZE; j++) {
-            lfs_file_read(&lfs, &writer, buffer, 1) => 1;
-            assert(buffer[0] == nums[j % 10]);
-        }
-    }
-
-    for (int i = 0; i < READERS; i++) {
-        lfs_file_close(&lfs, &readers[i]) => 0;
-    }
-    lfs_unmount(&lfs) => 0;
-'''
-
-[[case]] # check that attributes are updated in open files
-define.READERS = 3
-define.SIZE = 10
-define.RDMODE = ['LFS_O_RDONLY', 'LFS_O_RDWR']
-define.WRMODE = ['LFS_O_WRONLY', 'LFS_O_RDWR']
-code = '''
-    const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
-    const char nums[] = "0123456789";
-    lfs_format(&lfs, &cfg) => 0;
-    lfs_mount(&lfs, &cfg) => 0;
-    const struct lfs_file_config filecfg = {
-        .attr_count = 3,
-        .attrs = (struct lfs_attr[]){
-            {'A', "a",   1},
-            {'B', "bb",  2},
-            {'C', "ccc", 3},
-        },
-    };
-    lfs_file_opencfg(&lfs, &file, "shared",
-            LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // open all files
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_t writer;
-    const struct lfs_file_config writercfg = {
-        .attr_count = 3,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[1]){0}, 1},
-            {'B', &(uint8_t[2]){0}, 2},
-            {'C', &(uint8_t[3]){0}, 3}}};
-    lfs_file_t readers[READERS];
-    const struct lfs_file_config readercfgs[READERS] = {
-        {   .attr_count = 3,
-            .attrs = (struct lfs_attr[]){
-                {'A', &(uint8_t[1]){0}, 1},
-                {'B', &(uint8_t[2]){0}, 2},
-                {'C', &(uint8_t[3]){0}, 3}}},
-        {   .attr_count = 3,
-            .attrs = (struct lfs_attr[]){
-                {'A', &(uint8_t[1]){0}, 1},
-                {'B', &(uint8_t[2]){0}, 2},
-                {'C', &(uint8_t[3]){0}, 3}}},
-        {   .attr_count = 3,
-            .attrs = (struct lfs_attr[]){
-                {'A', &(uint8_t[1]){0}, 1},
-                {'B', &(uint8_t[2]){0}, 2},
-                {'C', &(uint8_t[3]){0}, 3}}}};
-    lfs_file_opencfg(&lfs, &writer, "shared",
-            WRMODE, &writercfg) => 0;
-    for (int i = 0; i < READERS; i++) {
-        lfs_file_opencfg(&lfs, &readers[i], "shared",
-                RDMODE, &readercfgs[i]) => 0;
-    }
-
-    // perform operations while all readers are open
-    writercfg.attrs[0].size = 1;
-    memcpy(writercfg.attrs[0].buffer, "0", 1);
-    writercfg.attrs[1].size = 2;
-    memcpy(writercfg.attrs[1].buffer, "11", 2);
-    writercfg.attrs[2].size = 3;
-    memcpy(writercfg.attrs[2].buffer, "222", 3);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &writer, &nums[j % 10], 1) => 1;
-    }
-
-    for (int i = 0; i < READERS; i++) {
-        assert(readercfgs[i].attrs[0].size == 1);
-        assert(memcmp(readercfgs[i].attrs[0].buffer, "a", 1) == 0);
-        assert(readercfgs[i].attrs[1].size == 2);
-        assert(memcmp(readercfgs[i].attrs[1].buffer, "bb", 2) == 0);
-        assert(readercfgs[i].attrs[2].size == 3);
-        assert(memcmp(readercfgs[i].attrs[2].buffer, "ccc", 3) == 0);
-        for (int j = 0; j < SIZE; j++) {
-            lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
-            assert(buffer[0] == alphas[j % 26]);
-        }
-    }
-
-    // sync, now write should reflect in all open files
-    lfs_file_sync(&lfs, &writer) => 0;
-
-    for (int i = 0; i < READERS; i++) {
-        assert(readercfgs[i].attrs[0].size == 1);
-        assert(memcmp(readercfgs[i].attrs[0].buffer, "0", 1) == 0);
-        assert(readercfgs[i].attrs[1].size == 2);
-        assert(memcmp(readercfgs[i].attrs[1].buffer, "11", 2) == 0);
-        assert(readercfgs[i].attrs[2].size == 3);
-        assert(memcmp(readercfgs[i].attrs[2].buffer, "222", 3) == 0);
-        lfs_file_rewind(&lfs, &readers[i]) => 0;
-        for (int j = 0; j < SIZE; j++) {
-            lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
-            assert(buffer[0] == nums[j % 10]);
-        }
-    }
-
-    // double check our writer reflects its own changes
-    if (WRMODE == LFS_O_RDWR) {
-        assert(writercfg.attrs[0].size == 1);
-        assert(memcmp(writercfg.attrs[0].buffer, "0", 1) == 0);
-        assert(writercfg.attrs[1].size == 2);
-        assert(memcmp(writercfg.attrs[1].buffer, "11", 2) == 0);
-        assert(writercfg.attrs[2].size == 3);
-        assert(memcmp(writercfg.attrs[2].buffer, "222", 3) == 0);
-        lfs_file_rewind(&lfs, &writer) => 0;
-        for (int j = 0; j < SIZE; j++) {
-            lfs_file_read(&lfs, &writer, buffer, 1) => 1;
-            assert(buffer[0] == nums[j % 10]);
-        }
-    }
-
-    // now try explicit lfs_setattr calls, this should still update open files
-    lfs_setattr(&lfs, "shared", 'A', "A",   1) => 0;
-    lfs_setattr(&lfs, "shared", 'B', "BB",  2) => 0;
-    lfs_setattr(&lfs, "shared", 'C', "CCC", 3) => 0;
-
-    for (int i = 0; i < READERS; i++) {
-        assert(readercfgs[i].attrs[0].size == 1);
-        assert(memcmp(readercfgs[i].attrs[0].buffer, "A", 1) == 0);
-        assert(readercfgs[i].attrs[1].size == 2);
-        assert(memcmp(readercfgs[i].attrs[1].buffer, "BB", 2) == 0);
-        assert(readercfgs[i].attrs[2].size == 3);
-        assert(memcmp(readercfgs[i].attrs[2].buffer, "CCC", 3) == 0);
-        lfs_file_rewind(&lfs, &readers[i]) => 0;
-        for (int j = 0; j < SIZE; j++) {
-            lfs_file_read(&lfs, &readers[i], buffer, 1) => 1;
-            assert(buffer[0] == nums[j % 10]);
-        }
-    }
-
-    if (WRMODE == LFS_O_RDWR) {
-        assert(writercfg.attrs[0].size == 1);
-        assert(memcmp(writercfg.attrs[0].buffer, "A", 1) == 0);
-        assert(writercfg.attrs[1].size == 2);
-        assert(memcmp(writercfg.attrs[1].buffer, "BB", 2) == 0);
-        assert(writercfg.attrs[2].size == 3);
-        assert(memcmp(writercfg.attrs[2].buffer, "CCC", 3) == 0);
-        lfs_file_rewind(&lfs, &writer) => 0;
-        for (int j = 0; j < SIZE; j++) {
-            lfs_file_read(&lfs, &writer, buffer, 1) => 1;
-            assert(buffer[0] == nums[j % 10]);
-        }
-    } else if (WRMODE == LFS_O_WRONLY) {
-        // this should NOT update wronly attributes, these may be
-        // stored in read-only memory
-        assert(writercfg.attrs[0].size == 1);
-        assert(memcmp(writercfg.attrs[0].buffer, "0", 1) == 0);
-        assert(writercfg.attrs[1].size == 2);
-        assert(memcmp(writercfg.attrs[1].buffer, "11", 2) == 0);
-        assert(writercfg.attrs[2].size == 3);
-        assert(memcmp(writercfg.attrs[2].buffer, "222", 3) == 0);
-    }
-
-    for (int i = 0; i < READERS; i++) {
-        lfs_file_close(&lfs, &readers[i]) => 0;
-    }
-    lfs_unmount(&lfs) => 0;
-'''
-
-[[case]] # simple snapshot for reading
-define.SIZE = [10, 100, 1000, 10000]
-code = '''
-    const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
-    const char nums[] = "0123456789";
-    lfs_format(&lfs, &cfg) => 0;
-    lfs_mount(&lfs, &cfg) => 0;
-    const struct lfs_file_config filecfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', "abcd", 4},
-        },
-    };
-    lfs_file_opencfg(&lfs, &file, "open_me",
-            LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // open reader/writer/snapshot
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_t reader;
-    const struct lfs_file_config readercfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_t writer;
-    const struct lfs_file_config writercfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_t snapshot;
-    const struct lfs_file_config snapshotcfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    lfs_file_opencfg(&lfs, &writer, "open_me",
-            LFS_O_WRONLY, &writercfg) => 0;
-    lfs_file_opencfg(&lfs, &snapshot, "open_me",
-            LFS_O_RDONLY | LFS_O_SNAPSHOT, &snapshotcfg) => 0;
-
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE/2; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    assert(memcmp(snapshotcfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE/2; j++) {
-        lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    // write file
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &writer, &nums[j % 10], 1) => 1;
-    }
-    memcpy(writercfg.attrs[0].buffer, "0123", 4);
-    lfs_file_sync(&lfs, &writer) => 0;
-
-    // reader should change
-    assert(memcmp(readercfg.attrs[0].buffer, "0123", 4) == 0);
-    for (int j = SIZE/2; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-
-    // snapshot should remain unchanged
-    assert(memcmp(snapshotcfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = SIZE/2; j < SIZE; j++) {
-        lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_file_close(&lfs, &writer) => 0;
-    lfs_file_close(&lfs, &snapshot) => 0;
-
-    // disk should change
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "0123", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "0123", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_unmount(&lfs) => 0;
-'''
-
-[[case]] # simple snapshot for writing
-define.SIZE = [10, 100, 1000, 10000]
-code = '''
-    const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
-    const char nums[] = "0123456789";
-    lfs_format(&lfs, &cfg) => 0;
-    lfs_mount(&lfs, &cfg) => 0;
-    const struct lfs_file_config filecfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', "abcd", 4},
-        },
-    };
-    lfs_file_opencfg(&lfs, &file, "open_me",
-            LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // open reader/snapshot
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_t reader;
-    const struct lfs_file_config readercfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_t snapshot;
-    const struct lfs_file_config snapshotcfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    lfs_file_opencfg(&lfs, &snapshot, "open_me",
-            LFS_O_RDWR | LFS_O_SNAPSHOT, &snapshotcfg) => 0;
-
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE/2; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    assert(memcmp(snapshotcfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    // modify snapshot
-    lfs_file_rewind(&lfs, &snapshot) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &snapshot, &nums[j % 10], 1) => 1;
-    }
-    memcpy(snapshotcfg.attrs[0].buffer, "0123", 4);
-
-    lfs_file_rewind(&lfs, &snapshot) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-
-    lfs_file_sync(&lfs, &snapshot) => 0;
-
-    // reader should not change
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = SIZE/2; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    // snapshot should changed
-    assert(memcmp(snapshotcfg.attrs[0].buffer, "0123", 4) == 0);
-    lfs_file_rewind(&lfs, &snapshot) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &snapshot, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_file_close(&lfs, &snapshot) => 0;
-
-    // disk should not change
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_unmount(&lfs) => 0;
-'''
-
-[[case]] # temporary files
-define.SIZE = [10, 100, 1000, 10000]
-define.TMP_PATH = 'range(4)'
-code = '''
-    const char alphas[] = "abcdefghijklmnopqrstuvwxyz";
-    const char nums[] = "0123456789";
-    const char caps[] = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
-    lfs_format(&lfs, &cfg) => 0;
-    lfs_mount(&lfs, &cfg) => 0;
-    const struct lfs_file_config filecfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', "abcd", 4},
-        },
-    };
-    lfs_file_opencfg(&lfs, &file, "open_me",
-            LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_file_opencfg(&lfs, &file, "dont_open_me",
-            LFS_O_CREAT | LFS_O_WRONLY, &filecfg) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &file, &alphas[j % 26], 1) => 1;
-    }
-    lfs_file_close(&lfs, &file) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    // open reader/writer/temp
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_t reader;
-    const struct lfs_file_config readercfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_t writer;
-    const struct lfs_file_config writercfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_t tmp;
-    const struct lfs_file_config tmpcfg = {
-        .attr_count = 1,
-        .attrs = (struct lfs_attr[]){
-            {'A', &(uint8_t[4]){0}, 4}
-        },
-    };
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    lfs_file_opencfg(&lfs, &writer, "open_me",
-            LFS_O_WRONLY, &writercfg) => 0;
-    const char *tmp_paths[] = {NULL, "/", "/tmp", "/open_me.tmp"};
-    lfs_file_opencfg(&lfs, &tmp, tmp_paths[TMP_PATH],
-            LFS_O_RDWR | LFS_O_CREAT | LFS_O_SNAPSHOT, &tmpcfg) => 0;
-
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE/3; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    assert(memcmp(tmpcfg.attrs[0].buffer, "\0\0\0\0", 4) == 0);
-    assert(lfs_file_size(&lfs, &tmp) == 0);
-
-    // write to tmp
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &tmp, &nums[j % 10], 1) => 1;
-    }
-    memcpy(tmpcfg.attrs[0].buffer, "0123", 4);
-
-    lfs_file_rewind(&lfs, &tmp) => 0;
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &tmp, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-
-    lfs_file_sync(&lfs, &tmp) => 0;
-
-    // reader should not change
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = SIZE/3; j < 2*SIZE/3; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-
-    // tmp should change
-    assert(memcmp(tmpcfg.attrs[0].buffer, "0123", 4) == 0);
-    lfs_file_rewind(&lfs, &tmp) => 0;
-    for (int j = 0; j < SIZE/2; j++) {
-        lfs_file_read(&lfs, &tmp, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-
-    // write to file
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_write(&lfs, &writer, &caps[j % 26], 1) => 1;
-    }
-    memcpy(writercfg.attrs[0].buffer, "ABCD", 4);
-    lfs_file_sync(&lfs, &writer) => 0;
-
-    // reader should change
-    assert(memcmp(readercfg.attrs[0].buffer, "ABCD", 4) == 0);
-    for (int j = 2*SIZE/3; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == caps[j % 26]);
-    }
-
-    // tmp should not change
-    assert(memcmp(tmpcfg.attrs[0].buffer, "0123", 4) == 0);
-    for (int j = SIZE/2; j < SIZE; j++) {
-        lfs_file_read(&lfs, &tmp, buffer, 1) => 1;
-        assert(buffer[0] == nums[j % 10]);
-    }
-
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_file_close(&lfs, &writer) => 0;
-    lfs_file_close(&lfs, &tmp) => 0;
-
-    // tmp should not appear on disk
-    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_DIR);
-    assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_DIR);
-    assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_REG);
-    assert(strcmp(info.name, "dont_open_me") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_REG);
-    assert(strcmp(info.name, "open_me") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "ABCD", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == caps[j % 26]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_file_opencfg(&lfs, &reader, "dont_open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_unmount(&lfs) => 0;
-
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_dir_open(&lfs, &dir, "/") => 0;
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_DIR);
-    assert(strcmp(info.name, ".") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_DIR);
-    assert(strcmp(info.name, "..") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_REG);
-    assert(strcmp(info.name, "dont_open_me") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 1;
-    assert(info.type == LFS_TYPE_REG);
-    assert(strcmp(info.name, "open_me") == 0);
-    lfs_dir_read(&lfs, &dir, &info) => 0;
-    lfs_dir_close(&lfs, &dir) => 0;
-    lfs_file_opencfg(&lfs, &reader, "open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "ABCD", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == caps[j % 26]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_file_opencfg(&lfs, &reader, "dont_open_me",
-            LFS_O_RDONLY, &readercfg) => 0;
-    assert(memcmp(readercfg.attrs[0].buffer, "abcd", 4) == 0);
-    for (int j = 0; j < SIZE; j++) {
-        lfs_file_read(&lfs, &reader, buffer, 1) => 1;
-        assert(buffer[0] == alphas[j % 26]);
-    }
-    lfs_file_close(&lfs, &reader) => 0;
-    lfs_unmount(&lfs) => 0;
-'''
-
-[[case]] # test snapshot open errors
-code = '''
-    lfs_format(&lfs, &cfg) => 0;
-    lfs_mount(&lfs, &cfg) => 0;
-    lfs_file_open(&lfs, &file, NULL,
-            LFS_O_RDWR | LFS_O_SNAPSHOT) => LFS_ERR_ISDIR;
-    lfs_file_open(&lfs, &file, "/",
-            LFS_O_RDWR | LFS_O_SNAPSHOT) => LFS_ERR_ISDIR;
-    lfs_file_open(&lfs, &file, "/tmp",
-            LFS_O_RDWR | LFS_O_SNAPSHOT) => LFS_ERR_NOENT;
-    lfs_file_open(&lfs, &file, "/tmp/",
-            LFS_O_RDWR | LFS_O_CREAT | LFS_O_SNAPSHOT) => LFS_ERR_NOENT;
-    lfs_file_open(&lfs, &file, "/tmp/tmp",
-            LFS_O_RDWR | LFS_O_CREAT | LFS_O_SNAPSHOT) => LFS_ERR_NOENT;
-    lfs_unmount(&lfs) => 0;
-'''

tests/test_paths.toml

@@ -95,9 +95,9 @@ code = '''
 
     lfs_mkdir(&lfs, "coffee/../milk") => 0;
     lfs_stat(&lfs, "coffee/../milk", &info) => 0;
-    assert(strcmp(info.name, "milk") == 0);
+    strcmp(info.name, "milk") => 0;
     lfs_stat(&lfs, "milk", &info) => 0;
-    assert(strcmp(info.name, "milk") == 0);
+    strcmp(info.name, "milk") => 0;
     lfs_unmount(&lfs) => 0;
 '''
 
@@ -129,9 +129,9 @@ code = '''
     lfs_mount(&lfs, &cfg) => 0;
     lfs_mkdir(&lfs, ".milk") => 0;
     lfs_stat(&lfs, ".milk", &info) => 0;
-    assert(strcmp(info.name, ".milk") == 0);
+    strcmp(info.name, ".milk") => 0;
     lfs_stat(&lfs, "tea/.././.milk", &info) => 0;
-    assert(strcmp(info.name, ".milk") == 0);
+    strcmp(info.name, ".milk") => 0;
     lfs_unmount(&lfs) => 0;
 '''
 
@@ -149,13 +149,13 @@ code = '''
     lfs_mkdir(&lfs, "coffee/coldcoffee") => 0;
 
     lfs_stat(&lfs, "coffee/../../../../../../tea/hottea", &info) => 0;
-    assert(strcmp(info.name, "hottea") == 0);
+    strcmp(info.name, "hottea") => 0;
 
     lfs_mkdir(&lfs, "coffee/../../../../../../milk") => 0;
     lfs_stat(&lfs, "coffee/../../../../../../milk", &info) => 0;
-    assert(strcmp(info.name, "milk") == 0);
+    strcmp(info.name, "milk") => 0;
     lfs_stat(&lfs, "milk", &info) => 0;
-    assert(strcmp(info.name, "milk") == 0);
+    strcmp(info.name, "milk") => 0;
     lfs_unmount(&lfs) => 0;
 '''
 

tests/test_powerloss.toml

@@ -0,0 +1,172 @@
+# There are already a number of tests that test general operations under
+# power-loss (see the reentrant attribute). These tests are for explicitly
+# testing specific corner cases.
+
+[[case]] # only a revision count
+code = '''
+    lfs_format(&lfs, &cfg) => 0;
+
+    lfs_mount(&lfs, &cfg) => 0;
+    lfs_mkdir(&lfs, "notebook") => 0;
+    lfs_file_open(&lfs, &file, "notebook/paper",
+            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
+    strcpy((char*)buffer, "hello");
+    size = strlen("hello");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_write(&lfs, &file, buffer, size) => size;
+        lfs_file_sync(&lfs, &file) => 0;
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    char rbuffer[256];
+    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    lfs_file_close(&lfs, &file) => 0;
+    lfs_unmount(&lfs) => 0;
+
+    // get pair/rev count
+    lfs_mount(&lfs, &cfg) => 0;
+    lfs_dir_open(&lfs, &dir, "notebook") => 0;
+    lfs_block_t pair[2] = {dir.m.pair[0], dir.m.pair[1]};
+    uint32_t rev = dir.m.rev;
+    lfs_dir_close(&lfs, &dir) => 0;
+    lfs_unmount(&lfs) => 0;
+
+    // write just the revision count
+    uint8_t bbuffer[LFS_BLOCK_SIZE];
+    cfg.read(&cfg, pair[1], 0, bbuffer, LFS_BLOCK_SIZE) => 0;
+
+    memcpy(bbuffer, &(uint32_t){lfs_tole32(rev+1)}, sizeof(uint32_t));
+
+    cfg.erase(&cfg, pair[1]) => 0;
+    cfg.prog(&cfg, pair[1], 0, bbuffer, LFS_BLOCK_SIZE) => 0;
+
+    lfs_mount(&lfs, &cfg) => 0;
+
+    // can read?
+    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    // can write?
+    lfs_file_open(&lfs, &file, "notebook/paper",
+            LFS_O_WRONLY | LFS_O_APPEND) => 0;
+    strcpy((char*)buffer, "goodbye");
+    size = strlen("goodbye");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_write(&lfs, &file, buffer, size) => size;
+        lfs_file_sync(&lfs, &file) => 0;
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
+    strcpy((char*)buffer, "hello");
+    size = strlen("hello");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    strcpy((char*)buffer, "goodbye");
+    size = strlen("goodbye");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    lfs_unmount(&lfs) => 0;
+'''
+
+[[case]] # partial prog, may not be byte in order!
+if = "LFS_PROG_SIZE < LFS_BLOCK_SIZE"
+define.BYTE_OFF = ["0", "LFS_PROG_SIZE-1", "LFS_PROG_SIZE/2"]
+define.BYTE_VALUE = [0x33, 0xcc]
+in = "lfs.c"
+code = '''
+    lfs_format(&lfs, &cfg) => 0;
+
+    lfs_mount(&lfs, &cfg) => 0;
+    lfs_mkdir(&lfs, "notebook") => 0;
+    lfs_file_open(&lfs, &file, "notebook/paper",
+            LFS_O_WRONLY | LFS_O_CREAT | LFS_O_APPEND) => 0;
+    strcpy((char*)buffer, "hello");
+    size = strlen("hello");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_write(&lfs, &file, buffer, size) => size;
+        lfs_file_sync(&lfs, &file) => 0;
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    char rbuffer[256];
+    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    lfs_file_close(&lfs, &file) => 0;
+    lfs_unmount(&lfs) => 0;
+
+    // imitate a partial prog, value should not matter, if littlefs
+    // doesn't notice the partial prog testbd will assert
+
+    // get offset to next prog
+    lfs_mount(&lfs, &cfg) => 0;
+    lfs_dir_open(&lfs, &dir, "notebook") => 0;
+    lfs_block_t block = dir.m.pair[0];
+    lfs_off_t off = dir.m.off;
+    lfs_dir_close(&lfs, &dir) => 0;
+    lfs_unmount(&lfs) => 0;
+
+    // tweak byte
+    uint8_t bbuffer[LFS_BLOCK_SIZE];
+    cfg.read(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0;
+
+    bbuffer[off + BYTE_OFF] = BYTE_VALUE;
+
+    cfg.erase(&cfg, block) => 0;
+    cfg.prog(&cfg, block, 0, bbuffer, LFS_BLOCK_SIZE) => 0;
+
+    lfs_mount(&lfs, &cfg) => 0;
+
+    // can read?
+    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    // can write?
+    lfs_file_open(&lfs, &file, "notebook/paper",
+            LFS_O_WRONLY | LFS_O_APPEND) => 0;
+    strcpy((char*)buffer, "goodbye");
+    size = strlen("goodbye");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_write(&lfs, &file, buffer, size) => size;
+        lfs_file_sync(&lfs, &file) => 0;
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    lfs_file_open(&lfs, &file, "notebook/paper", LFS_O_RDONLY) => 0;
+    strcpy((char*)buffer, "hello");
+    size = strlen("hello");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    strcpy((char*)buffer, "goodbye");
+    size = strlen("goodbye");
+    for (int i = 0; i < 5; i++) {
+        lfs_file_read(&lfs, &file, rbuffer, size) => size;
+        assert(memcmp(rbuffer, buffer, size) == 0);
+    }
+    lfs_file_close(&lfs, &file) => 0;
+
+    lfs_unmount(&lfs) => 0;
+'''