From 100fb66d37358b2e203218c732c67e7beb88acb1 Mon Sep 17 00:00:00 2001 From: Christopher Haster Date: Thu, 17 Jul 2025 15:11:40 -0500 Subject: [PATCH] tag-returning: Adopted tag-returns in btree lookups - lfs3_btree_lookupleaf - lfs3_btree_lookupnext - lfs3_btree_lookup - lfs3_btree_traverse - NOT lfs3_btree_namelookup Looks like we're starting to claw back stack usage a bit. This makes sense as the btree logic involves the most layers -- with out-pointers it needs more temporary copies to inspect tags along the way: code stack ctx before: 36576 2376 656 after: 36520 (-0.2%) 2352 (-1.0%) 656 (+0.0%) --- lfs3.c | 154 +++++------ tests/test_badblocks.toml | 24 +- tests/test_btree.toml | 529 +++++++++++++++++++------------------- tests/test_fwrite.toml | 120 ++++----- 4 files changed, 406 insertions(+), 421 deletions(-) diff --git a/lfs3.c b/lfs3.c index f95a19f0..cd264706 100644 --- a/lfs3.c +++ b/lfs3.c @@ -5239,10 +5239,11 @@ static int lfs3_data_fetchbtree(lfs3_t *lfs3, lfs3_data_t *data, // lookup rbyd/rid containing a given bid #ifndef LFS3_2BONLY -static int lfs3_btree_lookupleaf(lfs3_t *lfs3, const lfs3_btree_t *btree, +static lfs3_stag_t lfs3_btree_lookupleaf(lfs3_t *lfs3, + const lfs3_btree_t *btree, lfs3_bid_t bid, lfs3_bid_t *bid_, lfs3_rbyd_t *rbyd_, lfs3_srid_t *rid_, - lfs3_tag_t *tag_, lfs3_bid_t *weight_, lfs3_data_t *data_) { + lfs3_bid_t *weight_, lfs3_data_t *data_) { // descend down the btree looking for our bid *rbyd_ = *btree; lfs3_srid_t rid = bid; @@ -5290,16 +5291,13 @@ static int lfs3_btree_lookupleaf(lfs3_t *lfs3, const lfs3_btree_t *btree, if (rid_) { *rid_ = rid__; } - if (tag_) { - *tag_ = tag__; - } if (weight_) { *weight_ = weight__; } if (data_) { *data_ = data__; } - return 0; + return tag__; } } } @@ -5308,13 +5306,13 @@ static int lfs3_btree_lookupleaf(lfs3_t *lfs3, const lfs3_btree_t *btree, // non-leaf lookups discard the rbyd info, which can be a bit more // convenient, but may make commits more costly #ifndef LFS3_2BONLY -static int lfs3_btree_lookupnext(lfs3_t *lfs3, const lfs3_btree_t *btree, +static lfs3_stag_t lfs3_btree_lookupnext(lfs3_t *lfs3, + const lfs3_btree_t *btree, lfs3_bid_t bid, - lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bid_t *weight_, - lfs3_data_t *data_) { + lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) { lfs3_rbyd_t rbyd; return lfs3_btree_lookupleaf(lfs3, btree, bid, - bid_, &rbyd, NULL, tag_, weight_, data_); + bid_, &rbyd, NULL, weight_, data_); } #endif @@ -5322,17 +5320,17 @@ static int lfs3_btree_lookupnext(lfs3_t *lfs3, const lfs3_btree_t *btree, // behavior, if you don't care about the exact bid either first call // lfs3_btree_lookupnext, or lfs3_btree_lookupleaf + lfs3_rbyd_lookup #ifndef LFS3_2BONLY -static int lfs3_btree_lookup(lfs3_t *lfs3, const lfs3_btree_t *btree, +static lfs3_stag_t lfs3_btree_lookup(lfs3_t *lfs3, const lfs3_btree_t *btree, lfs3_bid_t bid, lfs3_tag_t tag, - lfs3_tag_t *tag_, lfs3_data_t *data_) { + lfs3_data_t *data_) { // lookup rbyd in btree lfs3_bid_t bid__; lfs3_rbyd_t rbyd__; lfs3_srid_t rid__; - int err = lfs3_btree_lookupleaf(lfs3, btree, bid, - &bid__, &rbyd__, &rid__, NULL, NULL, NULL); - if (err) { - return err; + lfs3_stag_t tag__ = lfs3_btree_lookupleaf(lfs3, btree, bid, + &bid__, &rbyd__, &rid__, NULL, NULL); + if (tag__ < 0) { + return tag__; } // lookup finds the next-smallest bid, all we need to do is fail if it @@ -5342,16 +5340,8 @@ static int lfs3_btree_lookup(lfs3_t *lfs3, const lfs3_btree_t *btree, } // lookup tag in rbyd - lfs3_stag_t tag__ = lfs3_rbyd_lookup(lfs3, &rbyd__, rid__, tag, + return lfs3_rbyd_lookup(lfs3, &rbyd__, rid__, tag, data_); - if (tag__ < 0) { - return tag__; - } - - if (tag_) { - *tag_ = tag__; - } - return 0; } #endif @@ -5497,12 +5487,12 @@ static int lfs3_btree_commit_(lfs3_t *lfs3, lfs3_srid_t rid = bcommit->bid; if (btree->weight > 0) { lfs3_srid_t rid_; - int err = lfs3_btree_lookupleaf(lfs3, btree, + lfs3_stag_t tag = lfs3_btree_lookupleaf(lfs3, btree, lfs3_min(bcommit->bid, btree->weight-1), - &bcommit->bid, &child, &rid_, NULL, NULL, NULL); - if (err) { - LFS3_ASSERT(err != LFS3_ERR_NOENT); - return err; + &bcommit->bid, &child, &rid_, NULL, NULL); + if (tag < 0) { + LFS3_ASSERT(tag != LFS3_ERR_NOENT); + return tag; } // adjust rid @@ -6287,10 +6277,10 @@ static void lfs3_btraversal_init(lfs3_btraversal_t *bt) { #endif #ifndef LFS3_2BONLY -static int lfs3_btree_traverse(lfs3_t *lfs3, const lfs3_btree_t *btree, +static lfs3_stag_t lfs3_btree_traverse(lfs3_t *lfs3, + const lfs3_btree_t *btree, lfs3_btraversal_t *bt, - lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bid_t *weight_, - lfs3_data_t *data_) { + lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) { // explicitly traverse the root even if weight=0 if (!bt->branch) { bt->branch = btree; @@ -6305,16 +6295,13 @@ static int lfs3_btree_traverse(lfs3_t *lfs3, const lfs3_btree_t *btree, if (bid_) { *bid_ = btree->weight-1; } - if (tag_) { - *tag_ = LFS3_TAG_BRANCH; - } if (weight_) { *weight_ = btree->weight; } if (data_) { data_->u.buffer = (const uint8_t*)bt->branch; } - return 0; + return LFS3_TAG_BRANCH; } } @@ -6365,16 +6352,13 @@ static int lfs3_btree_traverse(lfs3_t *lfs3, const lfs3_btree_t *btree, if (bid_) { *bid_ = bt->bid + (rid__ - bt->rid); } - if (tag_) { - *tag_ = LFS3_TAG_BRANCH; - } if (weight_) { *weight_ = weight__; } if (data_) { data_->u.buffer = (const uint8_t*)bt->branch; } - return 0; + return LFS3_TAG_BRANCH; } // found our bid @@ -6390,16 +6374,13 @@ static int lfs3_btree_traverse(lfs3_t *lfs3, const lfs3_btree_t *btree, if (bid_) { *bid_ = bid__; } - if (tag_) { - *tag_ = tag__; - } if (weight_) { *weight_ = weight__; } if (data_) { *data_ = data__; } - return 0; + return tag__; } } } @@ -6725,44 +6706,46 @@ static lfs3_ssize_t lfs3_bshrub_estimate(lfs3_t *lfs3, // bshrub lookup functions #ifndef LFS3_2BONLY -static int lfs3_bshrub_lookupleaf(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, +static lfs3_stag_t lfs3_bshrub_lookupleaf(lfs3_t *lfs3, + const lfs3_bshrub_t *bshrub, lfs3_bid_t bid, lfs3_bid_t *bid_, lfs3_rbyd_t *rbyd_, lfs3_srid_t *rid_, - lfs3_tag_t *tag_, lfs3_bid_t *weight_, lfs3_data_t *data_) { + lfs3_bid_t *weight_, lfs3_data_t *data_) { return lfs3_btree_lookupleaf(lfs3, &bshrub->shrub, bid, - bid_, rbyd_, rid_, tag_, weight_, data_); + bid_, rbyd_, rid_, weight_, data_); } #endif -static int lfs3_bshrub_lookupnext(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, +static lfs3_stag_t lfs3_bshrub_lookupnext(lfs3_t *lfs3, + const lfs3_bshrub_t *bshrub, lfs3_bid_t bid, - lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bid_t *weight_, - lfs3_data_t *data_) { + lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) { #ifndef LFS3_2BONLY return lfs3_btree_lookupnext(lfs3, &bshrub->shrub, bid, - bid_, tag_, weight_, data_); + bid_, weight_, data_); #else return lfs3_rbyd_lookupnext(lfs3, &bshrub->shrub, bid, 0, - (lfs3_srid_t*)bid_, tag_, weight_, data_); + (lfs3_srid_t*)bid_, weight_, data_); #endif } #ifndef LFS3_2BONLY -static int lfs3_bshrub_lookup(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, +static lfs3_stag_t lfs3_bshrub_lookup(lfs3_t *lfs3, + const lfs3_bshrub_t *bshrub, lfs3_bid_t bid, lfs3_tag_t tag, - lfs3_tag_t *tag_, lfs3_data_t *data_) { + lfs3_data_t *data_) { return lfs3_btree_lookup(lfs3, &bshrub->shrub, bid, tag, - tag_, data_); + data_); } #endif #ifndef LFS3_2BONLY -static int lfs3_bshrub_traverse(lfs3_t *lfs3, const lfs3_bshrub_t *bshrub, +static lfs3_stag_t lfs3_bshrub_traverse(lfs3_t *lfs3, + const lfs3_bshrub_t *bshrub, lfs3_btraversal_t *bt, - lfs3_bid_t *bid_, lfs3_tag_t *tag_, lfs3_bid_t *weight_, - lfs3_data_t *data_) { + lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_data_t *data_) { return lfs3_btree_traverse(lfs3, &bshrub->shrub, bt, - bid_, tag_, weight_, data_); + bid_, weight_, data_); } #endif @@ -7976,14 +7959,13 @@ static int lfs3_mtree_lookup(lfs3_t *lfs3, lfs3_smid_t mid, #ifndef LFS3_2BONLY lfs3_bid_t bid; lfs3_srid_t rid; - lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_btree_lookupleaf(lfs3, &lfs3->mtree, mid, - &bid, &mdir_->r, &rid, (lfs3_tag_t*)&tag, &weight, &data); - if (err) { - LFS3_ASSERT(err != LFS3_ERR_NOENT); - return err; + lfs3_stag_t tag = lfs3_btree_lookupleaf(lfs3, &lfs3->mtree, mid, + &bid, &mdir_->r, &rid, &weight, &data); + if (tag < 0) { + LFS3_ASSERT(tag != LFS3_ERR_NOENT); + return tag; } LFS3_ASSERT((lfs3_sbid_t)bid == lfs3_mbid(lfs3, mid)); LFS3_ASSERT(weight == (lfs3_bid_t)(1 << lfs3->mbits)); @@ -9790,11 +9772,11 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, #ifndef LFS3_2BONLY case LFS3_TSTATE_MROOTCHAIN:; // lookup mroot, if we find one this is not the active mroot - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_data_t data; err = lfs3_mdir_lookup(lfs3, &t->b.o.mdir, LFS3_TAG_MASK8 | LFS3_TAG_STRUCT, - &tag, &data); + (lfs3_tag_t*)&tag, &data); if (err) { // if we have no mtree (inlined mdir), we need to // traverse any files in our mroot next @@ -9970,10 +9952,10 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, case LFS3_TSTATE_BTREE:; case LFS3_TSTATE_OBTREE:; // traverse through our bshrub/btree - err = lfs3_bshrub_traverse(lfs3, &t->b, &t->u.bt, - NULL, &tag, NULL, &data); - if (err) { - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(lfs3, &t->b, &t->u.bt, + NULL, NULL, &data); + if (tag < 0) { + if (tag == LFS3_ERR_NOENT) { // clear the bshrub state lfs3_bshrub_init(&t->b); // end of mtree? start iterating over mdirs @@ -9999,7 +9981,7 @@ static int lfs3_mtree_traverse_(lfs3_t *lfs3, lfs3_traversal_t *t, LFS3_UNREACHABLE(); } } - return err; + return tag; } // found an inner btree node? @@ -11971,19 +11953,18 @@ int lfs3_file_close(lfs3_t *lfs3, lfs3_file_t *file) { static int lfs3_file_lookupnext(lfs3_t *lfs3, const lfs3_file_t *file, lfs3_bid_t bid, lfs3_bid_t *bid_, lfs3_bid_t *weight_, lfs3_bptr_t *bptr_) { - lfs3_tag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_lookupnext(lfs3, &file->b, bid, - bid_, &tag, &weight, &data); - if (err) { - return err; + lfs3_stag_t tag = lfs3_bshrub_lookupnext(lfs3, &file->b, bid, + bid_, &weight, &data); + if (tag < 0) { + return tag; } LFS3_ASSERT(tag == LFS3_TAG_DATA || tag == LFS3_TAG_BLOCK); // fetch the bptr/data fragment - err = lfs3_bptr_fetch(lfs3, bptr_, tag, weight, data); + int err = lfs3_bptr_fetch(lfs3, bptr_, tag, weight, data); if (err) { return err; } @@ -14095,15 +14076,14 @@ static int lfs3_file_ck(lfs3_t *lfs3, const lfs3_file_t *file, lfs3_btraversal_t bt; lfs3_btraversal_init(&bt); while (true) { - lfs3_tag_t tag; lfs3_data_t data; - int err = lfs3_bshrub_traverse(lfs3, &file->b, &bt, - NULL, &tag, NULL, &data); - if (err) { - if (err == LFS3_ERR_NOENT) { + lfs3_stag_t tag = lfs3_bshrub_traverse(lfs3, &file->b, &bt, + NULL, NULL, &data); + if (tag < 0) { + if (tag == LFS3_ERR_NOENT) { break; } - return err; + return tag; } // validate btree nodes? @@ -14115,7 +14095,7 @@ static int lfs3_file_ck(lfs3_t *lfs3, const lfs3_file_t *file, || lfs3_t_isckdata(flags)) && tag == LFS3_TAG_BRANCH) { lfs3_rbyd_t *rbyd = (lfs3_rbyd_t*)data.u.buffer; - err = lfs3_rbyd_fetchck(lfs3, rbyd, + int err = lfs3_rbyd_fetchck(lfs3, rbyd, rbyd->blocks[0], rbyd->trunk, rbyd->cksum); if (err) { @@ -14127,7 +14107,7 @@ static int lfs3_file_ck(lfs3_t *lfs3, const lfs3_file_t *file, if (lfs3_t_isckdata(flags) && tag == LFS3_TAG_BLOCK) { lfs3_bptr_t bptr; - err = lfs3_data_readbptr(lfs3, &data, + int err = lfs3_data_readbptr(lfs3, &data, &bptr); if (err) { return err; diff --git a/tests/test_badblocks.toml b/tests/test_badblocks.toml index 0cd9e377..dcaf4fed 100644 --- a/tests/test_badblocks.toml +++ b/tests/test_badblocks.toml @@ -105,12 +105,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == i); assert(tag_ == LFS3_TAG_DATA); @@ -120,7 +120,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2060,12 +2060,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == i); assert(tag_ == LFS3_TAG_DATA); @@ -2075,7 +2075,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -4017,12 +4017,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == i); assert(tag_ == LFS3_TAG_DATA); @@ -4032,7 +4032,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); diff --git a/tests/test_btree.toml b/tests/test_btree.toml index d460856a..9e77b7b3 100644 --- a/tests/test_btree.toml +++ b/tests/test_btree.toml @@ -30,12 +30,11 @@ code = ''' // try looking up tags lfs3_bid_t bid_; - lfs3_tag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # test an inlined tree @@ -66,12 +65,12 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(bid_ == 0); assert(tag_ == LFS3_TAG_DATA); @@ -79,7 +78,7 @@ code = ''' assert(memcmp(buffer, "a", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # test a single-rbyd tree @@ -112,26 +111,26 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_two_backwards] @@ -163,26 +162,26 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # still a single-rbyd tree, just making sure it works @@ -217,33 +216,33 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_three_backwards] @@ -277,33 +276,33 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "c", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' # try larger trees, when exactly a tree splits depends on the disk geometry, so @@ -342,13 +341,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -357,7 +356,7 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_push_backwards] @@ -394,13 +393,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, n-1-i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, n-1-i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -409,7 +408,7 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_push_fuzz] @@ -476,12 +475,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -490,7 +489,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -532,13 +531,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -547,13 +546,13 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, n*W, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == i*W+W-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -562,7 +561,7 @@ code = ''' assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_push_sparse_fuzz] @@ -655,7 +654,7 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -665,8 +664,9 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, weighted_bid+sim_weights[i]-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, + weighted_bid+sim_weights[i]-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -675,7 +675,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; @@ -686,8 +686,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -696,7 +696,7 @@ code = ''' assert(memcmp(buffer, &sim[i], 1) == 0); } lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -738,19 +738,19 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_two] @@ -791,26 +791,26 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_three] @@ -857,33 +857,33 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update] @@ -925,13 +925,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < N; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -940,7 +940,7 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, N, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_fuzz] @@ -1012,12 +1012,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < N; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -1026,7 +1026,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, N, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -1072,13 +1072,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < N; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -1087,13 +1087,13 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, N*W, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; for (lfs3_size_t i = 0; i < N; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == i*W+W-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -1102,7 +1102,7 @@ code = ''' assert(memcmp(buffer, &(uint8_t){'A'+(i % 26)}, 1) == 0); } lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_update_sparse_fuzz] @@ -1201,7 +1201,7 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < N; i++) { @@ -1211,8 +1211,9 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, weighted_bid+sim_weights[i]-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, + weighted_bid+sim_weights[i]-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -1221,7 +1222,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; @@ -1232,8 +1233,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -1242,7 +1243,7 @@ code = ''' assert(memcmp(buffer, &sim[i], 1) == 0); } lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -1283,12 +1284,12 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( @@ -1300,15 +1301,15 @@ code = ''' assert(btree.weight == 1); // try looking up tags - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_two] @@ -1343,19 +1344,19 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 1, LFS3_RATTRS( @@ -1367,22 +1368,22 @@ code = ''' assert(btree.weight == 2); // try looking up tags - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "B", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_two_other] @@ -1417,19 +1418,19 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( @@ -1441,22 +1442,22 @@ code = ''' assert(btree.weight == 2); // try looking up tags - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "A", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_three] @@ -1493,26 +1494,26 @@ code = ''' // try looking up tags uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // try to putting it back to see if things still work lfs3_btree_commit(&lfs3, &btree, 2, LFS3_RATTRS( @@ -1524,29 +1525,29 @@ code = ''' assert(btree.weight == 3); // try looking up tags - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "a", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "b", 1) == 0); - lfs3_btree_lookupnext(&lfs3, &btree, 2, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 2, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "C", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, 3, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop] @@ -1589,13 +1590,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < REMAINING; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -1604,30 +1605,30 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, REMAINING, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // try recovering lfs3_btree_commit(&lfs3, &btree, REMAINING, LFS3_RATTRS( LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "R", 1))) => 0; for (lfs3_size_t i = 0; i < REMAINING; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfs3_btree_lookupnext(&lfs3, &btree, REMAINING, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, REMAINING, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, REMAINING+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_backwards] @@ -1669,13 +1670,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < REMAINING; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -1685,22 +1686,22 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, REMAINING, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // try recovering lfs3_btree_commit(&lfs3, &btree, 0, LFS3_RATTRS( LFS3_RATTR_BUF(LFS3_TAG_DATA, +1, "R", 1))) => 0; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); assert(memcmp(buffer, "R", 1) == 0); for (lfs3_size_t i = 0; i < REMAINING; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i+1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -1709,7 +1710,7 @@ code = ''' } lfs3_btree_lookupnext(&lfs3, &btree, REMAINING+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_fuzz] @@ -1783,12 +1784,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -1797,7 +1798,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -1843,13 +1844,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < REMAINING; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -1858,36 +1859,36 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, REMAINING*W+W-1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // try recovering lfs3_btree_commit(&lfs3, &btree, REMAINING*W, LFS3_RATTRS( LFS3_RATTR_BUF(LFS3_TAG_DATA, +W, "R", 1))) => 0; for (lfs3_size_t i = 0; i < REMAINING; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfs3_btree_lookupnext(&lfs3, &btree, REMAINING*W+W-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, REMAINING*W+W-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); assert(memcmp(buffer, "R", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, (REMAINING+1)*W+W-1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; for (lfs3_size_t i = 0; i < REMAINING; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == i*W+W-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -1896,8 +1897,8 @@ code = ''' assert(memcmp(buffer, &(uint8_t){'a'+(i % 26)}, 1) == 0); } - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == REMAINING*W+W-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -1906,7 +1907,7 @@ code = ''' assert(memcmp(buffer, "R", 1) == 0); lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_pop_sparse_fuzz] @@ -2016,7 +2017,7 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -2026,8 +2027,9 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, weighted_bid+sim_weights[i]-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, + weighted_bid+sim_weights[i]-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2036,7 +2038,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; @@ -2047,8 +2049,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2057,7 +2059,7 @@ code = ''' assert(memcmp(buffer, &sim[i], 1) == 0); } lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2106,13 +2108,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -2121,7 +2123,7 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_split_fuzz] @@ -2195,12 +2197,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -2209,7 +2211,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2258,13 +2260,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i*W+W-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == W); @@ -2273,7 +2275,7 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, n*W, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_split_sparse_fuzz] @@ -2356,7 +2358,7 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -2366,8 +2368,9 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, weighted_bid+sim_weights[i]-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, + weighted_bid+sim_weights[i]-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2406,7 +2409,7 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -2416,8 +2419,9 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, weighted_bid+sim_weights[i]-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, + weighted_bid+sim_weights[i]-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2426,7 +2430,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; @@ -2437,8 +2441,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2447,7 +2451,7 @@ code = ''' assert(memcmp(buffer, &sim[i], 1) == 0); } lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2511,11 +2515,11 @@ code = ''' // check that our other entry is fine lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buf1, SIZE) => SIZE; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -2523,7 +2527,7 @@ code = ''' // and check that our pop worked lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_drop_compact] @@ -2585,11 +2589,11 @@ code = ''' // check that our other entry is fine lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buf1, SIZE) => SIZE; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -2597,7 +2601,7 @@ code = ''' // and check that our pop worked lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_drop_split] @@ -2652,11 +2656,11 @@ code = ''' // check that our other entry is fine lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buf1, SIZE) => SIZE; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -2664,7 +2668,7 @@ code = ''' // and check that our pop worked lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_drop_merge] @@ -2734,11 +2738,11 @@ code = ''' // check that our other entry is fine lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; - lfs3_btree_lookupnext(&lfs3, &btree, 0, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, 0, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buf1, SIZE) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -2746,7 +2750,7 @@ code = ''' // and check that our pop worked lfs3_btree_lookupnext(&lfs3, &btree, 1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' @@ -2838,12 +2842,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -2852,7 +2856,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -2979,7 +2983,7 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -2989,8 +2993,9 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, weighted_bid+sim_weights[i]-1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, + weighted_bid+sim_weights[i]-1, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -2999,7 +3004,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, total_weight, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // also test that we can traverse the tree without prior knowledge bid_ = -1; @@ -3010,8 +3015,8 @@ code = ''' weighted_bid += sim_weights[j]; } - lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, + &bid_, &weight_, &data_); assert(bid_ == weighted_bid+sim_weights[i]-1); assert(tag_ == LFS3_TAG_DATA); assert(weight_ == sim_weights[i]); @@ -3020,7 +3025,7 @@ code = ''' assert(memcmp(buffer, &sim[i], 1) == 0); } lfs3_btree_lookupnext(&lfs3, &btree, bid_+1, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); @@ -3094,7 +3099,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; @@ -3161,7 +3166,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; @@ -3245,7 +3250,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; @@ -3340,7 +3345,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; @@ -3446,7 +3451,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; @@ -3565,7 +3570,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -3645,7 +3650,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; @@ -3799,7 +3804,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -3990,7 +3995,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -4213,7 +4218,7 @@ code = ''' lfs3_bid_t bid_; lfs3_rbyd_t rbyd_; lfs3_srid_t rid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { @@ -4279,13 +4284,13 @@ code = ''' // check that the elements are in the tree uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -4294,7 +4299,7 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // test that we can traverse the tree, keeping track of all blocks we see uint8_t *seen = malloc((BLOCK_COUNT+7)/8); @@ -4307,13 +4312,13 @@ code = ''' assert(i <= 2*N); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_btree_traverse(&lfs3, &btree, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_btree_traverse(&lfs3, &btree, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -4360,8 +4365,8 @@ code = ''' // check that the elements are in the tree for (lfs3_size_t i = 0; i < n; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -4370,7 +4375,7 @@ code = ''' // and check that we can't lookup elements that aren't in the tree lfs3_btree_lookupnext(&lfs3, &btree, n, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; ''' [cases.test_btree_traversal_fuzz] @@ -4437,12 +4442,12 @@ code = ''' uint8_t buffer[4]; lfs3_bid_t bid_; - lfs3_tag_t tag_; + lfs3_stag_t tag_; lfs3_size_t weight_; lfs3_data_t data_; for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -4451,7 +4456,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // test that we can traverse the tree, keeping track of all blocks // we see @@ -4465,13 +4470,13 @@ code = ''' assert(i <= 2*N); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_btree_traverse(&lfs3, &btree, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_btree_traverse(&lfs3, &btree, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -4534,8 +4539,8 @@ code = ''' assert(btree.weight == sim_size); for (lfs3_size_t i = 0; i < sim_size; i++) { - lfs3_btree_lookupnext(&lfs3, &btree, i, - &bid_, &tag_, &weight_, &data_) => 0; + tag_ = lfs3_btree_lookupnext(&lfs3, &btree, i, + &bid_, &weight_, &data_); lfs3_data_read(&lfs3, &data_, buffer, 4) => 1; assert(tag_ == LFS3_TAG_DATA); assert(weight_ == 1); @@ -4544,7 +4549,7 @@ code = ''' // and no extra elements lfs3_btree_lookupnext(&lfs3, &btree, sim_size, - &bid_, &tag_, &weight_, &data_) => LFS3_ERR_NOENT; + &bid_, &weight_, &data_) => LFS3_ERR_NOENT; // clean up sim free(sim); diff --git a/tests/test_fwrite.toml b/tests/test_fwrite.toml index f1a1ba6c..e7f015fe 100644 --- a/tests/test_fwrite.toml +++ b/tests/test_fwrite.toml @@ -190,13 +190,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -338,13 +338,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -604,13 +604,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -767,13 +767,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -2095,13 +2095,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -2247,13 +2247,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -2546,13 +2546,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -2713,13 +2713,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -3006,13 +3006,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -3177,13 +3177,13 @@ code = ''' assert(i < 2*BLOCK_COUNT); lfs3_bid_t bid; - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, - &bid, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_traverse(&lfs3, &file.b, &bt, + &bid, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -4988,13 +4988,13 @@ code = ''' lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; lfs3_off_t pos = 0; while (true) { - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_lookupnext(&lfs3, &file.b, pos, - &pos, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_lookupnext(&lfs3, &file.b, pos, + &pos, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; } @@ -5098,13 +5098,13 @@ code = ''' lfs3_file_open(&lfs3, &file, "hello", LFS3_O_WRONLY) => 0; lfs3_off_t pos = 0; while (true) { - lfs3_tag_t tag; + lfs3_stag_t tag; lfs3_bid_t weight; lfs3_data_t data; - int err = lfs3_bshrub_lookupnext(&lfs3, &file.b, pos, - &pos, &tag, &weight, &data); - assert(!err || err == LFS3_ERR_NOENT); - if (err == LFS3_ERR_NOENT) { + tag = lfs3_bshrub_lookupnext(&lfs3, &file.b, pos, + &pos, &weight, &data); + assert(tag >= 0 || tag == LFS3_ERR_NOENT); + if (tag == LFS3_ERR_NOENT) { break; }