diff --git a/lfs.c b/lfs.c index adf3b776..7445d7cc 100644 --- a/lfs.c +++ b/lfs.c @@ -463,9 +463,8 @@ enum lfsr_tag_type { LFSR_TAG_RMUATTR = 0x2002, LFSR_TAG_BTREE = 0x0820, -// TODO these -// LFSR_TAG_WIDEN = 0x0004, -// LFSR_TAG_SHRINK = 0x0014, + LFSR_TAG_GROW = 0x0006, + LFSR_TAG_SHRINK = 0x0016, LFSR_TAG_ALT = 0x0008, LFSR_TAG_ALTBLE = 0x0008, @@ -473,10 +472,10 @@ enum lfsr_tag_type { LFSR_TAG_ALTBGT = 0x000c, LFSR_TAG_ALTRGT = 0x000e, - LFSR_TAG_CRC = 0x0024, - LFSR_TAG_CRC0 = 0x0024, - LFSR_TAG_CRC1 = 0x0034, - LFSR_TAG_FCRC = 0x0044, + LFSR_TAG_CRC = 0x0004, + LFSR_TAG_CRC0 = 0x0004, + LFSR_TAG_CRC1 = 0x0014, + LFSR_TAG_FCRC = 0x0024, }; #define LFSR_TAG_ALT_(color, dir, key) \ @@ -502,8 +501,12 @@ static inline bool lfsr_tag_isrm(lfsr_tag_t tag) { return tag & 0x2; } +static inline bool lfsr_tag_hasdata(lfsr_tag_t tag) { + return (tag & 0xe) <= 0x4; +} + static inline bool lfsr_tag_istrunk(lfsr_tag_t tag) { - return (tag & 0xc) != 0x4; + return (tag & 0xe) != 0x4; } static inline bool lfsr_tag_isalt(lfsr_tag_t tag) { @@ -675,16 +678,41 @@ struct lfs_diskoff { struct lfsr_attr { lfsr_tag_t tag; lfs_ssize_t id; - const void *buffer; - lfs_size_t size; + union { + struct { + const void *buffer; + lfs_size_t size; + } data; + struct { + lfs_size_t from; + lfs_size_t to; + } grow; + } u; const struct lfsr_attr *next; }; -#define LFSR_ATTR_(tag, id, buffer, size, next) \ - (&(const struct lfsr_attr){tag, id, buffer, size, next}) +#define LFSR_ATTR_(_tag, _id, _buffer, _size, _next) \ + (&(const struct lfsr_attr){ \ + .tag=(_tag), \ + .id=(_id), \ + .u.data.buffer=(_buffer), \ + .u.data.size=(_size), \ + .next=(_next) }) -#define LFSR_ATTR(type, id, buffer, size, next) \ - LFSR_ATTR_(LFSR_TAG_##type, id, buffer, size, next) +#define LFSR_ATTR(_type, _id, _buffer, _size, _next) \ + LFSR_ATTR_(LFSR_TAG_##_type, _id, _buffer, _size, _next) + +#define LFSR_ATTR_SHIFT_(_tag, _id, _from, _to, _next) \ + (&(const struct lfsr_attr){ \ + .tag=(_tag), \ + .id=(_id), \ + .u.grow.from=(_from), \ + .u.grow.to=(_to), \ + .next=(_next) }) + +#define LFSR_ATTR_SHIFT(_tag, _id, _from, _to, _next) \ + LFSR_ATTR_SHIFT_(LFSR_TAG_##_type, _id, _from, _to, _next) + //#define LFS_MKRATTR_(...) // (&(const struct lfsr_attr){__VA_ARGS__}) @@ -1260,13 +1288,28 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, off += delta; - // we mostly just skip alt pointers here - if (lfsr_tag_isalt(tag)) { - continue; + // update our id count + // + // NOTE we can't check for overflow/underflow here because we + // may be overeagerly parsing an invalid commit, it's ok for + // this to overflow/underflow as long as we throw it out later + // on a bad crc + if (tag == LFSR_TAG_GROW) { + weight += size; + } else if (tag == LFSR_TAG_SHRINK) { + weight -= size; } - // trunk ends at non-alt tag - wastrunk = false; + // TODO could this be better? + if (!lfsr_tag_isalt(tag)) { + // trunk ends at non-alt tag + wastrunk = false; + } + + // we mostly just skip alt pointers here + if (!lfsr_tag_hasdata(tag)) { + continue; + } // tag goes out of range? if (off + size > limit) { @@ -1289,53 +1332,53 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, return err; } - // found a mk? update id count - if (lfsr_tag_ismk(tag)) { - // NOTE we can't check for overflow/underflow here because we - // may be overeagerly parsing an invalid commit, it's ok for - // this to overflow/underflow as long as we throw it out later - // on a bad crc - weight += 1; - - } else if (tag == LFSR_TAG_RM) { - // NOTE we can't check for overflow/underflow here because we - // may be overeagerly parsing an invalid commit, it's ok for - // this to overflow/underflow as long as we throw it out later - // on a bad crc - weight -= 1; - -// TODO this -// // found an expand/shrink? update id count -// } else if (tag == LFSR_TAG_EXPAND || tag == LFSR_TAG_SHRINK) { -// uint8_t buf[5]; -// err = lfs_bd_read(lfs, -// NULL, &lfs->rcache, limit-off, -// block, off, buf, lfs_min(size, 5)); -// if (err) { -// if (err == LFS_ERR_CORRUPT) { -// break; -// } -// return err; -// } -// -// lfs_size_t weight_; -// lfs_ssize_t delta = lfs_fromleb128(&weight_, buf, 5); -// if (delta < 0) { -// return delta; -// } -// +// // found a mk? update id count +// if (lfsr_tag_ismk(tag)) { // // NOTE we can't check for overflow/underflow here because we // // may be overeagerly parsing an invalid commit, it's ok for // // this to overflow/underflow as long as we throw it out later // // on a bad crc -// if (tag == LFSR_TAG_EXPAND) { -// weight += weight_; -// } else { -// weight -= weight_; -// } +// weight += 1; +// +// } else if (tag == LFSR_TAG_RM) { +// // NOTE we can't check for overflow/underflow here because we +// // may be overeagerly parsing an invalid commit, it's ok for +// // this to overflow/underflow as long as we throw it out later +// // on a bad crc +// weight -= 1; +// +//// TODO this +//// // found an expand/shrink? update id count +//// } else if (tag == LFSR_TAG_EXPAND || tag == LFSR_TAG_SHRINK) { +//// uint8_t buf[5]; +//// err = lfs_bd_read(lfs, +//// NULL, &lfs->rcache, limit-off, +//// block, off, buf, lfs_min(size, 5)); +//// if (err) { +//// if (err == LFS_ERR_CORRUPT) { +//// break; +//// } +//// return err; +//// } +//// +//// lfs_size_t weight_; +//// lfs_ssize_t delta = lfs_fromleb128(&weight_, buf, 5); +//// if (delta < 0) { +//// return delta; +//// } +//// +//// // NOTE we can't check for overflow/underflow here because we +//// // may be overeagerly parsing an invalid commit, it's ok for +//// // this to overflow/underflow as long as we throw it out later +//// // on a bad crc +//// if (tag == LFSR_TAG_EXPAND) { +//// weight += weight_; +//// } else { +//// weight -= weight_; +//// } // found an fcrc? save for later - } else if (tag == LFSR_TAG_FCRC) { + if (tag == LFSR_TAG_FCRC) { uint8_t fbuf[LFSR_FCRC_DSIZE]; err = lfs_bd_read(lfs, NULL, &lfs->rcache, limit-off, @@ -1479,7 +1522,7 @@ static int lfsr_rbyd_fetch(lfs_t *lfs, lfsr_rbyd_t *rbyd, static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfsr_tag_t tag, lfs_ssize_t id, - lfsr_tag_t *tag_, lfs_ssize_t *id_, + lfsr_tag_t *tag_, lfs_ssize_t *id_, lfs_size_t *weight_, lfs_off_t *off_, lfs_size_t *size_) { // tag must be non-zero! zero tags may deceptively look like they work but // fail when the tree contains a deleted id0 @@ -1535,6 +1578,9 @@ static int lfsr_rbyd_lookup(lfs_t *lfs, const lfsr_rbyd_t *rbyd, // TODO how many of these need to be conditional? *tag_ = tag__; *id_ = id__; + if (weight_) { + *weight_ = id__ - lower; + } if (off_) { *off_ = branch + delta; } @@ -1554,7 +1600,7 @@ static lfs_ssize_t lfsr_rbyd_get(lfs_t *lfs, const lfsr_rbyd_t *rbyd, lfs_off_t off_; lfs_size_t size_; int err = lfsr_rbyd_lookup(lfs, rbyd, tag, id, - &tag_, &id_, &off_, &size_); + &tag_, &id_, NULL, &off_, &size_); if (err) { return err; } @@ -1780,6 +1826,8 @@ static void lfsr_rbyd_p_red( } } +// TODO s/rbyd_/rbyd/g +// TODO s/size/len/g // core rbyd algorithm static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, lfsr_tag_t tag, lfs_ssize_t id, const void *buffer, lfs_size_t size) { @@ -1787,30 +1835,48 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, lfs_off_t branch = rbyd_->trunk; rbyd_->trunk = rbyd_->off; - // no trunk yet? - if (!branch) { - goto leaf; - } + // TODO where should this go? +// // no trunk yet? +// if (!branch) { +// goto leaf; +// } + // TODO these can probably be rearranged // figure out the range of tags to operate on lfsr_tag_t tag_; lfs_ssize_t id_; lfsr_tag_t other_tag_; lfs_ssize_t other_id_; if (lfsr_tag_ismk(tag)) { - LFS_ASSERT(rbyd_->weight < 0xffff); + // TODO these asserts are missed because of the above goto LFS_ASSERT(id <= rbyd_->weight); tag_ = 0; id_ = id; other_tag_ = tag_; other_id_ = id_; } else if (tag == LFSR_TAG_RM) { - LFS_ASSERT(rbyd_->weight > 0); + // TODO these asserts are missed because of the above goto + LFS_ASSERT(rbyd_->weight >= size); LFS_ASSERT(id < rbyd_->weight); + LFS_ASSERT(id >= size-1); tag_ = 0; id_ = id; other_tag_ = tag_; other_id_ = id_ + 1; + } else if (tag == LFSR_TAG_GROW) { + LFS_ASSERT(id < rbyd_->weight); + tag_ = 0; + id_ = id; + other_tag_ = tag_; + other_id_ = id_; + } else if (tag == LFSR_TAG_SHRINK) { + LFS_ASSERT(rbyd_->weight >= size); + LFS_ASSERT(id < rbyd_->weight); + LFS_ASSERT(id >= size-1); + tag_ = 0; + id_ = id; + other_tag_ = tag_; + other_id_ = id_; } else if (lfsr_tag_isrm(tag)) { LFS_ASSERT(id < rbyd_->weight); tag_ = tag & ~0x2; @@ -1835,6 +1901,37 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, lfsr_tag_t lower_tag = 0; lfsr_tag_t upper_tag = 0xffff; + // TODO move this? we need weight above but maybe we can save it earlier? + // TODO rename rbyd_ -> rbyd + // TODO combine all these mk/rm conditions? + + // create grow/shrink tags if necessary + if (lfsr_tag_ismk(tag)) { + int err = lfsr_rbyd_progtag(lfs, rbyd_, + LFSR_TAG_GROW, id, 1, &rbyd_->crc); + if (err) { + return err; + } + + // update our trunk so grow/shrink isn't in it + rbyd_->trunk = rbyd_->off; + +// } else if (tag == LFSR_TAG_RM) { +// int err = lfsr_rbyd_progtag(lfs, rbyd_, +// LFSR_TAG_SHRINK, id, 1, &rbyd_->crc); +// if (err) { +// return err; +// } +// +// // update our trunk so grow/shrink isn't in it +// rbyd_->trunk = rbyd_->off; + } + + // no trunk yet? + if (!branch) { + goto leaf; + } + // diverged state in case we are removing a range from the tree // // this is a second copy of the search path state, used to keep track @@ -2131,6 +2228,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, weight = id_ - lower_id; } else if (lfsr_tag_ismk(tag)) { + // TODO what is this id check doing? if (id_ >= id) { // increase weight when creating alt = LFSR_TAG_ALT(B, GT, tag); @@ -2138,10 +2236,27 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } } else if (tag == LFSR_TAG_RM) { + // TODO what is this id check doing? if (id_ > id) { // decrease weight when deleting alt = LFSR_TAG_ALT(B, GT, 0); - weight = upper_id - lower_id - 1 - 1; + weight = upper_id - lower_id - 1 - size; + } + + } else if (tag == LFSR_TAG_GROW) { + // TODO what is this id check doing? + if (id_ >= id) { + // decrease weight when deleting + alt = LFSR_TAG_ALT(B, GT, 0); + weight = upper_id - lower_id - 1 + size; + } + + } else if (tag == LFSR_TAG_SHRINK) { + // TODO what is this id check doing? + if (id_ >= id) { + // decrease weight when deleting + alt = LFSR_TAG_ALT(B, GT, 0); + weight = upper_id - lower_id - 1 - size; } } else if (id_ > id @@ -2149,7 +2264,7 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, if (lfsr_tag_isrm(tag)) { // hide our tag during removes alt = LFSR_TAG_ALT(B, GT, 0); - weight = upper_id - lower_id; + weight = upper_id - lower_id - 1; } else { // split greater than alt = LFSR_TAG_ALT(B, GT, tag); @@ -2179,18 +2294,36 @@ static int lfsr_rbyd_append(lfs_t *lfs, lfsr_rbyd_t *rbyd_, } leaf:; - // write the tag - err = lfsr_rbyd_progtag(lfs, rbyd_, tag, id, size, &rbyd_->crc); - if (err) { - return err; - } - - // don't forget the actual data! - err = lfsr_rbyd_prog(lfs, rbyd_, buffer, size, &rbyd_->crc); - if (err) { - return err; + // write the actual tag + // + // note we always need something after the alts! without something between + // alts we may not be able to find the trunk of our tree + if (tag == LFSR_TAG_RM) { + // TODO note this is tricky, we normally expect tags between alts to + // find the trunk, should we have a test for this explicitly? + // write a grow/shrink + err = lfsr_rbyd_progtag(lfs, rbyd_, + LFSR_TAG_SHRINK, id, size, &rbyd_->crc); + if (err) { + return err; + } + } else { + // write the tag + err = lfsr_rbyd_progtag(lfs, rbyd_, tag, id, size, &rbyd_->crc); + if (err) { + return err; + } + + if (lfsr_tag_hasdata(tag)) { + // don't forget the actual data! + err = lfsr_rbyd_prog(lfs, rbyd_, buffer, size, &rbyd_->crc); + if (err) { + return err; + } + } } + // TODO move this above? // if we're inserting or deleting, adjust the id count, indirectly // shifting all greater ids by one // @@ -2199,7 +2332,11 @@ leaf:; if (lfsr_tag_ismk(tag)) { rbyd_->weight += 1; } else if (tag == LFSR_TAG_RM) { - rbyd_->weight -= 1; + rbyd_->weight -= size; + } else if (tag == LFSR_TAG_GROW) { + rbyd_->weight += size; + } else if (tag == LFSR_TAG_SHRINK) { + rbyd_->weight -= size; } return 0; @@ -2232,7 +2369,7 @@ int lfsr_rbyd_commit(lfs_t *lfs, lfsr_rbyd_t *rbyd, // append each tag to the tree for (const struct lfsr_attr *attr = attrs; attr; attr = attr->next) { int err = lfsr_rbyd_append(lfs, &rbyd_, - attr->tag, attr->id, attr->buffer, attr->size); + attr->tag, attr->id, attr->u.data.buffer, attr->u.data.size); if (err) { return err; } diff --git a/scripts/dbgrbyd.py b/scripts/dbgrbyd.py index 060b14b4..96030fb1 100755 --- a/scripts/dbgrbyd.py +++ b/scripts/dbgrbyd.py @@ -52,33 +52,36 @@ def xxd(data, width=16, crc=False): b if b >= ' ' and b <= '~' else '.' for b in map(chr, data[i:i+width]))) -def tagrepr(tag, id, size, off=None): +def tagrepr(tag, id, w, size, off=None): if (tag & ~0x3f0) == 0x0400: - return 'mk%s id%d %d' % ( + return 'mk%s id%d%s %d' % ( 'branch' if ((tag & 0x3f0) >> 4) == 0x00 else 'reg' if ((tag & 0x3f0) >> 4) == 0x01 else 'dir' if ((tag & 0x3f0) >> 4) == 0x02 else ' 0x%02x' % ((tag & 0x3f0) >> 4), id, + ' w%d' % w if w is not None else '', size) - elif (tag & ~0x3f0) == 0x0402: - return 'rm%s id%d%s' % ( - ' 0x%02x' % ((tag & 0x3f0) >> 4) - if ((tag & 0x3f0) >> 4) else '', - id, - ' %d' % size if size else '') elif (tag & ~0xff2) == 0x2000: return '%suattr 0x%02x%s%s' % ( 'rm' if tag & 0x2 else '', (tag & 0xff0) >> 4, ' id%d' % id if id != -1 else '', ' %d' % size if not tag & 0x2 or size else '') - elif (tag & ~0x10) == 0x24: + elif tag == 0x0006: + return 'grow id%d w%d' % ( + id, + size) + elif tag == 0x0016: + return 'shrink id%d w%d' % ( + id, + size) + elif (tag & ~0x10) == 0x0004: return 'crc%x%s %d' % ( 1 if tag & 0x10 else 0, ' 0x%02x' % id if id != -1 else '', size) - elif tag == 0x44: + elif tag == 0x0024: return 'fcrc%s %d' % ( ' 0x%02x' % id if id != -1 else '', size) @@ -107,7 +110,7 @@ def show_log(block_size, data, rev, off, *, j = j_ v, tag, id, size, delta = fromtag(data[j_:]) j_ += delta - if not tag & 0x8: + if (tag & 0xe) <= 0x4: j_ += size if tag & 0x8: @@ -161,64 +164,88 @@ def show_log(block_size, data, rev, off, *, # preprocess lifetimes if args.get('lifetimes'): - weight = 0 - max_weight = 0 - lifetimes = {} - ids = [] - ids_i = 0 + def index(weights, id): + for i, w in enumerate(weights): + if id < w: + return i, id + id -= w + return len(weights)-1, -1 + + def ranges(weights): + return zip( + it.chain([0], it.accumulate(weights)), + it.accumulate(weights)) + + weights = [0] + grow = None + colors = [''] + colors_i = 0 + lifetimes = [(0, 0, -1, weights.copy(), colors.copy())] + j_ = 4 while j_ < (block_size if args.get('all') else off): j = j_ v, tag, id, size, delta = fromtag(data[j_:]) j_ += delta - if not tag & 0x8: + if (tag & 0xe) <= 0x4: j_ += size - if (tag & ~0x3f0) == 0x0400: - weight += 1 - max_weight = max(max_weight, weight) - ids.insert(id, COLORS[ids_i % len(COLORS)]) - ids_i += 1 - lifetimes[j] = ( - ''.join( - '%s%s%s' % ( - '\x1b[%sm' % ids[id_] if color else '', - '.' if id_ == id - else '\ ' if id_ > id - else '| ', - '\x1b[m' if color else '') - for id_ in range(weight)) - + ' ', - weight) - elif ((tag & ~0x3f0) == 0x0402 and id < len(ids)): - lifetimes[j] = ( - ''.join( - '%s%s%s' % ( - '\x1b[%sm' % ids[id_] if color else '', - '\'' if id_ == id - else '/ ' if id_ > id - else '| ', - '\x1b[m' if color else '') - for id_ in range(weight)) - + ' ', - weight) - weight -= 1 - ids.pop(id) - else: - lifetimes[j] = ( - ''.join( - '%s%s%s' % ( - '\x1b[%sm' % ids[id_] if color else '', - '* ' if not tag & 0x8 - and id_ == id - else '| ', - '\x1b[m' if color else '') - for id_ in range(weight)), - weight) + # note these slices are also copying the arrays + if grow is not None: + if (tag & ~0x3f0) == 0x0400 and id == grow[1]: + i, p = index(weights, id) + weights[i:i+1] = [p+1, weights[i]-(p+1)] + colors[i:i+1] = [COLORS[colors_i % len(COLORS)], colors[i]] + colors_i += 1 + lifetimes.append((grow[0], + +1, id, weights[:-1], colors[:-1])) + grow = None + elif not tag & 0x8: + lifetimes.append((grow[0], + 0, grow[1], weights[:-1], colors[:-1])) + grow = None + + if tag == 0x0006: + i, _ = index(weights, id) + weights[i] += size + grow = j, id + elif tag == 0x0016: + i, _ = index(weights, id) + if weights[i] == size and len(weights) > 1: + lifetimes.append((j, + -1, id, weights[:-1], colors[:-1])) + weights[i:i+1] = [] + colors[i:i+1] = [] + else: + weights[i] = max(weights[i] - size, 0) + lifetimes.append((j, + 0, id-size, weights[:-1], colors[:-1])) + elif not tag & 0x8: + lifetimes.append((j, + 0, id, weights[:-1], colors[:-1])) + + lifetimes_j = [j for j, _, _, _, _ in lifetimes] + width = 2*max(len(weights) for _, _, _, weights, _ in lifetimes) def lifetimerepr(j): - lifetime, weight = lifetimes.get(j, ('', 0)) - return '%s%*s' % (lifetime, 2*(max_weight-weight), '') + j_, g, id, weights, colors = lifetimes[ + bisect.bisect(lifetimes_j, j)-1] + if j != j_: + g, id = 0, -1 + + return '%s%*s' % ( + ''.join( + '%s%s%s' % ( + '\x1b[%sm' % c if color else '', + '.' if g > 0 and id >= a and id < b + else '\\ ' if g > 0 and id < a + else '\'' if g < 0 and id >= a and id < b + else '/ ' if g < 0 and id < a + else '* ' if not tag & 0x8 and id >= a and id < b + else '| ', + '\x1b[m' if color else '') + for (a, b), c in zip(ranges(weights), colors)), + width - 2*len(weights) + (1 if g else 0), '') # print header print('%-8s %s%-22s %s' % ( @@ -245,8 +272,8 @@ def show_log(block_size, data, rev, off, *, crc = crc32c(data[j_:j_+delta], crc) j_ += delta - if not tag & 0x8: - if (tag & ~0x10) != 0x24: + if (tag & 0xe) <= 0x4: + if (tag & ~0x10) != 0x04: crc = crc32c(data[j_:j_+size], crc) # found a crc? else: @@ -263,11 +290,11 @@ def show_log(block_size, data, rev, off, *, lifetimerepr(j) if args.get('lifetimes') else '', '\x1b[90m' if color and j >= off else '', '%-22s%s' % ( - tagrepr(tag, id, size, j), + tagrepr(tag, id, None, size, j), ' %s' % next(xxd( data[j+delta:j+delta+min(size, 8)], 8), '') if not args.get('no_truncate') - and not tag & 0x8 else ''), + and (tag & 0xe) <= 0x4 else ''), '\x1b[m' if color and j >= off else '', ' (%s)' % ', '.join(notes) if notes else ' %s' % jumprepr(j) @@ -297,12 +324,12 @@ def show_log(block_size, data, rev, off, *, data[j+delta+i*4:j+delta+min(i*4+4,size)] .ljust(4, b'\0')) for i in range(min(m.ceil(size/4), 3)))[:23] - if not tag & 0x8 else ''), + if (tag & 0xe) <= 0x4 else ''), crc, popc(crc) & 1, '\x1b[m' if color and j >= off else '')) - if not tag & 0x8: + if (tag & 0xe) <= 0x4: # show on-disk encoding of data if args.get('raw') or args.get('no_truncate'): for o, line in enumerate(xxd(data[j+delta:j+delta+size])): @@ -372,10 +399,11 @@ def show_tree(block_size, data, rev, trunk, weight, *, else: tag_ = alt id_ = upper-1 + w_ = id_-lower done = (id_, tag_) < (id, tag) or tag_ & 2 - return done, tag_, id_, j, delta, jump, path + return done, tag_, id_, w_, j, delta, jump, path # precompute tree if args.get('tree'): @@ -384,7 +412,7 @@ def show_tree(block_size, data, rev, trunk, weight, *, tag, id = 0, -1 while True: - done, tag, id, j, delta, size, path = lookup(tag+0x10, id) + done, tag, id, w, j, delta, size, path = lookup(tag+0x10, id) # found end of tree? if done: break @@ -481,7 +509,7 @@ def show_tree(block_size, data, rev, trunk, weight, *, tag, id = 0, -1 while True: - done, tag, id, j, delta, size, path = lookup(tag+0x10, id) + done, tag, id, w, j, delta, size, path = lookup(tag+0x10, id) # found end of tree? if done: break @@ -491,11 +519,11 @@ def show_tree(block_size, data, rev, trunk, weight, *, j, treerepr(j) if args.get('tree') else '', '%-22s%s' % ( - tagrepr(tag, id, size, j), + tagrepr(tag, id, w, size, j), ' %s' % next(xxd( data[j+delta:j+delta+min(size, 8)], 8), '') if not args.get('no_truncate') - and not tag & 0x8 else ''))) + and (tag & 0xe) <= 0x4 else ''))) if args.get('raw'): # show on-disk encoding of tags @@ -517,9 +545,9 @@ def show_tree(block_size, data, rev, trunk, weight, *, data[j+delta+i*4:j+delta+min(i*4+4,size)] .ljust(4, b'\0')) for i in range(min(m.ceil(size/4), 3)))[:23] - if not tag & 0x8 else ''))) + if (tag & 0xe) <= 0x4 else ''))) - if not tag & 0x8: + if (tag & 0xe) <= 0x4: # show on-disk encoding of data if args.get('raw') or args.get('no_truncate'): for o, line in enumerate(xxd(data[j+delta:j+delta+size])): @@ -571,18 +599,21 @@ def main(disk, block_size=None, block1=0, block2=None, *, crc = crc32c(data[j_:j_+delta], crc) j_ += delta - if not wastrunk and (tag & 0xc) != 0x4: + # find trunk + if not wastrunk and (tag & 0xe) != 0x4: trunk_ = j_ - delta - wastrunk = True + wastrunk = not not tag & 0x8 - if not tag & 0x8: - if (tag & ~0x10) != 0x24: + # keep track of weight + if tag == 0x0006: + weight_ += size + elif tag == 0x0016: + weight_ = max(weight_ - size, 0) + + # take care of crcs + if (tag & 0xe) <= 0x4: + if (tag & ~0x10) != 0x04: crc = crc32c(data[j_:j_+size], crc) - # keep track of weight - if (tag & ~0x3f0) == 0x0400: - weight_ += 1 - elif (tag & ~0x3f0) == 0x0402: - weight_ = max(weight_ - 1, 0) # found a crc? else: crc_, = struct.unpack(' 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; @@ -167,21 +167,21 @@ code = ''' LFSR_ATTR(UATTR(1), -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; @@ -191,31 +191,31 @@ code = ''' LFSR_ATTR(UATTR(2), -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; @@ -225,31 +225,31 @@ code = ''' LFSR_ATTR(UATTR(1), -1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_lookup] @@ -279,11 +279,11 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with one attribute rbyd = init_rbyd; @@ -292,21 +292,21 @@ code = ''' LFSR_ATTR(UATTR(1), -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes rbyd = init_rbyd; @@ -317,31 +317,31 @@ code = ''' LFSR_ATTR(UATTR(2), -1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes, in the other direction rbyd = init_rbyd; @@ -352,31 +352,31 @@ code = ''' LFSR_ATTR(UATTR(1), -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_get] @@ -600,12 +600,12 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); @@ -622,12 +622,12 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); @@ -667,12 +667,12 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); @@ -690,12 +690,12 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); @@ -737,17 +737,17 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); @@ -767,17 +767,17 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); @@ -820,17 +820,17 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); @@ -851,17 +851,17 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); @@ -882,17 +882,17 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); @@ -913,17 +913,17 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); @@ -968,22 +968,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1006,22 +1006,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1044,22 +1044,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1082,22 +1082,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1142,22 +1142,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1180,22 +1180,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1218,22 +1218,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1256,22 +1256,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1319,22 +1319,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1360,22 +1360,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1399,22 +1399,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1438,22 +1438,22 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); @@ -1503,27 +1503,27 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); @@ -1551,27 +1551,27 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); @@ -1597,27 +1597,27 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); @@ -1643,27 +1643,27 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); @@ -1714,27 +1714,27 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); @@ -1763,27 +1763,27 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); @@ -1812,27 +1812,27 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); @@ -1885,32 +1885,32 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(6), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); assert(id_ == -1); assert(size_ == 4); @@ -1939,32 +1939,32 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(6), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); assert(id_ == -1); assert(size_ == 4); @@ -1993,32 +1993,32 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(3)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(5)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(6), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(6)); assert(id_ == -1); assert(size_ == 4); @@ -2065,7 +2065,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -2086,7 +2086,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(j+1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); assert(size_ == 4); @@ -2170,7 +2170,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -2186,7 +2186,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(j+1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); assert(size_ == 4); @@ -2258,31 +2258,31 @@ code = ''' LFSR_ATTR(UATTR(2), -1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -2292,31 +2292,31 @@ code = ''' LFSR_ATTR(UATTR(1), -1, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_traverse] @@ -2351,31 +2351,31 @@ code = ''' LFSR_ATTR(UATTR(2), -1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -2386,31 +2386,31 @@ code = ''' LFSR_ATTR(UATTR(1), -1, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_traverse_permutations] @@ -2451,7 +2451,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -2475,13 +2475,13 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); assert(size_ == 4); } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // next permutation using Heap's algorithm if (stack[i] < i) { @@ -2543,7 +2543,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -2563,13 +2563,13 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); assert(size_ == 4); } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // next permutation using Heap's algorithm if (stack[i] < i) { @@ -2652,7 +2652,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -2675,7 +2675,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(j+1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(j+1)); assert(id_ == -1); assert(size_ == 6); @@ -2780,7 +2780,7 @@ code = ''' : (ORDER == 1) ? (uint8_t)(((lfs_size_t)-1) - i) : (uint8_t)TEST_PRNG(&prng); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(x), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(x)); assert(id_ == -1); assert(size_ == 4); @@ -2820,15 +2820,15 @@ code = ''' LFSR_ATTR(RMUATTR(1), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes, remove the first one rbyd = init_rbyd; @@ -2840,31 +2840,31 @@ code = ''' LFSR_ATTR(RMUATTR(1), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes, remove the second one rbyd = init_rbyd; @@ -2876,25 +2876,25 @@ code = ''' LFSR_ATTR(RMUATTR(2), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -2942,7 +2942,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -2964,7 +2964,7 @@ code = ''' // try removing each tag for (unsigned j = 0; j < N; j++) { // print what we are removing to help debugging - printf("--- remove: %d ---\n", j+1); + printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -2980,7 +2980,7 @@ code = ''' for (unsigned k = 0; k < N; k++) { int err = lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(k+1), -1, - &tag_, &id_, &off_, &size_); + &tag_, &id_, NULL, &off_, &size_); assert(!err || err == LFS_ERR_NOENT); if (k == j) { if (j == N-1) { @@ -2999,7 +2999,7 @@ code = ''' } // try appending the tag back to make sure things still work - printf("--- append: %d ---\n", j+1); + printf("--- append: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(UATTR(j+1), -1, "\xaa\xaa\xaa\xaa\xaa\xaa", 6, NULL)) => 0; @@ -3009,7 +3009,7 @@ code = ''' for (unsigned k = 0; k < N; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(k+1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; if (k == j) { assert(tag_ == LFSR_TAG_UATTR(k+1)); assert(id_ == -1); @@ -3102,7 +3102,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -3124,7 +3124,7 @@ code = ''' // try removing each tag for (unsigned j = 0; j < N; j++) { // print what we are removing to help debugging - printf("--- remove: %d ---\n", j+1); + printf("--- remove: %d ---\n", j); rbyd = backup_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -3143,7 +3143,7 @@ code = ''' id_ = -1; for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; if (k >= j) { assert(tag_ == LFSR_TAG_UATTR(k+1+1)); assert(id_ == -1); @@ -3156,7 +3156,7 @@ code = ''' } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; } // cleanup @@ -3211,128 +3211,128 @@ code = ''' LFSR_ATTR(UATTR(4), -1, "\xdd\xdd\xdd\xdd", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(1), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(3), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(5), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_remove_again] @@ -3373,205 +3373,205 @@ code = ''' LFSR_ATTR(RMUATTR(5), -1, NULL, 0, NULL)))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // try to remove tags that aren't there, this should do nothing lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(1), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(3), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(5), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // try to remove the tags again, just to make sure (keep in mind // these removes still commit to the rbyd) lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(1), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(3), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(RMUATTR(5), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // one last fetch to make sure nothing was broken lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(2)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(4), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(4)); assert(id_ == -1); assert(size_ == 4); lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(5), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_remove_all] @@ -3604,15 +3604,15 @@ code = ''' LFSR_ATTR(RMUATTR(1), -1, NULL, 0, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes, remove both rbyd = init_rbyd; @@ -3625,15 +3625,15 @@ code = ''' LFSR_ATTR(RMUATTR(2), -1, NULL, 0, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // commit with two attributes, remove both in the other order rbyd = init_rbyd; @@ -3646,15 +3646,15 @@ code = ''' LFSR_ATTR(RMUATTR(1), -1, NULL, 0, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' # NOTE if we separate physical/logical block sizes we may be able to @@ -3718,7 +3718,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -3739,7 +3739,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(j+1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; } // try resuming from all tags being removed @@ -3749,13 +3749,13 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == -1); assert(size_ == 6); for (unsigned j = 1; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(j+1), -1, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; } // keep track of the worst size @@ -4332,7 +4332,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -4448,7 +4448,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -4544,39 +4544,39 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -4586,39 +4586,39 @@ code = ''' LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_create_traverse] @@ -4654,39 +4654,39 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -4697,39 +4697,39 @@ code = ''' LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_create_traverse_permutations] @@ -4779,7 +4779,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -4812,7 +4812,7 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == j); assert(size_ == 4); @@ -4821,7 +4821,7 @@ code = ''' assert(memcmp(buffer, names[j % 6], 4) == 0); } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // next permutation using Heap's algorithm if (stack[i] < i) { @@ -4892,7 +4892,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -4920,7 +4920,7 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == j); assert(size_ == 4); @@ -4929,7 +4929,7 @@ code = ''' assert(memcmp(buffer, names[j % 6], 4) == 0); } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // next permutation using Heap's algorithm if (stack[i] < i) { @@ -5017,7 +5017,7 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, x, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == x); assert(size_ == 4); @@ -5568,7 +5568,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -5698,7 +5698,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -5807,67 +5807,67 @@ code = ''' LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -5879,67 +5879,67 @@ code = ''' LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL))))) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_multi_mixed_traverse] @@ -5979,67 +5979,67 @@ code = ''' LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // also try the other direction rbyd = init_rbyd; @@ -6054,67 +6054,67 @@ code = ''' LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL)) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 0); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xaa\xaa\xaa\xaa", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 0); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xaa\xaa", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == 1); assert(size_ == 4); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; assert(memcmp(buffer, "\xbb\xbb\xbb\xbb", 4) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(1)); assert(id_ == 1); assert(size_ == 2); lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 2; assert(memcmp(buffer, "\xbb\xbb", 2) == 0); lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; ''' [cases.test_rbyd_mixed_traverse_permutations] @@ -6165,7 +6165,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -6206,7 +6206,7 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == j); assert(size_ == 4); @@ -6216,7 +6216,7 @@ code = ''' for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == j); assert(size_ == 2); @@ -6226,7 +6226,7 @@ code = ''' } } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // next permutation using Heap's algorithm if (stack[i] < i) { @@ -6298,7 +6298,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -6333,7 +6333,7 @@ code = ''' id_ = -1; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == j); assert(size_ == 4); @@ -6343,7 +6343,7 @@ code = ''' for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == j); assert(size_ == 2); @@ -6353,7 +6353,7 @@ code = ''' } } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; // next permutation using Heap's algorithm if (stack[i] < i) { @@ -6448,7 +6448,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -6573,7 +6573,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -6629,7 +6629,7 @@ code = ''' for (unsigned u = 0; u < M; u++) { int err = lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(u+1), k, - &tag_, &id_, &off_, &size_); + &tag_, &id_, NULL, &off_, &size_); assert(!err || err == LFS_ERR_NOENT); if (k == j/M && u == j%M) { if (u == M-1 && k == N-1) { @@ -6671,7 +6671,7 @@ code = ''' for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(u+1), k, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; if (k == j/M && u == j%M) { assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == k); @@ -6802,7 +6802,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -6820,7 +6820,7 @@ code = ''' NULL)) => 0; } - // check that all tags have been removed + // check that all tags have been removed lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (unsigned j = 0; j < N; j++) { lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j, buffer, 4) => 4; @@ -6949,14 +6949,14 @@ code = ''' lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; for (uint16_t x = 0; x < rbyd.weight; x++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, x, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == x); assert(size_ == 4); for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(u+1), x, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == x); assert(size_ == 2); @@ -6992,7 +6992,7 @@ code = ''' LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; @@ -7012,7 +7012,7 @@ code = ''' LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; @@ -7033,7 +7033,7 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 2, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 2, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; @@ -7056,7 +7056,7 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; @@ -7079,7 +7079,7 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; @@ -7122,7 +7122,7 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -7158,7 +7158,7 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 1); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -7196,7 +7196,7 @@ code = ''' LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 2, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 2, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) => 4; @@ -7245,7 +7245,7 @@ code = ''' LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -7295,7 +7295,7 @@ code = ''' LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 1, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 1, NULL, 1, NULL)) => 0; assert(rbyd.weight == 2); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -7385,7 +7385,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -7417,7 +7417,7 @@ code = ''' // try deleting each id for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging - printf("--- delete: %d ---\n", j+1); + printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -7426,7 +7426,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, j, NULL, 1, NULL)) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -7444,7 +7444,7 @@ code = ''' => LFS_ERR_NOENT; // try recreating the id to make sure things still work - printf("--- create: %d ---\n", j+1); + printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(MKREG, j, names[j % 6], 6, NULL)) => 0; assert(rbyd.weight == N); @@ -7554,7 +7554,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -7592,7 +7592,7 @@ code = ''' // try deleting each id for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging - printf("--- delete: %d ---\n", j+1); + printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -7601,7 +7601,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, j, NULL, 1, NULL)) => 0; assert(rbyd.weight == N-1); lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, @@ -7631,7 +7631,7 @@ code = ''' => LFS_ERR_NOENT; // try recreating the id to make sure things still work - printf("--- create: %d ---\n", j+1); + printf("--- create: %d ---\n", j); lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(MKREG, j, names[j % 6], 6, NULL)) => 0; for (unsigned u = 0; u < M; u++) { @@ -7759,7 +7759,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -7791,7 +7791,7 @@ code = ''' // try deleting each id for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging - printf("--- delete: %d ---\n", j+1); + printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -7800,7 +7800,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, j, NULL, 1, NULL)) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7812,7 +7812,7 @@ code = ''' id_ = -1; for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == k); assert(size_ == 4); @@ -7826,7 +7826,7 @@ code = ''' } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; } // cleanup @@ -7904,7 +7904,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -7942,7 +7942,7 @@ code = ''' // try deleting each id for (unsigned j = 0; j < N; j++) { // print what we are deleting to help debugging - printf("--- delete: %d ---\n", j+1); + printf("--- delete: %d ---\n", j); rbyd = backup_rbyd; lfs_bd_erase(&lfs, rbyd.block) => 0; @@ -7951,7 +7951,7 @@ code = ''' lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, j, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, j, NULL, 1, NULL)) => 0; assert(rbyd.weight == N-1); // try traversing over the tags @@ -7963,7 +7963,7 @@ code = ''' id_ = -1; for (unsigned k = 0; k < N-1; k++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_MKREG); assert(id_ == k); assert(size_ == 4); @@ -7977,7 +7977,7 @@ code = ''' for (unsigned u = 0; u < M; u++) { lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => 0; + &tag_, &id_, NULL, &off_, &size_) => 0; assert(tag_ == LFSR_TAG_UATTR(u+1)); assert(id_ == k); assert(size_ == 2); @@ -7992,7 +7992,7 @@ code = ''' } lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, - &tag_, &id_, &off_, &size_) => LFS_ERR_NOENT; + &tag_, &id_, NULL, &off_, &size_) => LFS_ERR_NOENT; } // cleanup @@ -8018,6 +8018,8 @@ code = ''' } ''' +# Note, "delete_all" is a weird state for rbyd trees to be in, since they +# don't really have a trunk at this point [cases.test_rbyd_delete_all] in = 'lfs.c' code = ''' @@ -8042,7 +8044,7 @@ code = ''' lfsr_rbyd_commit(&lfs, &rbyd, LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8060,8 +8062,8 @@ code = ''' LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; + LFSR_ATTR(RM, 0, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8079,8 +8081,8 @@ code = ''' LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 1, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; + LFSR_ATTR(RM, 1, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8099,9 +8101,9 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; + LFSR_ATTR(RM, 0, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8120,9 +8122,9 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, NULL)))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 2, NULL, 0, - LFSR_ATTR(RM, 1, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; + LFSR_ATTR(RM, 2, NULL, 1, + LFSR_ATTR(RM, 1, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8159,7 +8161,7 @@ code = ''' LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, NULL))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, 0, NULL, 1, NULL)) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8179,8 +8181,8 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; + LFSR_ATTR(RM, 0, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8200,8 +8202,8 @@ code = ''' LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, NULL))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 1, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL))) => 0; + LFSR_ATTR(RM, 1, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8223,9 +8225,9 @@ code = ''' LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 0, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; + LFSR_ATTR(RM, 0, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8247,9 +8249,9 @@ code = ''' LFSR_ATTR(MKREG, 2, "\xcc\xcc\xcc\xcc", 4, LFSR_ATTR(UATTR(1), 2, "\xcc\xcc", 2, NULL))))))) => 0; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, 2, NULL, 0, - LFSR_ATTR(RM, 1, NULL, 0, - LFSR_ATTR(RM, 0, NULL, 0, NULL)))) => 0; + LFSR_ATTR(RM, 2, NULL, 1, + LFSR_ATTR(RM, 1, NULL, 1, + LFSR_ATTR(RM, 0, NULL, 1, NULL)))) => 0; assert(rbyd.weight == 0); lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, 0, buffer, 4) @@ -8328,7 +8330,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -8351,7 +8353,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, id, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, id, NULL, 1, NULL)) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8490,7 +8492,7 @@ code = ''' if (j > 0) { printf(", "); } - printf("%d", perm[j]+1); + printf("%d", perm[j]); } printf("] ---\n"); @@ -8513,7 +8515,7 @@ code = ''' lfs_size_t rbyd_weight_before = rbyd.weight; lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, id, NULL, 0, NULL)) => 0; + LFSR_ATTR(RM, id, NULL, 1, NULL)) => 0; assert(rbyd.weight == rbyd_weight_before-1); } @@ -8674,7 +8676,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, id, NULL, 0, + LFSR_ATTR(RM, id, NULL, 1, NULL)) => 0; } } @@ -8764,7 +8766,7 @@ code = ''' count -= 1; // update our rbyd lfsr_rbyd_commit(&lfs, &rbyd, - LFSR_ATTR(RM, id, NULL, 0, + LFSR_ATTR(RM, id, NULL, 1, NULL)) => 0; } } @@ -8775,3 +8777,2450 @@ code = ''' assert(worst_size <= N*12*(2*lfs_nlog2(N)+1)+1); } ''' + + +# Test rbyd weights +[cases.test_rbyd_grow] +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + + // make id0 with weight w1 + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, NULL)) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + + // make id2 with weight w2 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(GROW, 1, NULL, 1, + NULL))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + + // make id5 with weight w3 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 3, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(GROW, 3, NULL, 2, + NULL))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + + // make id9 with weight w4 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 6, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(GROW, 6, NULL, 3, + NULL))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + + // make id14 with weight w5 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 10, "\xee\xee\xee\xee", 4, + LFSR_ATTR(GROW, 10, NULL, 4, + NULL))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); +''' + +[cases.test_rbyd_grow_traverse] +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + // make id0 with weight w1 + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + // make id2 with weight w2 + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(GROW, 1, NULL, 1, + // make id5 with weight w3 + LFSR_ATTR(MKREG, 3, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(GROW, 3, NULL, 2, + // make id9 with weight w4 + LFSR_ATTR(MKREG, 6, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(GROW, 6, NULL, 3, + // make id14 with weight w5 + LFSR_ATTR(MKREG, 10, "\xee\xee\xee\xee", 4, + LFSR_ATTR(GROW, 10, NULL, 4, + NULL)))))))))) => 0; + + // traverse, finding tags and weights + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => LFS_ERR_NOENT; +''' + +[cases.test_rbyd_grow_permutations] +defines.N = 'range(1, 8)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][4] = { + "\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee", + "\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[4]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // test the given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(GROW, id*W, NULL, W-1, + NULL))) => 0; + } + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + for (unsigned j = 0; j < N; j++) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == j*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, buffer, 4) => 4; + assert(memcmp(buffer, names[j % 6], 4) == 0); + } + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +''' + +[cases.test_rbyd_grow_traverse_permutations] +defines.N = 'range(1, 8)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][4] = { + "\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee", + "\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[4]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // test the given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(GROW, id*W, NULL, W-1, + NULL))) => 0; + } + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + // try traversing all tags + tag_ = 0; + id_ = -1; + for (unsigned j = 0; j < N; j++) { + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == j*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[j % 6], 4) == 0); + } + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +''' + +# Weights mixed with attributes +[cases.test_rbyd_mixed_grow] +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + + // make id0 with weight w1 + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(UATTR(3), -1, "unrelated", 9, + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, + LFSR_ATTR(UATTR(2), 0, "\xaa\xaa", 2, NULL))))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + + // make id2 with weight w2 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, + LFSR_ATTR(GROW, 1, NULL, 1, + LFSR_ATTR(UATTR(2), 2, "\xbb\xbb", 2, + NULL))))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + + // make id5 with weight w3 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 3, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(UATTR(1), 3, "\xcc\xcc", 2, + LFSR_ATTR(GROW, 3, NULL, 2, + LFSR_ATTR(UATTR(2), 5, "\xcc\xcc", 2, + NULL))))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + + // make id9 with weight w4 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 6, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(UATTR(1), 6, "\xdd\xdd", 2, + LFSR_ATTR(GROW, 6, NULL, 3, + LFSR_ATTR(UATTR(2), 9, "\xdd\xdd", 2, + NULL))))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + + // make id14 with weight w5 + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, 10, "\xee\xee\xee\xee", 4, + LFSR_ATTR(UATTR(1), 10, "\xee\xee", 2, + LFSR_ATTR(GROW, 10, NULL, 4, + LFSR_ATTR(UATTR(2), 14, "\xee\xee", 2, + NULL))))) => 0; + + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 0, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 2, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 5, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 9, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), 14, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); +''' + +[cases.test_rbyd_mixed_grow_traverse] +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(UATTR(3), -1, "unrelated", 9, + // make id0 with weight w1 + LFSR_ATTR(MKREG, 0, "\xaa\xaa\xaa\xaa", 4, + LFSR_ATTR(UATTR(1), 0, "\xaa\xaa", 2, + LFSR_ATTR(UATTR(2), 0, "\xaa\xaa", 2, + // make id2 with weight w2 + LFSR_ATTR(MKREG, 1, "\xbb\xbb\xbb\xbb", 4, + LFSR_ATTR(UATTR(1), 1, "\xbb\xbb", 2, + LFSR_ATTR(GROW, 1, NULL, 1, + LFSR_ATTR(UATTR(2), 2, "\xbb\xbb", 2, + // make id5 with weight w3 + LFSR_ATTR(MKREG, 3, "\xcc\xcc\xcc\xcc", 4, + LFSR_ATTR(UATTR(1), 3, "\xcc\xcc", 2, + LFSR_ATTR(GROW, 3, NULL, 2, + LFSR_ATTR(UATTR(2), 5, "\xcc\xcc", 2, + // make id9 with weight w4 + LFSR_ATTR(MKREG, 6, "\xdd\xdd\xdd\xdd", 4, + LFSR_ATTR(UATTR(1), 6, "\xdd\xdd", 2, + LFSR_ATTR(GROW, 6, NULL, 3, + LFSR_ATTR(UATTR(2), 9, "\xdd\xdd", 2, + // make id14 with weight w5 + LFSR_ATTR(MKREG, 10, "\xee\xee\xee\xee", 4, + LFSR_ATTR(UATTR(1), 10, "\xee\xee", 2, + LFSR_ATTR(GROW, 10, NULL, 4, + LFSR_ATTR(UATTR(2), 14, "\xee\xee", 2, + NULL))))))))))))))))))))) => 0; + + // traverse, finding tags and weights + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(0), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 0); + assert(weight_ == 1); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 0); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 2); + assert(weight_ == 2); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 2); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 5); + assert(weight_ == 3); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 5); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 9); + assert(weight_ == 4); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 9); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == 14); + assert(weight_ == 5); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == 14); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => LFS_ERR_NOENT; +''' + +[cases.test_rbyd_mixed_grow_permutations] +defines.N = 'range(1, 8)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][4] = { + "\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee", + "\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[4]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // test the given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(UATTR(3), -1, "unrelated", 9, NULL)) => 0; + + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(UATTR(1), id*W, names[perm[j] % 6], 2, + LFSR_ATTR(GROW, id*W, NULL, W-1, + LFSR_ATTR(UATTR(2), id*W+W-1, names[perm[j] % 6], 2, + NULL))))) => 0; + } + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(3), -1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + for (unsigned j = 0; j < N; j++) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == j*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), j*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == j*W+W-1); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(2), j*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == j*W+W-1); + assert(weight_ == 0); + assert(size_ == 2); + + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_MKREG, j*W+W-1, buffer, 4) => 4; + assert(memcmp(buffer, names[j % 6], 4) == 0); + } + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +''' + +[cases.test_rbyd_mixed_grow_traverse_permutations] +defines.N = 'range(1, 8)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][4] = { + "\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee", + "\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[4]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // test the given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(UATTR(3), -1, "unrelated", 9, NULL)) => 0; + + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(UATTR(1), id*W, names[perm[j] % 6], 2, + LFSR_ATTR(GROW, id*W, NULL, W-1, + LFSR_ATTR(UATTR(2), id*W+W-1, names[perm[j] % 6], 2, + NULL))))) => 0; + } + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + // try traversing all tags + tag_ = 0; + id_ = -1; + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(3)); + assert(id_ == -1); + assert(weight_ == 0); + assert(size_ == 9); + for (unsigned j = 0; j < N; j++) { + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == j*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[j % 6], 4) == 0); + + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == j*W+W-1); + assert(weight_ == 0); + assert(size_ == 2); + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(2)); + assert(id_ == j*W+W-1); + assert(weight_ == 0); + assert(size_ == 2); + } + lfsr_rbyd_lookup(&lfs, &rbyd, lfsr_tag_next(tag_), id_, + &tag_, &id_, &weight_, &off_, &size_) => LFS_ERR_NOENT; + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +''' + +[cases.test_rbyd_sparse_grow_permutations] +defines.N = 'range(1, 7)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][4] = { + "\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee", + "\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[4]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // create given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(GROW, id*W, NULL, W-1, + NULL))) => 0; + } + assert(rbyd.weight == N*W); + + // copy block so we can reset after each remove + lfsr_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(rbyd.off); + lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, + rbyd.block, 0, backup_block, rbyd.off) => 0; + + // try growing each id + for (unsigned j = 0; j < N; j++) { + // print what we are growing to help debugging + printf("--- growing: %d ---\n", j); + + rbyd = backup_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, + rbyd.block, 0, backup_block, rbyd.off) => 0; + lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(GROW, j*W+W-1, NULL, 1, NULL)) => 0; + assert(rbyd.weight == N*W+1); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, + cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W+1); + for (unsigned k = 0; k < N; k++) { + if (k == j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1+1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1+1); + assert(weight_ == W+1); + assert(size_ == 4); + } else if (k > j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1+1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1+1); + assert(weight_ == W); + assert(size_ == 4); + } else { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + } + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[k % 6], 4) == 0); + } + } + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +''' + +[cases.test_rbyd_sparse_shrink_permutations] +defines.N = 'range(1, 7)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][4] = { + "\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee", + "\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[4]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // create given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(GROW, id*W, NULL, W-1, + NULL))) => 0; + } + assert(rbyd.weight == N*W); + + // copy block so we can reset after each remove + lfsr_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(rbyd.off); + lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, + rbyd.block, 0, backup_block, rbyd.off) => 0; + + // try shrinking each id + for (unsigned j = 0; j < N; j++) { + // print what we are shrinking to help debugging + printf("--- shrinking: %d ---\n", j); + + rbyd = backup_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, + rbyd.block, 0, backup_block, rbyd.off) => 0; + lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(SHRINK, j*W+W-1, NULL, 1, NULL)) => 0; + assert(rbyd.weight == N*W-1); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, + cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W-1); + for (unsigned k = 0; k < N; k++) { + if (k == j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1-1); + assert(weight_ == W-1); + assert(size_ == 4); + } else if (k > j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1-1); + assert(weight_ == W); + assert(size_ == 4); + } else { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + } + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[k % 6], 4) == 0); + } + } + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +''' + +[cases.test_rbyd_sparse_delete_permutations] +defines.N = 'range(1, 7)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][6] = { + "\xaa\xaa\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee\xee\xee", + "\xff\xff\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[6]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // create given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(GROW, id*W, NULL, W-1, + NULL))) => 0; + } + assert(rbyd.weight == N*W); + + // copy block so we can reset after each remove + lfsr_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(rbyd.off); + lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, + rbyd.block, 0, backup_block, rbyd.off) => 0; + + // try deleting each id + for (unsigned j = 0; j < N; j++) { + // print what we are deleting to help debugging + printf("--- deleting: %d ---\n", j); + + rbyd = backup_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, + rbyd.block, 0, backup_block, rbyd.off) => 0; + lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RM, j*W+W-1, NULL, W, NULL)) => 0; + assert(rbyd.weight == (N-1)*W); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, + cfg->block_size, NULL) => 0; + assert(rbyd.weight == (N-1)*W); + for (unsigned k = 0; k < N-1; k++) { + if (k >= j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[(k+1) % 6], 4) == 0); + } else { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[k % 6], 4) == 0); + } + } + + // try recreating the id to make sure things still work + printf("--- create: %d ---\n", j); + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, j*W, names[j % 6], 6, + LFSR_ATTR(GROW, j*W, NULL, W-1, + NULL))) => 0; + assert(rbyd.weight == N*W); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, + cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + for (unsigned k = 0; k < N; k++) { + if (k == j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 6); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 6) => 6; + assert(memcmp(buffer, names[k % 6], 6) == 0); + } else { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 6) => 4; + assert(memcmp(buffer, names[k % 6], 4) == 0); + } + } + } + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +''' + +[cases.test_rbyd_sparse_attr_permutations] +defines.N = 'range(1, 7)' +defines.W = 5 +# large progs take too long for now +if = 'PROG_SIZE < 512' +in = 'lfs.c' +code = ''' + lfs_t lfs; + lfs_init(&lfs, cfg) => 0; + + lfsr_rbyd_t init_rbyd = { + .block = 0, + .rev = 1, + .off = 0, + .crc = 0, + .trunk = 0, + .weight = 0, + .erased = true, + }; + lfsr_rbyd_t rbyd; + const uint8_t names[6][4] = { + "\xaa\xaa\xaa\xaa", + "\xbb\xbb\xbb\xbb", + "\xcc\xcc\xcc\xcc", + "\xdd\xdd\xdd\xdd", + "\xee\xee\xee\xee", + "\xff\xff\xff\xff", + }; + lfsr_tag_t tag_; + lfs_ssize_t id_; + lfs_size_t weight_; + lfs_off_t off_; + lfs_size_t size_; + uint8_t buffer[4]; + + // test all permutations of a given size + uint16_t perm[N]; + unsigned stack[N]; + for (uint16_t i = 0; i < N; i++) { + perm[i] = i; + stack[i] = 0; + } + + unsigned i = 1; + while (i < N) { + // print permutation to help debugging + printf("--- permutation: ["); + for (unsigned j = 0; j < N; j++) { + if (j > 0) { + printf(", "); + } + printf("%d", perm[j]); + } + printf("] ---\n"); + + // create given permutation with multiple commits + rbyd = init_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + for (unsigned j = 0; j < N; j++) { + // adjust id based on future insertions + uint16_t id = perm[j]; + for (unsigned k = j+1; k < N; k++) { + if (perm[j] > perm[k]) { + id -= 1; + } + } + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(MKREG, id*W, names[perm[j] % 6], 4, + LFSR_ATTR(GROW, id*W, NULL, W-1, + NULL))) => 0; + } + assert(rbyd.weight == N*W); + + // copy block so we can reset after each remove + lfsr_rbyd_t backup_rbyd = rbyd; + uint8_t *backup_block = malloc(rbyd.off); + lfs_bd_read(&lfs, NULL, &lfs.rcache, rbyd.off, + rbyd.block, 0, backup_block, rbyd.off) => 0; + + // try appending an attr to each id, this should not affect + // weights at all! + for (unsigned j = 0; j < N; j++) { + // print what we are appending to help debugging + printf("--- appending: %d ---\n", j); + + rbyd = backup_rbyd; + lfs_bd_erase(&lfs, rbyd.block) => 0; + lfs_bd_prog(&lfs, &lfs.pcache, &lfs.rcache, false, + rbyd.block, 0, backup_block, rbyd.off) => 0; + lfs_bd_flush(&lfs, &lfs.pcache, &lfs.rcache, false) => 0; + + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(UATTR(1), j*W+W-1, names[j % 6], 2, NULL)) => 0; + assert(rbyd.weight == N*W); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, + cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + for (unsigned k = 0; k < N; k++) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[k % 6], 4) == 0); + + if (k == j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == k*W+W-1); + assert(weight_ == 0); + assert(size_ == 2); + } + } + + // now try removing the attr + printf("--- removing: %d ---\n", j); + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(RMUATTR(1), j*W+W-1, NULL, 0, NULL)) => 0; + assert(rbyd.weight == N*W); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, + cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + for (unsigned k = 0; k < N; k++) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[k % 6], 4) == 0); + + if (k == j) { + lfsr_rbyd_get(&lfs, &rbyd, LFSR_TAG_UATTR(1), k*W+W-1, + buffer, 4) => LFS_ERR_NOENT; + } + } + + // and try putting the attr back just for good measure + printf("--- appending: %d ---\n", j); + lfsr_rbyd_commit(&lfs, &rbyd, + LFSR_ATTR(UATTR(1), j*W+W-1, names[j % 6], 2, NULL)) => 0; + assert(rbyd.weight == N*W); + + lfsr_rbyd_fetch(&lfs, &rbyd, rbyd.block, + cfg->block_size, NULL) => 0; + assert(rbyd.weight == N*W); + for (unsigned k = 0; k < N; k++) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_MKREG, k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_MKREG); + assert(id_ == k*W+W-1); + assert(weight_ == W); + assert(size_ == 4); + + lfsr_rbyd_get(&lfs, &rbyd, tag_, id_, buffer, 4) => 4; + assert(memcmp(buffer, names[k % 6], 4) == 0); + + if (k == j) { + lfsr_rbyd_lookup(&lfs, &rbyd, LFSR_TAG_UATTR(1), k*W+W-1, + &tag_, &id_, &weight_, &off_, &size_) => 0; + assert(tag_ == LFSR_TAG_UATTR(1)); + assert(id_ == k*W+W-1); + assert(weight_ == 0); + assert(size_ == 2); + } + } + } + + // next permutation using Heap's algorithm + if (stack[i] < i) { + if (i % 2 == 0) { + uint16_t t = perm[0]; + perm[0] = perm[i]; + perm[i] = t; + } else { + uint16_t t = perm[stack[i]]; + perm[stack[i]] = perm[i]; + perm[i] = t; + } + stack[i] += 1; + i = 1; + } else { + stack[i] = 0; + i += 1; + } + } +'''