106 lines
4.0 KiB
C++
106 lines
4.0 KiB
C++
// 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 <algorithm>
|
||
#include <cstdint>
|
||
#include <cstdio>
|
||
#include <limits>
|
||
#include <type_traits>
|
||
#include <utility>
|
||
#include <vector>
|
||
|
||
#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<Key> 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<OptKey> 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<decltype(Selector::offset), std::int32_t>,
|
||
"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<std::int32_t>::min(),
|
||
std::numeric_limits<std::int32_t>::min() + 1,
|
||
-1000000000,
|
||
-3,
|
||
-1,
|
||
0,
|
||
1,
|
||
2,
|
||
3,
|
||
1000000000,
|
||
std::numeric_limits<std::int32_t>::max() - 1,
|
||
std::numeric_limits<std::int32_t>::max()};
|
||
std::vector<Selector> 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<Key> complete =
|
||
gen::inRange(db, gen::resolve(db, bs), gen::resolve(db, es));
|
||
for (bool reverse : {false, true}) {
|
||
std::vector<Key> ordered = complete;
|
||
if (reverse) std::reverse(ordered.begin(), ordered.end());
|
||
|
||
std::vector<std::pair<std::size_t, bool>> 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<KeyView> 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<long long>(bs.offset),
|
||
static_cast<long long>(es.offset), reverse, more,
|
||
keep);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
std::printf("extreme: %lld cases, %lld mismatches\n", cases, bad);
|
||
return bad == 0 ? 0 : 1;
|
||
}
|