Annotate noexcept and constexpr with HEDLEY, and add interval containment, ChaCha, and the dyadic range tables.
Co-authored-by: Cursor <cursoragent@cursor.com>
This commit is contained in:
parent
875f09fec1
commit
0d8a5a8131
97 changed files with 9212 additions and 1159 deletions
224
test/tests/ic_test.cpp
Normal file
224
test/tests/ic_test.cpp
Normal file
|
|
@ -0,0 +1,224 @@
|
|||
#include <gtest/gtest.h>
|
||||
|
||||
#include "dpf.hpp"
|
||||
|
||||
#include <cstdint>
|
||||
#include <random>
|
||||
#include <vector>
|
||||
|
||||
namespace
|
||||
{
|
||||
|
||||
uint64_t oracle(uint64_t x, uint64_t r, uint64_t p, uint64_t q,
|
||||
uint64_t nmask, uint64_t if_true, uint64_t if_false, uint64_t gmask)
|
||||
{
|
||||
const uint64_t w = (x - r) & nmask;
|
||||
const bool inside = w >= p && w <= q;
|
||||
return (inside ? if_true : if_false) & gmask;
|
||||
}
|
||||
|
||||
template <typename Input, typename Beta>
|
||||
void expect_domain(Input r, Input p, Input q, Beta if_true, Beta if_false,
|
||||
uint64_t gmask)
|
||||
{
|
||||
auto keys = dpf::make_dpf(r, dpf::ic(p, q, if_true, if_false));
|
||||
const uint64_t nmask = keys.first.input_mask;
|
||||
const uint64_t rb = static_cast<uint64_t>(r);
|
||||
const uint64_t pb = static_cast<uint64_t>(p);
|
||||
const uint64_t qb = static_cast<uint64_t>(q);
|
||||
for (uint64_t x = 0; x <= nmask; ++x)
|
||||
{
|
||||
const auto y0 = dpf::eval_point(dpf::ic, keys.first,
|
||||
static_cast<Input>(x));
|
||||
const auto y1 = dpf::eval_point(dpf::ic, keys.second,
|
||||
static_cast<Input>(x));
|
||||
const uint64_t got = static_cast<uint64_t>(dpf::reconstruct(y0, y1)) & gmask;
|
||||
const uint64_t want = oracle(x, rb, pb, qb, nmask,
|
||||
static_cast<uint64_t>(if_true), static_cast<uint64_t>(if_false), gmask);
|
||||
ASSERT_EQ(got, want) << "r=" << rb << " x=" << x
|
||||
<< " p=" << pb << " q=" << qb;
|
||||
}
|
||||
}
|
||||
|
||||
} // namespace
|
||||
|
||||
TEST(Ic, Uint8FullDomainCorners)
|
||||
{
|
||||
const uint32_t betas[] = {1u, 7u, 255u};
|
||||
const uint32_t falses[] = {0u, 9u};
|
||||
const uint8_t intervals[][2] = {
|
||||
{0, 0}, {0, 255}, {5, 5}, {1, 20}, {200, 250}, {0, 1}, {254, 255}, {10, 40}
|
||||
};
|
||||
for (uint32_t beta : betas)
|
||||
{
|
||||
for (uint32_t f : falses)
|
||||
{
|
||||
for (const auto & iv : intervals)
|
||||
{
|
||||
for (int r = 0; r < 256; r += 17)
|
||||
{
|
||||
expect_domain<uint8_t>(static_cast<uint8_t>(r), iv[0], iv[1],
|
||||
beta, f, 0xffffffffu);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Ic, Uint8AllMasksOneInterval)
|
||||
{
|
||||
expect_domain<uint8_t>(uint8_t{0}, uint8_t{10}, uint8_t{20},
|
||||
uint32_t{3}, uint32_t{0}, 0xffffffffu);
|
||||
expect_domain<uint8_t>(uint8_t{200}, uint8_t{10}, uint8_t{100},
|
||||
uint32_t{3}, uint32_t{1}, 0xffffffffu);
|
||||
expect_domain<uint8_t>(uint8_t{255}, uint8_t{0}, uint8_t{255},
|
||||
uint32_t{1}, uint32_t{0}, 0xffffffffu);
|
||||
}
|
||||
|
||||
TEST(Ic, MemoizerAgrees)
|
||||
{
|
||||
const uint8_t r = 40, p = 7, q = 90;
|
||||
auto keys = dpf::make_dpf(r, dpf::ic(p, q, uint32_t{11}, uint32_t{2}));
|
||||
dpf::basic_path_memoizer<decltype(keys.first.key)> memo0;
|
||||
dpf::basic_path_memoizer<decltype(keys.second.key)> memo1;
|
||||
for (int x = 0; x < 256; ++x)
|
||||
{
|
||||
const auto a = dpf::eval_point(dpf::ic, keys.first, static_cast<uint8_t>(x), memo0);
|
||||
const auto b = dpf::eval_point(dpf::ic, keys.second, static_cast<uint8_t>(x), memo1);
|
||||
const auto c = dpf::eval_point(dpf::ic, keys.first, static_cast<uint8_t>(x));
|
||||
const auto d = dpf::eval_point(dpf::ic, keys.second, static_cast<uint8_t>(x));
|
||||
EXPECT_EQ(dpf::reconstruct(a, b), dpf::reconstruct(c, d));
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Ic, IntervalAndSequenceBuffers)
|
||||
{
|
||||
const uint8_t r = 15, p = 4, q = 12;
|
||||
auto keys = dpf::make_dpf(r, dpf::ic(p, q, uint16_t{9}));
|
||||
auto buf0 = dpf::make_output_buffer(dpf::ic, keys.first, uint8_t{3}, uint8_t{18});
|
||||
auto buf1 = dpf::make_output_buffer(dpf::ic, keys.second, uint8_t{3}, uint8_t{18});
|
||||
dpf::basic_path_memoizer<decltype(keys.first.key)> memo;
|
||||
dpf::eval_interval(dpf::ic, keys.first, uint8_t{3}, uint8_t{18}, buf0, memo);
|
||||
dpf::eval_interval(dpf::ic, keys.second, uint8_t{3}, uint8_t{18}, buf1);
|
||||
for (std::size_t i = 0; i < buf0.size(); ++i)
|
||||
{
|
||||
const auto point = dpf::reconstruct(
|
||||
dpf::eval_point(dpf::ic, keys.first, static_cast<uint8_t>(3 + i)),
|
||||
dpf::eval_point(dpf::ic, keys.second, static_cast<uint8_t>(3 + i)));
|
||||
EXPECT_EQ(dpf::reconstruct(buf0[i], buf1[i]), point);
|
||||
}
|
||||
|
||||
const uint8_t pts[] = {0, 9, 15, 255, 4};
|
||||
auto s0 = dpf::make_output_buffer(dpf::ic, keys.first, 5);
|
||||
auto s1 = dpf::make_output_buffer(dpf::ic, keys.second, 5);
|
||||
dpf::eval_sequence(dpf::ic, keys.first, std::begin(pts), std::end(pts), s0);
|
||||
dpf::eval_sequence(dpf::ic, keys.second, std::begin(pts), std::end(pts), s1);
|
||||
for (std::size_t i = 0; i < 5; ++i)
|
||||
{
|
||||
const auto point = dpf::reconstruct(
|
||||
dpf::eval_point(dpf::ic, keys.first, pts[i]),
|
||||
dpf::eval_point(dpf::ic, keys.second, pts[i]));
|
||||
EXPECT_EQ(dpf::reconstruct(s0[i], s1[i]), point);
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Ic, WildcardAssign)
|
||||
{
|
||||
auto keys = dpf::make_dpf(uint8_t{33},
|
||||
dpf::ic(uint8_t{2}, uint8_t{8}, dpf::wildcard<uint32_t>));
|
||||
EXPECT_THROW(dpf::eval_point(dpf::ic, keys.first, uint8_t{0}), std::invalid_argument);
|
||||
dpf::assign_cmp(keys.first, keys.second, uint32_t{6}, uint32_t{1});
|
||||
expect_domain<uint8_t>(uint8_t{33}, uint8_t{2}, uint8_t{8},
|
||||
uint32_t{6}, uint32_t{1}, 0xffffffffu);
|
||||
// The keys just assigned are a different generation; check those directly.
|
||||
for (int x = 0; x < 256; ++x)
|
||||
{
|
||||
const uint64_t got = static_cast<uint64_t>(dpf::reconstruct(
|
||||
dpf::eval_point(dpf::ic, keys.first, static_cast<uint8_t>(x)),
|
||||
dpf::eval_point(dpf::ic, keys.second, static_cast<uint8_t>(x))));
|
||||
const uint64_t w = static_cast<uint64_t>(static_cast<uint8_t>(x - 33));
|
||||
const uint64_t want = (w >= 2 && w <= 8) ? 6u : 1u;
|
||||
EXPECT_EQ(got, want) << x;
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Ic, DoernerShelatMatchesDealer)
|
||||
{
|
||||
std::mt19937 rng{7};
|
||||
std::uniform_int_distribution<int> d(0, 255);
|
||||
for (int n = 0; n < 30; ++n)
|
||||
{
|
||||
const uint8_t r0 = static_cast<uint8_t>(d(rng));
|
||||
const uint8_t r1 = static_cast<uint8_t>(d(rng));
|
||||
const uint8_t p = static_cast<uint8_t>(d(rng));
|
||||
const uint8_t q = static_cast<uint8_t>(p + static_cast<uint8_t>(d(rng) % (256 - p)));
|
||||
const uint32_t beta = 1u + static_cast<uint32_t>(d(rng));
|
||||
const uint8_t r = static_cast<uint8_t>(r0 ^ r1);
|
||||
auto dealer = dpf::make_dpf(r, dpf::ic(p, q, beta));
|
||||
struct Pad
|
||||
{
|
||||
simde__m128i block() { return dpf::uniform_sample<simde__m128i>(); }
|
||||
uint8_t bit() { return static_cast<uint8_t>(dpf::uniform_sample<uint8_t>() & 1u); }
|
||||
};
|
||||
dpf::ds_randomness<decltype(&dpf::uniform_sample<simde__m128i>), Pad> rngs{
|
||||
&dpf::uniform_sample<simde__m128i>, {}};
|
||||
auto ds = dpf::make_dpf_doerner_shelat(r0, r1, rngs, dpf::ic(p, q, beta));
|
||||
for (int x = 0; x < 256; x += 5)
|
||||
{
|
||||
const auto dealer_y = dpf::reconstruct(
|
||||
dpf::eval_point(dpf::ic, dealer.first, static_cast<uint8_t>(x)),
|
||||
dpf::eval_point(dpf::ic, dealer.second, static_cast<uint8_t>(x)));
|
||||
const auto ds_y = dpf::reconstruct(
|
||||
dpf::eval_point(dpf::ic, ds.first, static_cast<uint8_t>(x)),
|
||||
dpf::eval_point(dpf::ic, ds.second, static_cast<uint8_t>(x)));
|
||||
EXPECT_EQ(dealer_y, ds_y) << "x=" << x;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Ic, Geneval)
|
||||
{
|
||||
struct Pad
|
||||
{
|
||||
simde__m128i block() { return dpf::uniform_sample<simde__m128i>(); }
|
||||
uint8_t bit() { return static_cast<uint8_t>(dpf::uniform_sample<uint8_t>() & 1u); }
|
||||
};
|
||||
const uint8_t r0 = 9, r1 = 100, p = 3, q = 50;
|
||||
const uint32_t beta = 4;
|
||||
const uint8_t queries[] = {0, 3, 12, 49, 50, 51, 255};
|
||||
dpf::ds_randomness<decltype(&dpf::uniform_sample<simde__m128i>), Pad> rngs{
|
||||
&dpf::uniform_sample<simde__m128i>, {}};
|
||||
auto opened = dpf::geneval_ic(r0, r1, std::begin(queries), std::end(queries),
|
||||
rngs, dpf::ic(p, q, beta));
|
||||
ASSERT_EQ(opened.party0.size(), 7u);
|
||||
ASSERT_EQ(opened.live_levels, 8u);
|
||||
const uint8_t r = static_cast<uint8_t>(r0 ^ r1);
|
||||
for (std::size_t i = 0; i < 7; ++i)
|
||||
{
|
||||
const uint64_t got = (opened.party0[i] + opened.party1[i]) & 0xffffffffu;
|
||||
const uint64_t w = static_cast<uint64_t>(
|
||||
static_cast<uint8_t>(queries[i] - r));
|
||||
const uint64_t want = (w >= p && w <= q) ? beta : 0u;
|
||||
EXPECT_EQ(got, want) << i;
|
||||
}
|
||||
}
|
||||
|
||||
TEST(Ic, RejectsWrappedBounds)
|
||||
{
|
||||
EXPECT_THROW(dpf::make_dpf(uint8_t{1}, dpf::ic(uint8_t{9}, uint8_t{2}, uint32_t{1})),
|
||||
std::invalid_argument);
|
||||
}
|
||||
|
||||
TEST(Ic, BitPayload)
|
||||
{
|
||||
auto keys = dpf::make_dpf(uint8_t{4},
|
||||
dpf::ic(uint8_t{1}, uint8_t{3}, dpf::bit::one, dpf::bit::zero));
|
||||
for (int x = 0; x < 256; ++x)
|
||||
{
|
||||
const auto y = dpf::reconstruct(
|
||||
dpf::eval_point(dpf::ic, keys.first, static_cast<uint8_t>(x)),
|
||||
dpf::eval_point(dpf::ic, keys.second, static_cast<uint8_t>(x)));
|
||||
const uint64_t w = static_cast<uint64_t>(static_cast<uint8_t>(x - 4));
|
||||
EXPECT_EQ(static_cast<bool>(y), w >= 1 && w <= 3) << x;
|
||||
}
|
||||
}
|
||||
Loading…
Add table
Add a link
Reference in a new issue