// Released under Apache 2.0 license as described in the file LICENSE. // Regression test for offsets at the extremes of the input domain. Offsets // supplied by callers are 32-bit; a positive `end.offset` near `INT32_MAX` // would otherwise materialise about 2^31 zero bytes for Lean's // `keyAfterN n k < upper` test, so both implementations decide it from key // lengths (`keyAfterNLt`) instead of allocating. #include #include #include #include #include #include #include #include "../src/fast.h" #include "../src/literal.h" #include "readable_gen.h" namespace { using namespace cr; } // namespace int main() { // Sorted, duplicate-free, with an empty key and a two-byte `0xff` key. const std::vector db{Key{}, Key(1, '\0'), Key("a"), Key("b"), Key("\xff\xff", 2)}; // Selector keys are owned here and borrowed by the selectors below. std::vector owned; owned.reserve(4); owned.push_back(std::nullopt); // ⊤ owned.push_back(OptKey{Key{}}); // ⊥ owned.push_back(OptKey{Key("a")}); owned.push_back(OptKey{Key("\xff\xff", 2)}); // `Selector` stores offsets as `std::int32_t`, so `RangeRead` itself cannot // violate the input contract. The corpus parsers still validate wider // parsed values with `offsetsFitInt32` before narrowing. static_assert(std::is_same_v, "Selector::offset must match the 32-bit input contract"); if (!offsetsFitInt32(kMinInputOffset, kMaxInputOffset) || offsetsFitInt32(kMinInputOffset - 1, kMaxInputOffset + 1)) { std::fprintf(stderr, "offset contract check failed\n"); return 1; } const std::int32_t offs[] = {std::numeric_limits::min(), std::numeric_limits::min() + 1, -1000000000, -3, -1, 0, 1, 2, 3, 1000000000, std::numeric_limits::max() - 1, std::numeric_limits::max()}; std::vector sels; sels.reserve(owned.size() * (sizeof(offs) / sizeof(offs[0]))); for (const OptKey& k : owned) for (std::int32_t off : offs) sels.push_back(Selector{optView(k), off}); long long cases = 0, bad = 0; for (const Selector& bs : sels) for (const Selector& es : sels) { std::vector complete = gen::inRange(db, gen::resolve(db, bs), gen::resolve(db, es)); for (bool reverse : {false, true}) { std::vector ordered = complete; if (reverse) std::reverse(ordered.begin(), ordered.end()); std::vector> keeps; keeps.emplace_back(ordered.size(), false); if (!ordered.empty()) { keeps.emplace_back(1, true); if (ordered.size() > 1) keeps.emplace_back((ordered.size() + 1) / 2, true); } for (auto [keep, more] : keeps) { std::vector views; views.reserve(keep); for (std::size_t i = 0; i < keep; ++i) views.push_back(ordered[i]); RangeRead r{bs, es, reverse}; Result res{views, more}; ConflictRange a = literal::closedForm(r, res); ConflictRange b = fast::closedForm(r, res); ++cases; if (!gen::equivalent(a, b)) { if (++bad <= 10) std::fprintf(stderr, "MISMATCH bo=%lld eo=%lld rev=%d more=%d keys=%zu\n", static_cast(bs.offset), static_cast(es.offset), reverse, more, keep); } } } } std::printf("extreme: %lld cases, %lld mismatches\n", cases, bad); return bad == 0 ? 0 : 1; }