Fix SeedSequence SFINAE, SaltedSeedSeq truncation salting, and reseed mixing.
DO_NOT_SUBMIT: Found additional repairs
Custom `SeedSequence` types, `absl::SeedSeq` overloads, and engine seeding
previously had several correctness gaps:
* Passing an lvalue or `const` `absl::SeedSeq` to `absl::BitGen` or
`absl::InsecureBitGen` copied or re-wrapped it in another `SaltedSeedSeq`,
double-salting outputs or dropping entropy from stateful zero-size seeders;
brace-moving `absl::SeedSeq b{std::move(a)}` selected the `initializer_list`
constructor instead of moving, and `SaltedSeedSeq` permitted rvalue-reference
template arguments.
* Narrow `SaltedSeedSeq::generate()` requests (`n < min(60, 2 * s)`) mixed salt
only after `[rand.util.seedseq]` truncation collisions had already occurred;
expanding to `min(60, 2 * s)` words and folding both the salt and excess words
into the `n`-word output eliminates collisions up to 1,056 bits (`s <= 33`)
while keeping `size()` and `param()` unsalted.
* Engine and `SaltedSeedSeq` `SeedSequence` overloads lacked uniform
`[rand.req.seedseq]` SFINAE constraints (including `result_type` validation
on `randen_engine` and `pcg_engine` and constraints on
`randen_engine::reseed()`), and seeding `randen_engine` with a 64-bit
`SeedSequence::result_type` overflowed its 32-bit seed buffer sizing.
* `RandenPoolSeedSeq::generate()` wrote raw bytes directly into any pointer or
`std::vector<U>::iterator`, causing trap-representation UB on `bool*` and
corrupting non-integral targets assignable from `uint32_t`.
* `randen_engine` decoupled `RandenPoolSeedSeq` via `IsDirectEntropySeedSeq`
(drawing 8 pool words directly into two even 128-bit rate lanes rather than
inferring pool seeding from `seq.size() == 0`), and `reseed(seq)` now permutes
and domain-separates capacity before absorbing seed material while keeping all
constructors and `seed()` streams bit-identical.
PiperOrigin-RevId: 1022538016
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt
index cef4ab5..7e4b1d1 100644
--- a/absl/random/CMakeLists.txt
+++ b/absl/random/CMakeLists.txt
@@ -688,9 +688,11 @@
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
+ absl::config
absl::inlined_vector
absl::optional
absl::random_internal_seed_material
+ absl::random_internal_traits
absl::span
absl::type_traits
)
@@ -774,6 +776,7 @@
absl::random_internal_entropy_pool
absl::random_internal_salted_seed_seq
absl::random_internal_seed_material
+ absl::random_internal_traits
absl::type_traits
)
@@ -788,10 +791,12 @@
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
+ absl::bits
absl::config
absl::int128
absl::random_internal_fastmath
absl::random_internal_iostream_state_saver
+ absl::random_internal_traits
absl::type_traits
)
@@ -806,9 +811,11 @@
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
+ absl::config
absl::endian
absl::random_internal_iostream_state_saver
absl::random_internal_randen
+ absl::random_internal_traits
absl::raw_logging_internal
absl::type_traits
)
@@ -1073,6 +1080,7 @@
absl::random_random
absl::synchronization
absl::type_traits
+ GTest::gmock
GTest::gtest_main
)
@@ -1121,6 +1129,7 @@
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
+ absl::config
absl::random_internal_explicit_seed_seq
absl::random_internal_pcg_engine
absl::time
@@ -1139,6 +1148,7 @@
LINKOPTS
${ABSL_DEFAULT_LINKOPTS}
DEPS
+ absl::config
absl::log
absl::random_internal_explicit_seed_seq
absl::random_internal_randen_engine
diff --git a/absl/random/internal/BUILD.bazel b/absl/random/internal/BUILD.bazel
index 04f9a27..251a393 100644
--- a/absl/random/internal/BUILD.bazel
+++ b/absl/random/internal/BUILD.bazel
@@ -239,6 +239,7 @@
linkopts = ABSL_DEFAULT_LINKOPTS,
deps = [
":seed_material",
+ ":traits",
"//absl/base:config",
"//absl/container:inlined_vector",
"//absl/meta:type_traits",
@@ -310,6 +311,7 @@
":entropy_pool",
":salted_seed_seq",
":seed_material",
+ ":traits",
"//absl/base:config",
"//absl/container:inlined_vector",
"//absl/meta:type_traits",
@@ -324,6 +326,7 @@
deps = [
":fastmath",
":iostream_state_saver",
+ ":traits",
"//absl/base:config",
"//absl/meta:type_traits",
"//absl/numeric:bits",
@@ -341,6 +344,7 @@
deps = [
":iostream_state_saver",
":randen",
+ ":traits",
"//absl/base:config",
"//absl/base:endian",
"//absl/meta:type_traits",
@@ -689,6 +693,7 @@
deps = [
":explicit_seed_seq",
":pcg_engine",
+ "//absl/base:config",
"@googletest//:gtest",
"@googletest//:gtest_main",
],
@@ -705,6 +710,7 @@
deps = [
":explicit_seed_seq",
":randen_engine",
+ "//absl/base:config",
"//absl/log",
"//absl/time",
"@googletest//:gtest",
diff --git a/absl/random/internal/nonsecure_base.h b/absl/random/internal/nonsecure_base.h
index d1442f8..ec4604e 100644
--- a/absl/random/internal/nonsecure_base.h
+++ b/absl/random/internal/nonsecure_base.h
@@ -29,11 +29,47 @@
#include "absl/random/internal/entropy_pool.h"
#include "absl/random/internal/salted_seed_seq.h"
#include "absl/random/internal/seed_material.h"
+#include "absl/random/internal/traits.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
namespace random_internal {
+// True when `Iterator` is a known contiguous mutable iterator over non-bool
+// integral elements (`U*` or `std::vector<U>::iterator`) whose object
+// representation can be filled directly with random bytes. Excludes `bool`
+// (trap representations), non-integral types (arbitrary object layout),
+// `const`/`volatile` pointees, and proxy references, without instantiating
+// `std::iterator_traits<void*>` (ill-formed in C++17) or `std::vector<U>` for
+// non-qualifying `U`.
+template <typename Iterator, bool IsPointer = std::is_pointer_v<Iterator>,
+ typename = void>
+struct IsRandenPoolContiguousIterator : std::false_type {};
+
+template <typename Iterator>
+struct IsRandenPoolContiguousIterator<Iterator, true, void>
+ : std::bool_constant<
+ std::is_same_v<std::remove_pointer_t<Iterator>,
+ std::remove_cv_t<std::remove_pointer_t<Iterator>>> &&
+ std::is_integral_v<std::remove_pointer_t<Iterator>> &&
+ !std::is_same_v<std::remove_pointer_t<Iterator>, bool>> {};
+
+template <typename Iterator>
+struct IsRandenPoolContiguousIterator<
+ Iterator, false,
+ std::enable_if_t<
+ std::is_same_v<typename std::iterator_traits<Iterator>::value_type,
+ absl::remove_cvref_t<typename std::iterator_traits<
+ Iterator>::value_type>> &&
+ std::is_integral_v<
+ typename std::iterator_traits<Iterator>::value_type> &&
+ !std::is_same_v<typename std::iterator_traits<Iterator>::value_type,
+ bool> &&
+ std::is_same_v<typename std::iterator_traits<Iterator>::reference,
+ typename std::iterator_traits<Iterator>::value_type&>>>
+ : std::is_same<Iterator, typename std::vector<typename std::iterator_traits<
+ Iterator>::value_type>::iterator> {};
+
// RandenPoolSeedSeq is a custom seed sequence type where generate() fills the
// provided buffer via the RandenPool entropy source.
class RandenPoolSeedSeq {
@@ -54,16 +90,16 @@
template <typename RandomAccessIterator>
void generate_impl(BufferTag, RandomAccessIterator begin,
RandomAccessIterator end) {
- const size_t n = std::distance(begin, end);
+ const size_t n = static_cast<size_t>(std::distance(begin, end));
absl::InlinedVector<uint32_t, 8> data(n, 0);
- GetEntropyFromRandenPool(data.begin(), sizeof(data[0]) * n);
+ GetEntropyFromRandenPool(data.data(), sizeof(data[0]) * n);
std::copy(std::begin(data), std::end(data), begin);
}
public:
using result_type = uint32_t;
- size_t size() { return 0; }
+ size_t size() const { return 0; }
template <typename OutIterator>
void param(OutIterator) const {}
@@ -72,16 +108,13 @@
void generate(RandomAccessIterator begin, RandomAccessIterator end) {
// RandomAccessIterator must be assignable from uint32_t
if (begin != end) {
- using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
- // ContiguousTag indicates the common case of a known contiguous buffer,
- // which allows directly filling the buffer. In C++20,
- // std::contiguous_iterator_tag provides a mechanism for testing this
- // capability, however until Abseil's support requirements allow us to
- // assume C++20, limit checks to a few common cases.
+ // ContiguousTag indicates the common case of a known contiguous buffer of
+ // mutable non-bool integral values, which allows directly filling the
+ // buffer. In C++20, std::contiguous_iterator_tag provides a mechanism for
+ // testing this capability, however until Abseil's support requirements
+ // allow us to assume C++20, limit checks to a few common cases.
using TagType = std::conditional_t<
- (std::is_pointer_v<RandomAccessIterator> ||
- std::is_same_v<RandomAccessIterator,
- typename std::vector<U>::iterator>),
+ IsRandenPoolContiguousIterator<RandomAccessIterator>::value,
ContiguousTag, BufferTag>;
generate_impl(TagType{}, begin, end);
@@ -89,6 +122,65 @@
}
};
+template <>
+struct IsDirectEntropySeedSeq<RandenPoolSeedSeq> : std::true_type {};
+
+// Detects whether `URBG` can be constructed directly from `seq` (if it is
+// already a `SaltedSeedSeq`) or from a stack-scoped non-owning
+// `SaltedSeedSeq<std::remove_reference_t<SSeq>&>`.
+template <typename URBG, typename SSeq, typename = void>
+struct CanDirectlySeedURBG : std::false_type {};
+
+template <typename URBG, typename SSeq>
+struct CanDirectlySeedURBG<URBG, SSeq,
+ std::enable_if_t<HasSeedSeqGenerate<SSeq>::value>>
+ : std::is_constructible<
+ URBG,
+ std::conditional_t<is_salted_seed_seq<SSeq>::value,
+ std::remove_reference_t<SSeq>&,
+ SaltedSeedSeq<std::remove_reference_t<SSeq>&>&>> {
+};
+
+template <typename SSeq, typename ResultType, typename = void>
+struct HasSeedSeqParam : std::false_type {};
+
+template <typename SSeq, typename ResultType>
+struct HasSeedSeqParam<
+ SSeq, ResultType,
+ std::void_t<decltype(std::declval<std::remove_reference_t<SSeq>&>().param(
+ std::back_inserter(
+ std::declval<absl::InlinedVector<ResultType, 8>&>())))>>
+ : std::true_type {};
+
+template <typename URBG, typename SSeq, typename Target, typename ResultType,
+ typename = void>
+struct CanMakeSaltedSeedSeqImpl : std::false_type {};
+
+template <typename URBG, typename SSeq, typename Target, typename ResultType>
+struct CanMakeSaltedSeedSeqImpl<
+ URBG, SSeq, Target, ResultType,
+ std::enable_if_t<std::conjunction_v<
+ std::is_constructible<
+ SaltedSeedSeq<Target>,
+ typename absl::InlinedVector<ResultType, 8>::iterator,
+ typename absl::InlinedVector<ResultType, 8>::iterator>,
+ HasSeedSeqParam<SSeq, ResultType>>>>
+ : std::is_constructible<URBG, SaltedSeedSeq<Target>&> {};
+
+// Detects whether `MakeSaltedSeedSeq(seq)` can construct a mutable owning
+// `SaltedSeedSeq` from `seq` via `seq.param(...)` (e.g. `const std::seed_seq&`
+// or `const absl::SeedSeq&`) that can construct `URBG`.
+template <typename URBG, typename SSeq, typename = void>
+struct CanMakeSaltedSeedSeq : std::false_type {};
+
+template <typename URBG, typename SSeq>
+struct CanMakeSaltedSeedSeq<URBG, SSeq,
+ std::enable_if_t<HasSeedSeqGenerate<
+ typename UnwrappedSeedSeq<SSeq>::type>::value>>
+ : CanMakeSaltedSeedSeqImpl<
+ URBG, SSeq, typename UnwrappedSeedSeq<SSeq>::type,
+ typename UnwrappedSeedSeq<SSeq>::type::result_type> {};
+
// Each instance of NonsecureURBGBase<URBG> will be seeded by variates produced
// by a thread-unique URBG-instance.
template <typename URBG, typename Seeder = RandenPoolSeedSeq>
@@ -106,8 +198,14 @@
NonsecureURBGBase& operator=(NonsecureURBGBase&&) = default;
// Constructor using a seed
- template <class SSeq, typename = typename std::enable_if_t<
- !std::is_same_v<SSeq, NonsecureURBGBase>>>
+ template <
+ class SSeq,
+ typename = std::enable_if_t<
+ !std::is_same_v<absl::remove_cvref_t<SSeq>, NonsecureURBGBase> &&
+ !std::is_base_of_v<NonsecureURBGBase, absl::remove_cvref_t<SSeq>> &&
+ !std::is_convertible_v<SSeq, result_type>>,
+ typename = std::enable_if_t<std::disjunction_v<
+ CanDirectlySeedURBG<URBG, SSeq>, CanMakeSaltedSeedSeq<URBG, SSeq>>>>
explicit NonsecureURBGBase(SSeq&& seq)
: urbg_(ConstructURBG(std::forward<SSeq>(seq))) {}
@@ -145,9 +243,17 @@
template <typename SSeq>
static URBG ConstructURBG(SSeq&& seq) { // NOLINT(runtime/references)
- auto salted_seq =
- random_internal::MakeSaltedSeedSeq(std::forward<SSeq>(seq));
- return URBG(salted_seq);
+ if constexpr (CanDirectlySeedURBG<URBG, SSeq>::value) {
+ if constexpr (is_salted_seed_seq<SSeq>::value) {
+ return URBG(seq);
+ } else {
+ SaltedSeedSeq<std::remove_reference_t<SSeq>&> salted_seq(seq);
+ return URBG(salted_seq);
+ }
+ } else {
+ auto salted_seq = random_internal::MakeSaltedSeedSeq(seq);
+ return URBG(salted_seq);
+ }
}
URBG urbg_;
diff --git a/absl/random/internal/nonsecure_base_test.cc b/absl/random/internal/nonsecure_base_test.cc
index 61f49cd..be6f28d 100644
--- a/absl/random/internal/nonsecure_base_test.cc
+++ b/absl/random/internal/nonsecure_base_test.cc
@@ -15,8 +15,12 @@
#include "absl/random/internal/nonsecure_base.h"
#include <algorithm>
+#include <array>
+#include <cmath>
#include <cstddef>
#include <cstdint>
+#include <cstring>
+#include <deque>
#include <iterator>
#include <random>
#include <thread> // NOLINT
@@ -24,6 +28,7 @@
#include <utility>
#include <vector>
+#include "gmock/gmock.h"
#include "gtest/gtest.h"
#include "absl/algorithm/container.h"
#include "absl/container/flat_hash_set.h"
@@ -76,6 +81,18 @@
static_assert(!std::is_copy_constructible_v<E>,
"NonsecureURBGBase should not be copy constructible");
+ static_assert(!std::is_constructible_v<E, E&>,
+ "NonsecureURBGBase should not be constructible from non-const "
+ "lvalue reference");
+ static_assert(!std::is_constructible_v<E, int>,
+ "NonsecureURBGBase should not be constructible from int");
+ static_assert(!std::is_constructible_v<E, T>,
+ "NonsecureURBGBase should not be constructible from "
+ "result_type");
+ static_assert(!std::is_constructible_v<absl::BitGen, int>,
+ "BitGen should not be constructible from int");
+ static_assert(!std::is_constructible_v<absl::BitGen, absl::BitGen&>,
+ "BitGen should not be constructible from BitGen&");
static_assert(!std::is_copy_assignable_v<E>,
"NonsecureURBGBase should not be copy assignable");
@@ -265,3 +282,548 @@
seeder.generate(std::begin(state), std::end(state));
EXPECT_FALSE(state[0] == 0 && state[1] == 0);
}
+
+TEST(RandenPoolSeedSeqTest, SizeIsConstAndZero) {
+ const absl::random_internal::RandenPoolSeedSeq const_seeder;
+ EXPECT_EQ(const_seeder.size(), 0u);
+}
+
+namespace {
+struct AssignableSeedSink {
+ static constexpr uint64_t kHeadCanary = 0x1122334455667788ull;
+ static constexpr uint64_t kTailCanary = 0x99aabbccddeeff00ull;
+
+ uint64_t head_canary = kHeadCanary;
+ uint32_t value = 0;
+ int assignments = 0;
+ uint64_t tail_canary = kTailCanary;
+
+ AssignableSeedSink& operator=(uint32_t v) {
+ value = v;
+ ++assignments;
+ return *this;
+ }
+};
+} // namespace
+
+TEST(RandenPoolSeedSeqTest, ContiguousIteratorTraitGuardsInvalidTypes) {
+ using absl::random_internal::IsRandenPoolContiguousIterator;
+
+ static_assert(IsRandenPoolContiguousIterator<uint8_t*>::value);
+ static_assert(IsRandenPoolContiguousIterator<uint16_t*>::value);
+ static_assert(IsRandenPoolContiguousIterator<uint32_t*>::value);
+ static_assert(IsRandenPoolContiguousIterator<uint64_t*>::value);
+ static_assert(IsRandenPoolContiguousIterator<int32_t*>::value);
+ static_assert(IsRandenPoolContiguousIterator<int64_t*>::value);
+ static_assert(
+ IsRandenPoolContiguousIterator<std::vector<uint32_t>::iterator>::value);
+ static_assert(
+ IsRandenPoolContiguousIterator<std::vector<uint64_t>::iterator>::value);
+ static_assert(
+ IsRandenPoolContiguousIterator<std::vector<int32_t>::iterator>::value);
+
+ // Exclude bool (trap representations), non-integral types (arbitrary object
+ // representations), const/volatile pointees, non-contiguous iterators, and
+ // non-iterators.
+ static_assert(!IsRandenPoolContiguousIterator<bool*>::value);
+ static_assert(!IsRandenPoolContiguousIterator<const bool*>::value);
+ static_assert(
+ !IsRandenPoolContiguousIterator<std::vector<bool>::iterator>::value);
+ static_assert(!IsRandenPoolContiguousIterator<const uint32_t*>::value);
+ static_assert(!IsRandenPoolContiguousIterator<volatile uint32_t*>::value);
+ static_assert(!IsRandenPoolContiguousIterator<
+ std::vector<uint32_t>::const_iterator>::value);
+ static_assert(!IsRandenPoolContiguousIterator<float*>::value);
+ static_assert(!IsRandenPoolContiguousIterator<double*>::value);
+ static_assert(
+ !IsRandenPoolContiguousIterator<std::vector<double>::iterator>::value);
+ static_assert(!IsRandenPoolContiguousIterator<AssignableSeedSink*>::value);
+ static_assert(!IsRandenPoolContiguousIterator<
+ std::vector<AssignableSeedSink>::iterator>::value);
+ static_assert(
+ !IsRandenPoolContiguousIterator<std::deque<uint32_t>::iterator>::value);
+ static_assert(!IsRandenPoolContiguousIterator<void*>::value);
+ static_assert(!IsRandenPoolContiguousIterator<const void*>::value);
+ static_assert(!IsRandenPoolContiguousIterator<void (*)()>::value);
+ static_assert(!IsRandenPoolContiguousIterator<int>::value);
+
+ static_assert(absl::random_internal::IsDirectEntropySeedSeq<
+ absl::random_internal::RandenPoolSeedSeq>::value);
+ static_assert(
+ !absl::random_internal::IsDirectEntropySeedSeq<std::seed_seq>::value);
+}
+
+TEST(RandenPoolSeedSeqTest, SeederAvoidsTrapRepresentationsOnBool) {
+ absl::random_internal::RandenPoolSeedSeq seeder;
+
+ bool bool_array[64] = {};
+ seeder.generate(std::begin(bool_array), std::end(bool_array));
+ int true_count = 0;
+ for (const bool& b : bool_array) {
+ unsigned char raw = 0xff;
+ static_assert(sizeof(bool) == sizeof(unsigned char));
+ std::memcpy(&raw, &b, sizeof(raw));
+ EXPECT_LE(raw, 1u);
+ if (b) ++true_count;
+ }
+ EXPECT_GT(true_count, 0);
+
+ std::vector<bool> bool_vec(16, false);
+ seeder.generate(bool_vec.begin(), bool_vec.end());
+ EXPECT_THAT(bool_vec, testing::Contains(true));
+}
+
+TEST(RandenPoolSeedSeqTest, SeederUsesAssignmentForNonIntegralAndBufferPaths) {
+ absl::random_internal::RandenPoolSeedSeq seeder;
+
+ // Size 12 exceeds InlinedVector<uint32_t, 8>'s inline capacity to exercise
+ // heap-backed BufferTag generation and scrubbing as well.
+ AssignableSeedSink sink_array[12];
+ seeder.generate(std::begin(sink_array), std::end(sink_array));
+ bool any_nonzero = false;
+ for (const auto& s : sink_array) {
+ EXPECT_EQ(s.head_canary, AssignableSeedSink::kHeadCanary);
+ EXPECT_EQ(s.tail_canary, AssignableSeedSink::kTailCanary);
+ EXPECT_EQ(s.assignments, 1);
+ any_nonzero = any_nonzero || (s.value != 0);
+ }
+ EXPECT_TRUE(any_nonzero);
+
+ std::vector<AssignableSeedSink> sink_vec(6);
+ seeder.generate(sink_vec.begin(), sink_vec.end());
+ for (const auto& s : sink_vec) {
+ EXPECT_EQ(s.head_canary, AssignableSeedSink::kHeadCanary);
+ EXPECT_EQ(s.tail_canary, AssignableSeedSink::kTailCanary);
+ EXPECT_EQ(s.assignments, 1);
+ }
+
+ double fp_array[8] = {};
+ seeder.generate(std::begin(fp_array), std::end(fp_array));
+ for (double d : fp_array) {
+ EXPECT_TRUE(std::isfinite(d));
+ EXPECT_GE(d, 0.0);
+ EXPECT_LE(d, static_cast<double>(UINT32_MAX));
+ }
+
+ volatile uint32_t vol_array[4] = {};
+ seeder.generate(std::begin(vol_array), std::end(vol_array));
+ EXPECT_FALSE(vol_array[0] == 0 && vol_array[1] == 0 && vol_array[2] == 0 &&
+ vol_array[3] == 0);
+
+ std::deque<uint32_t> dq(12, 0);
+ seeder.generate(dq.begin(), dq.end());
+ EXPECT_THAT(dq, testing::Contains(testing::Ne(0u)));
+}
+
+TEST(NonsecureURBGBase, LvalueAndRvalueSaltedSeedSeqMatch) {
+ absl::SeedSeq s1{1, 2, 3, 4};
+ absl::SeedSeq s2{1, 2, 3, 4};
+
+ absl::BitGen gen_lvalue(s1);
+ absl::BitGen gen_rvalue(std::move(s2));
+ for (int i = 0; i < 16; ++i) {
+ EXPECT_EQ(gen_lvalue(), gen_rvalue());
+ }
+}
+
+namespace {
+template <typename URBG>
+std::array<typename URBG::result_type, 16> GenerateSequence(URBG& gen) {
+ std::array<typename URBG::result_type, 16> out;
+ for (auto& value : out) {
+ value = gen();
+ }
+ return out;
+}
+
+template <typename ResultT, bool kConstGenerate = true, uint32_t kStart = 1,
+ bool kConstSize = true, bool kHasSize = true>
+struct TestSeedSeq {
+ using result_type = ResultT;
+ size_t count = 4;
+ uint32_t start = kStart;
+
+ explicit TestSeedSeq(size_t n = 4) : count(n) {}
+
+ template <bool H = kHasSize, bool C = kConstSize,
+ std::enable_if_t<H && C, int> = 0>
+ size_t size() const {
+ return count;
+ }
+ template <bool H = kHasSize, bool C = kConstSize,
+ std::enable_if_t<H && !C, int> = 0>
+ size_t size() {
+ return count;
+ }
+
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<C, int> = 0>
+ void generate(OutIt begin, OutIt end) const {
+ uint32_t v = start;
+ for (OutIt it = begin; it != end; ++it) *it = v++;
+ }
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<!C, int> = 0>
+ void generate(OutIt begin, OutIt end) {
+ uint32_t v = start;
+ for (OutIt it = begin; it != end; ++it) *it = v++;
+ }
+};
+
+struct NoResultTypeSeedSeq {
+ size_t size() const { return 2; }
+ template <typename OutIt>
+ void generate(OutIt begin, OutIt end) const {
+ uint32_t v = 1;
+ for (OutIt it = begin; it != end; ++it) *it = v++;
+ }
+};
+
+template <bool kConstGenerate>
+struct ZeroSizeCounterSeedSeq {
+ using result_type = uint32_t;
+ mutable uint32_t counter = 1;
+ size_t size() const { return 0; }
+ template <typename OutIt>
+ void param(OutIt) const {}
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<C, int> = 0>
+ void generate(OutIt begin, OutIt end) const {
+ for (OutIt it = begin; it != end; ++it) *it = counter++;
+ }
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<!C, int> = 0>
+ void generate(OutIt begin, OutIt end) {
+ for (OutIt it = begin; it != end; ++it) *it = counter++;
+ }
+};
+
+template <bool kConstGenerate, bool kHasSize>
+struct TestParamSeedSeq
+ : TestSeedSeq<uint32_t, kConstGenerate, 1, /*kConstSize=*/false, kHasSize> {
+ std::vector<uint32_t> values;
+ TestParamSeedSeq() = default;
+ template <typename It>
+ TestParamSeedSeq(It begin, It end) : values(begin, end) {
+ this->count = values.size();
+ this->start = values.empty() ? 1u : values[0];
+ }
+ template <typename OutIt>
+ void param(OutIt out) const {
+ std::copy(values.begin(), values.end(), out);
+ }
+};
+
+using StatefulZeroSizeSeedSeq = ZeroSizeCounterSeedSeq<false>;
+using ConstGenerateZeroSizeSeedSeq = ZeroSizeCounterSeedSeq<true>;
+using SeedSeq64 = TestSeedSeq<uint64_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SeedSeq32 = TestSeedSeq<uint32_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SignedResultTypeSeedSeq = TestSeedSeq<int32_t>;
+using NarrowResultTypeSeedSeq = TestSeedSeq<uint16_t>;
+using VoidResultTypeSeedSeq = TestSeedSeq<void>;
+using ConstGenerateNonConstSizeSeedSeq =
+ TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/false>;
+using ConstGenerateNoSizeSeedSeq =
+ TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/true,
+ /*kHasSize=*/false>;
+using ConstGenerateNonConstSizeWithParamSeedSeq = TestParamSeedSeq<true, true>;
+using ConstParamNoSizeSeedSeq = TestParamSeedSeq<false, false>;
+} // namespace
+
+TEST(NonsecureURBGBase, SeedSeqConstructibilityTraits) {
+ static_assert(std::is_constructible_v<absl::BitGen, absl::SeedSeq&>);
+ static_assert(std::is_constructible_v<absl::BitGen, absl::SeedSeq&&>);
+ static_assert(std::is_constructible_v<absl::BitGen, const absl::SeedSeq&>);
+ static_assert(std::is_constructible_v<absl::BitGen, const absl::SeedSeq&&>);
+ static_assert(std::is_constructible_v<absl::BitGen, std::seed_seq&>);
+ static_assert(std::is_constructible_v<absl::BitGen, std::seed_seq&&>);
+ static_assert(std::is_constructible_v<absl::BitGen, const std::seed_seq&>);
+ static_assert(std::is_constructible_v<absl::BitGen, const std::seed_seq&&>);
+ static_assert(
+ std::is_constructible_v<absl::BitGen, StatefulZeroSizeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::BitGen, const StatefulZeroSizeSeedSeq&>);
+ static_assert(std::is_constructible_v<absl::BitGen,
+ const ConstGenerateZeroSizeSeedSeq&>);
+ static_assert(std::is_constructible_v<absl::BitGen, SeedSeq64&>);
+ static_assert(std::is_constructible_v<absl::BitGen, SeedSeq64&&>);
+ static_assert(!std::is_constructible_v<absl::BitGen, NoResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::BitGen, const NoResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::BitGen, SignedResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::BitGen, NarrowResultTypeSeedSeq&>);
+ static_assert(!std::is_constructible_v<absl::BitGen, VoidResultTypeSeedSeq&>);
+ static_assert(
+ std::is_constructible_v<absl::BitGen, ConstGenerateNonConstSizeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::BitGen,
+ const ConstGenerateNonConstSizeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::BitGen, ConstGenerateNoSizeSeedSeq&>);
+ static_assert(!std::is_constructible_v<absl::BitGen,
+ const ConstGenerateNoSizeSeedSeq&>);
+ static_assert(
+ std::is_constructible_v<
+ absl::BitGen, const ConstGenerateNonConstSizeWithParamSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::BitGen, const ConstParamNoSizeSeedSeq&>);
+
+ static_assert(
+ std::is_constructible_v<absl::InsecureBitGen, const absl::SeedSeq&>);
+ static_assert(
+ std::is_constructible_v<absl::InsecureBitGen, const std::seed_seq&>);
+ static_assert(!std::is_constructible_v<absl::InsecureBitGen,
+ const StatefulZeroSizeSeedSeq&>);
+ static_assert(std::is_constructible_v<absl::InsecureBitGen,
+ const ConstGenerateZeroSizeSeedSeq&>);
+ static_assert(std::is_constructible_v<absl::InsecureBitGen, SeedSeq64&>);
+ static_assert(
+ !std::is_constructible_v<absl::InsecureBitGen, NoResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::InsecureBitGen, SignedResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::InsecureBitGen, NarrowResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<absl::InsecureBitGen, VoidResultTypeSeedSeq&>);
+ static_assert(
+ std::is_constructible_v<absl::InsecureBitGen,
+ const ConstGenerateNonConstSizeSeedSeq&>);
+ static_assert(std::is_constructible_v<absl::InsecureBitGen,
+ const ConstGenerateNoSizeSeedSeq&>);
+ static_assert(std::is_constructible_v<
+ absl::InsecureBitGen,
+ const ConstGenerateNonConstSizeWithParamSeedSeq&>);
+ static_assert(std::is_constructible_v<absl::InsecureBitGen,
+ const ConstParamNoSizeSeedSeq&>);
+
+ static_assert(std::is_constructible_v<ExampleNonsecureURBG, SeedSeq64&>);
+ static_assert(
+ !std::is_constructible_v<ExampleNonsecureURBG, NoResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<ExampleNonsecureURBG, SignedResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<ExampleNonsecureURBG, NarrowResultTypeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<ExampleNonsecureURBG, VoidResultTypeSeedSeq&>);
+ static_assert(
+ std::is_constructible_v<ExampleNonsecureURBG,
+ const ConstGenerateNonConstSizeSeedSeq&>);
+ static_assert(std::is_constructible_v<ExampleNonsecureURBG,
+ const ConstGenerateNoSizeSeedSeq&>);
+}
+
+TEST(NonsecureURBGBase, ConstSaltedSeedSeqMatchesMutable) {
+ absl::SeedSeq mutable_lvalue{1, 2, 3, 4};
+ absl::SeedSeq mutable_rvalue{1, 2, 3, 4};
+ const absl::SeedSeq const_lvalue{1, 2, 3, 4};
+ const absl::SeedSeq const_rvalue{1, 2, 3, 4};
+
+ absl::BitGen bitgen_mutable_lvalue(mutable_lvalue);
+ absl::BitGen bitgen_mutable_rvalue(std::move(mutable_rvalue));
+ absl::BitGen bitgen_const_lvalue(const_lvalue);
+ absl::BitGen bitgen_const_rvalue(std::move(const_rvalue));
+ const auto expected_bitgen = GenerateSequence(bitgen_mutable_lvalue);
+ EXPECT_THAT(GenerateSequence(bitgen_mutable_rvalue),
+ testing::Eq(expected_bitgen));
+ EXPECT_THAT(GenerateSequence(bitgen_const_lvalue),
+ testing::Eq(expected_bitgen));
+ EXPECT_THAT(GenerateSequence(bitgen_const_rvalue),
+ testing::Eq(expected_bitgen));
+
+ absl::InsecureBitGen insecure_mutable(mutable_lvalue);
+ absl::InsecureBitGen insecure_const(const_lvalue);
+ EXPECT_THAT(GenerateSequence(insecure_const),
+ testing::Eq(GenerateSequence(insecure_mutable)));
+}
+
+TEST(NonsecureURBGBase, ConstStdSeedSeqMatchesMutable) {
+ std::seed_seq mutable_lvalue{1, 2, 3, 4};
+ std::seed_seq mutable_rvalue{1, 2, 3, 4};
+ const std::seed_seq const_lvalue{1, 2, 3, 4};
+ const std::seed_seq const_rvalue{1, 2, 3, 4};
+
+ absl::BitGen bitgen_mutable_lvalue(mutable_lvalue);
+ absl::BitGen bitgen_mutable_rvalue(std::move(mutable_rvalue));
+ absl::BitGen bitgen_const_lvalue(const_lvalue);
+ absl::BitGen bitgen_const_rvalue(std::move(const_rvalue));
+ const auto expected_bitgen = GenerateSequence(bitgen_mutable_lvalue);
+ EXPECT_THAT(GenerateSequence(bitgen_mutable_rvalue),
+ testing::Eq(expected_bitgen));
+ EXPECT_THAT(GenerateSequence(bitgen_const_lvalue),
+ testing::Eq(expected_bitgen));
+ EXPECT_THAT(GenerateSequence(bitgen_const_rvalue),
+ testing::Eq(expected_bitgen));
+
+ absl::InsecureBitGen insecure_mutable(mutable_lvalue);
+ absl::InsecureBitGen insecure_const(const_lvalue);
+ EXPECT_THAT(GenerateSequence(insecure_const),
+ testing::Eq(GenerateSequence(insecure_mutable)));
+}
+
+TEST(NonsecureURBGBase, StatefulZeroSizeSeedSeqPreservesEntropy) {
+ StatefulZeroSizeSeedSeq seeder;
+ absl::BitGen gen1(seeder);
+ absl::BitGen gen2(seeder);
+ EXPECT_THAT(GenerateSequence(gen1), testing::Ne(GenerateSequence(gen2)));
+}
+
+TEST(NonsecureURBGBase, ConstGenerateZeroSizeSeedSeqPreservesEntropy) {
+ const ConstGenerateZeroSizeSeedSeq seeder;
+ absl::BitGen gen1(seeder);
+ absl::BitGen gen2(seeder);
+ EXPECT_THAT(GenerateSequence(gen1), testing::Ne(GenerateSequence(gen2)));
+}
+
+TEST(NonsecureURBGBase, SeedSequenceWith64BitResultTypeMatches32Bit) {
+ SeedSeq64 seq64;
+ SeedSeq32 seq32;
+
+ absl::BitGen bitgen64(seq64);
+ absl::BitGen bitgen32(seq32);
+ EXPECT_THAT(GenerateSequence(bitgen64),
+ testing::Eq(GenerateSequence(bitgen32)));
+
+ absl::InsecureBitGen insecure64(seq64);
+ absl::InsecureBitGen insecure32(seq32);
+ EXPECT_THAT(GenerateSequence(insecure64),
+ testing::Eq(GenerateSequence(insecure32)));
+
+ ExampleNonsecureURBG example64(seq64);
+ ExampleNonsecureURBG example32(seq32);
+ EXPECT_THAT(GenerateSequence(example64),
+ testing::Eq(GenerateSequence(example32)));
+}
+
+TEST(NonsecureURBGBase, ConstFallbackViaParamMatchesDirectSeeding) {
+ std::array<uint32_t, 3> init = {10, 20, 30};
+ ConstGenerateNonConstSizeWithParamSeedSeq mutable_with_param(init.begin(),
+ init.end());
+ const ConstGenerateNonConstSizeWithParamSeedSeq const_with_param(init.begin(),
+ init.end());
+ absl::BitGen bitgen_from_mutable_param(mutable_with_param);
+ absl::BitGen bitgen_from_const_param(const_with_param);
+ EXPECT_THAT(GenerateSequence(bitgen_from_const_param),
+ testing::Eq(GenerateSequence(bitgen_from_mutable_param)));
+}
+
+TEST(NonsecureURBGBase, NonConstSizeAndNoSizeSeedSeqs) {
+ ConstGenerateNonConstSizeSeedSeq mutable_non_const_size;
+ absl::BitGen bitgen_mutable(mutable_non_const_size);
+ EXPECT_THAT(GenerateSequence(bitgen_mutable),
+ testing::Ne(std::array<absl::BitGen::result_type, 16>{}));
+
+ const ConstGenerateNonConstSizeSeedSeq const_non_const_size;
+ absl::InsecureBitGen insecure_non_const_size(const_non_const_size);
+ ExampleNonsecureURBG example_non_const_size(const_non_const_size);
+ EXPECT_THAT(GenerateSequence(insecure_non_const_size),
+ testing::Ne(std::array<absl::InsecureBitGen::result_type, 16>{}));
+ EXPECT_THAT(GenerateSequence(example_non_const_size),
+ testing::Ne(std::array<ExampleNonsecureURBG::result_type, 16>{}));
+
+ const ConstGenerateNoSizeSeedSeq const_no_size;
+ absl::InsecureBitGen insecure_no_size(const_no_size);
+ ExampleNonsecureURBG example_no_size(const_no_size);
+ EXPECT_THAT(GenerateSequence(insecure_no_size),
+ testing::Ne(std::array<absl::InsecureBitGen::result_type, 16>{}));
+ EXPECT_THAT(GenerateSequence(example_no_size),
+ testing::Ne(std::array<ExampleNonsecureURBG::result_type, 16>{}));
+
+ std::array<uint32_t, 3> init = {10, 20, 30};
+ const ConstParamNoSizeSeedSeq const_param_no_size(init.begin(), init.end());
+ absl::InsecureBitGen insecure_param_no_size(const_param_no_size);
+ EXPECT_THAT(GenerateSequence(insecure_param_no_size),
+ testing::Ne(std::array<absl::InsecureBitGen::result_type, 16>{}));
+}
+
+TEST(NonsecureURBGBase, SaltedSeedingSeparatesStdSeedSeqCollisionTuples) {
+ if (!absl::random_internal::GetSaltMaterial().has_value()) {
+ return;
+ }
+
+ // s = 2 collision pair at n = 2 (affects BitGen(s=2) and pcg32(SeedSeq)).
+ constexpr uint32_t kS2A[2] = {0x00000003u, 0xef243a0au};
+ constexpr uint32_t kS2B[2] = {0x0b8bb54eu, 0xfaafef55u};
+ {
+ absl::SeedSeq salted_a(std::begin(kS2A), std::end(kS2A));
+ absl::SeedSeq salted_b(std::begin(kS2B), std::end(kS2B));
+ absl::random_internal::pcg32_2018_engine pcg_a(salted_a);
+ absl::random_internal::pcg32_2018_engine pcg_b(salted_b);
+ EXPECT_THAT(GenerateSequence(pcg_a), testing::Ne(GenerateSequence(pcg_b)));
+
+ absl::BitGen bitgen_a(salted_a);
+ absl::BitGen bitgen_b(salted_b);
+ EXPECT_THAT(GenerateSequence(bitgen_a),
+ testing::Ne(GenerateSequence(bitgen_b)));
+
+ std::seed_seq std_a(std::begin(kS2A), std::end(kS2A));
+ std::seed_seq std_b(std::begin(kS2B), std::end(kS2B));
+ absl::BitGen bitgen_std_a(std_a);
+ absl::BitGen bitgen_std_b(std_b);
+ EXPECT_THAT(GenerateSequence(bitgen_std_a),
+ testing::Ne(GenerateSequence(bitgen_std_b)));
+ }
+
+ // s = 3 collision pair at n = 3 (affects BitGen(s=3)).
+ constexpr uint32_t kS3A[3] = {0x0000269du, 0x4cc2d2d4u, 0x507fd03cu};
+ constexpr uint32_t kS3B[3] = {0x00033c9bu, 0xa08a4e6cu, 0x5082e63au};
+ {
+ std::seed_seq std_a(std::begin(kS3A), std::end(kS3A));
+ std::seed_seq std_b(std::begin(kS3B), std::end(kS3B));
+ absl::BitGen bitgen_a(std_a);
+ absl::BitGen bitgen_b(std_b);
+ EXPECT_THAT(GenerateSequence(bitgen_a),
+ testing::Ne(GenerateSequence(bitgen_b)));
+ }
+
+ // s = 4 collision pair at n = 4 (affects InsecureBitGen and BitGen(s=4)).
+ constexpr uint32_t kS4A[4] = {0x00010253u, 0x4c1127d0u, 0xc406ad4cu,
+ 0x13a2704du};
+ constexpr uint32_t kS4B[4] = {0x000135d7u, 0xc89ecda0u, 0x24996d88u,
+ 0x13a2a3d1u};
+ {
+ absl::SeedSeq salted_a(std::begin(kS4A), std::end(kS4A));
+ absl::SeedSeq salted_b(std::begin(kS4B), std::end(kS4B));
+ absl::InsecureBitGen insecure_a(salted_a);
+ absl::InsecureBitGen insecure_b(salted_b);
+ EXPECT_THAT(GenerateSequence(insecure_a),
+ testing::Ne(GenerateSequence(insecure_b)));
+
+ absl::BitGen bitgen_a(salted_a);
+ absl::BitGen bitgen_b(salted_b);
+ EXPECT_THAT(GenerateSequence(bitgen_a),
+ testing::Ne(GenerateSequence(bitgen_b)));
+ }
+
+ // s = 8 collision pairs at n = 8 (BitGen) and n = 4 (InsecureBitGen).
+ constexpr uint32_t kS8N8A[8] = {0x7496df94u, 0x2f701878u, 0xf374430bu,
+ 0x33e4d291u, 0x8e5b51a3u, 0x0f511665u,
+ 0xd44a6ec8u, 0xbb00fd0au};
+ constexpr uint32_t kS8N8B[8] = {0x64e949bau, 0x47fb3261u, 0xdeaae914u,
+ 0xfdd32ba0u, 0xa4d1fd8du, 0x357706e1u,
+ 0xc49cd8eeu, 0xbb01dbdfu};
+ {
+ std::seed_seq std_a(std::begin(kS8N8A), std::end(kS8N8A));
+ std::seed_seq std_b(std::begin(kS8N8B), std::end(kS8N8B));
+ absl::BitGen bitgen_a(std_a);
+ absl::BitGen bitgen_b(std_b);
+ EXPECT_THAT(GenerateSequence(bitgen_a),
+ testing::Ne(GenerateSequence(bitgen_b)));
+ }
+
+ constexpr uint32_t kS8N4A[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+ 0x00000004u, 0x0000bf91u, 0x67c0a593u,
+ 0x313389e7u, 0xee5c8e5cu};
+ constexpr uint32_t kS8N4B[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+ 0x00000004u, 0x00011835u, 0xa5168553u,
+ 0xcee80a7au, 0xee5ce700u};
+ {
+ absl::SeedSeq salted_a(std::begin(kS8N4A), std::end(kS8N4A));
+ absl::SeedSeq salted_b(std::begin(kS8N4B), std::end(kS8N4B));
+ absl::InsecureBitGen insecure_a(salted_a);
+ absl::InsecureBitGen insecure_b(salted_b);
+ EXPECT_THAT(GenerateSequence(insecure_a),
+ testing::Ne(GenerateSequence(insecure_b)));
+ }
+}
diff --git a/absl/random/internal/pcg_engine.h b/absl/random/internal/pcg_engine.h
index e785392..3616163 100644
--- a/absl/random/internal/pcg_engine.h
+++ b/absl/random/internal/pcg_engine.h
@@ -19,9 +19,11 @@
#include <cstdint>
#include <ios>
#include <istream>
+#include <iterator>
#include <limits>
#include <ostream>
#include <type_traits>
+#include <utility>
#include "absl/base/config.h"
#include "absl/meta/type_traits.h"
@@ -29,6 +31,7 @@
#include "absl/numeric/int128.h"
#include "absl/random/internal/fastmath.h"
#include "absl/random/internal/iostream_state_saver.h"
+#include "absl/random/internal/traits.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
@@ -58,6 +61,13 @@
using mix_type = Mix;
using state_type = typename Mix::state_type;
+ template <class SeedSequence>
+ using EnableIfSeedSeq = std::conjunction<
+ std::negation<
+ std::is_base_of<pcg_engine, absl::remove_cvref_t<SeedSequence>>>,
+ std::negation<std::is_convertible<SeedSequence, uint64_t>>,
+ HasSeedSeqGenerate<SeedSequence>>;
+
public:
// C++11 URBG interface:
using result_type = typename Mix::result_type;
@@ -72,8 +82,8 @@
explicit pcg_engine(uint64_t seed_value = 0) { seed(seed_value); }
- template <class SeedSequence, typename = typename std::enable_if_t<
- !std::is_same_v<SeedSequence, pcg_engine>>>
+ template <class SeedSequence,
+ typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
explicit pcg_engine(SeedSequence&& seq) {
seed(seq);
}
@@ -94,10 +104,9 @@
state_ = lcg(tmp + Params::increment());
}
- template <class SeedSequence>
- typename std::enable_if_t<!std::is_convertible_v<SeedSequence, uint64_t>,
- void>
- seed(SeedSequence&& seq) {
+ template <class SeedSequence,
+ typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
+ void seed(SeedSequence&& seq) {
reseed(seq);
}
@@ -213,15 +222,13 @@
template <class SeedSequence>
void reseed(SeedSequence& seq) {
- using sequence_result_type = typename SeedSequence::result_type;
- constexpr size_t kBufferSize =
- sizeof(state_type) / sizeof(sequence_result_type);
- sequence_result_type buffer[kBufferSize];
+ constexpr size_t kBufferSize = sizeof(state_type) / sizeof(uint32_t);
+ uint32_t buffer[kBufferSize];
seq.generate(std::begin(buffer), std::end(buffer));
// Convert the seed output to a single state value.
state_type tmp = buffer[0];
for (size_t i = 1; i < kBufferSize; i++) {
- tmp <<= (sizeof(sequence_result_type) * 8);
+ tmp <<= (sizeof(uint32_t) * 8);
tmp |= buffer[i];
}
state_ = lcg(tmp + params_type::increment());
diff --git a/absl/random/internal/pcg_engine_test.cc b/absl/random/internal/pcg_engine_test.cc
index 938dc85..68daaed 100644
--- a/absl/random/internal/pcg_engine_test.cc
+++ b/absl/random/internal/pcg_engine_test.cc
@@ -29,6 +29,7 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
+#include "absl/base/config.h"
#include "absl/random/internal/explicit_seed_seq.h"
#define UPDATE_GOLDEN 0
@@ -238,6 +239,20 @@
"return type of operator== must be bool");
}
+TYPED_TEST(PCGEngineTest, NonConstCopyConstruction) {
+ using E = TypeParam;
+ E v(123);
+ v();
+
+ E copy_paren(v);
+ E copy_brace{v};
+ EXPECT_TRUE(copy_paren == v);
+ EXPECT_TRUE(copy_brace == v);
+ const auto expected = v();
+ EXPECT_EQ(copy_paren(), expected);
+ EXPECT_EQ(copy_brace(), expected);
+}
+
TYPED_TEST(PCGEngineTest, RandenEngineSFINAETest) {
using engine_type = TypeParam;
using result_type = typename engine_type::result_type;
@@ -407,6 +422,163 @@
FailsLeavingUnchanged());
}
+template <typename Engine, typename Arg, typename = void>
+struct HasSeedMethod : std::false_type {};
+
+template <typename Engine, typename Arg>
+struct HasSeedMethod<
+ Engine, Arg,
+ std::void_t<decltype(std::declval<Engine&>().seed(std::declval<Arg>()))>>
+ : std::true_type {};
+
+template <typename ResultT, bool kConstGenerate = true, uint32_t kStart = 1>
+struct TestSeedSeq {
+ using result_type = ResultT;
+ size_t size() const { return 4; }
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<C, int> = 0>
+ void generate(OutIt begin, OutIt end) const {
+ uint32_t v = kStart;
+ for (OutIt it = begin; it != end; ++it) *it = v++;
+ }
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<!C, int> = 0>
+ void generate(OutIt begin, OutIt end) {
+ uint32_t v = kStart;
+ for (OutIt it = begin; it != end; ++it) *it = v++;
+ }
+};
+
+struct NoResultTypeSeedSeq {
+ size_t size() const { return 4; }
+ template <typename OutIt>
+ void generate(OutIt begin, OutIt end) const {
+ for (OutIt it = begin; it != end; ++it) *it = 1u;
+ }
+};
+
+struct ConvertibleSeedSeq {
+ using result_type = uint32_t;
+ template <typename OutIt>
+ void generate(OutIt begin, OutIt end) const {
+ for (OutIt it = begin; it != end; ++it) *it = 1u;
+ }
+ operator uint64_t() const {
+ return 7u;
+ } // NOLINT(google-explicit-constructor)
+};
+
+template <typename Engine>
+struct DerivedPCG : Engine {
+ using Engine::Engine;
+ void generate(uint32_t*, uint32_t*) const {}
+};
+
+using NonConstGenerateSeedSeq = TestSeedSeq<uint32_t, /*kConstGenerate=*/false>;
+using ConstGenerateSeedSeq = TestSeedSeq<uint32_t>;
+using SeedSeq64 = TestSeedSeq<uint64_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SeedSeq32 = TestSeedSeq<uint32_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SignedResultSeedSeq = TestSeedSeq<int32_t>;
+using NarrowResultSeedSeq = TestSeedSeq<uint16_t>;
+using BoolResultSeedSeq = TestSeedSeq<bool>;
+using ConstResultSeedSeq = TestSeedSeq<const uint32_t>;
+using RefResultSeedSeq = TestSeedSeq<uint32_t&>;
+using VoidResultSeedSeq = TestSeedSeq<void>;
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+struct ThrowingPCGSeedSeq {
+ using result_type = uint32_t;
+ void generate(uint32_t* begin, uint32_t*) {
+ *begin = 0xdeadbeefu;
+ throw 9;
+ }
+};
+#endif
+
+TYPED_TEST(PCGEngineTest, SeedSequenceConstraintsAndConstSeeding) {
+ using engine_type = TypeParam;
+
+ const ConstGenerateSeedSeq const_seq;
+ engine_type engine(const_seq);
+ engine_type reseeded;
+ reseeded.seed(const_seq);
+ EXPECT_TRUE(engine == reseeded);
+
+ DerivedPCG<engine_type> derived(123u);
+ derived();
+ engine_type from_derived(derived);
+ EXPECT_TRUE(from_derived == static_cast<const engine_type&>(derived));
+
+ ConvertibleSeedSeq conv_seq;
+ EXPECT_TRUE(engine_type(conv_seq) == engine_type(7u));
+
+ static_assert(!std::is_constructible_v<engine_type, int*>);
+ static_assert(!std::is_constructible_v<engine_type, void*>);
+ static_assert(!HasSeedMethod<engine_type, int*>::value);
+ static_assert(!HasSeedMethod<engine_type, void*>::value);
+
+ static_assert(std::is_constructible_v<engine_type, std::seed_seq&>);
+ static_assert(std::is_constructible_v<engine_type, std::seed_seq&&>);
+ static_assert(HasSeedMethod<engine_type, std::seed_seq&>::value);
+ static_assert(HasSeedMethod<engine_type, std::seed_seq&&>::value);
+
+ // Test non-const generate() rejection with a dedicated type because MSVC STL
+ // marks std::seed_seq::generate() const while libc++/libstdc++ do not.
+ static_assert(std::is_constructible_v<engine_type, NonConstGenerateSeedSeq&>);
+ static_assert(
+ std::is_constructible_v<engine_type, NonConstGenerateSeedSeq&&>);
+ static_assert(
+ !std::is_constructible_v<engine_type, const NonConstGenerateSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<engine_type, const NonConstGenerateSeedSeq&&>);
+ static_assert(HasSeedMethod<engine_type, NonConstGenerateSeedSeq&>::value);
+ static_assert(
+ !HasSeedMethod<engine_type, const NonConstGenerateSeedSeq&>::value);
+
+ static_assert(
+ std::is_constructible_v<engine_type, const ConstGenerateSeedSeq&>);
+ static_assert(HasSeedMethod<engine_type, const ConstGenerateSeedSeq&>::value);
+
+ // Reject missing or invalid [rand.req.seedseq] result_type across ctor and
+ // seed().
+ static_assert(!std::is_constructible_v<engine_type, NoResultTypeSeedSeq&>);
+ static_assert(!HasSeedMethod<engine_type, NoResultTypeSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<engine_type, SignedResultSeedSeq&>);
+ static_assert(!HasSeedMethod<engine_type, SignedResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<engine_type, NarrowResultSeedSeq&>);
+ static_assert(!HasSeedMethod<engine_type, NarrowResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<engine_type, BoolResultSeedSeq&>);
+ static_assert(!HasSeedMethod<engine_type, BoolResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<engine_type, ConstResultSeedSeq&>);
+ static_assert(!HasSeedMethod<engine_type, ConstResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<engine_type, RefResultSeedSeq&>);
+ static_assert(!HasSeedMethod<engine_type, RefResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<engine_type, VoidResultSeedSeq&>);
+ static_assert(!HasSeedMethod<engine_type, VoidResultSeedSeq&>::value);
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+ ThrowingPCGSeedSeq throwing_seq;
+ const engine_type snapshot = engine;
+ EXPECT_THROW(engine.seed(throwing_seq), int);
+ EXPECT_TRUE(engine == snapshot);
+#endif
+}
+
+TYPED_TEST(PCGEngineTest, SeedSequenceWith64BitResultTypeMatches32Bit) {
+ using engine_type = TypeParam;
+ SeedSeq64 seq64;
+ SeedSeq32 seq32;
+ engine_type e64(seq64);
+ engine_type e32(seq32);
+ EXPECT_TRUE(e64 == e32);
+ EXPECT_EQ(e64(), e32());
+
+ e64.seed(seq64);
+ e32.seed(seq32);
+ EXPECT_TRUE(e64 == e32);
+ EXPECT_EQ(e64(), e32());
+}
+
// ------------------------------------------------------------------
// Stability tests for pcg64_2018_engine
// ------------------------------------------------------------------
diff --git a/absl/random/internal/randen_engine.h b/absl/random/internal/randen_engine.h
index 0f51462..d951166 100644
--- a/absl/random/internal/randen_engine.h
+++ b/absl/random/internal/randen_engine.h
@@ -17,6 +17,7 @@
#include <algorithm>
#include <cinttypes>
+#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <cstring>
@@ -33,6 +34,7 @@
#include "absl/meta/type_traits.h"
#include "absl/random/internal/iostream_state_saver.h"
#include "absl/random/internal/randen.h"
+#include "absl/random/internal/traits.h"
namespace absl {
ABSL_NAMESPACE_BEGIN
@@ -49,6 +51,13 @@
// generator, faster in some benchmarks than std::mt19937_64 and pcg64_c32.
template <typename T>
class alignas(8) randen_engine {
+ template <class SeedSequence>
+ using EnableIfSeedSeq = std::conjunction<
+ std::negation<
+ std::is_base_of<randen_engine, absl::remove_cvref_t<SeedSequence>>>,
+ std::negation<std::is_convertible<SeedSequence, T>>,
+ HasSeedSeqGenerate<SeedSequence>, HasSeedSeqSize<SeedSequence>>;
+
public:
// C++11 URBG interface:
using result_type = T;
@@ -68,8 +77,7 @@
explicit randen_engine(result_type seed_value) { seed(seed_value); }
template <class SeedSequence,
- typename = typename std::enable_if_t<
- !std::is_same_v<SeedSequence, randen_engine>>>
+ typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
explicit randen_engine(SeedSequence&& seq) {
seed(seq);
}
@@ -100,12 +108,11 @@
return little_endian::ToHost(begin[next_++]);
}
- template <class SeedSequence>
- typename std::enable_if_t<!std::is_convertible_v<SeedSequence, result_type>>
- seed(SeedSequence&& seq) {
- // Zeroes the state.
- seed();
- reseed(seq);
+ template <class SeedSequence,
+ typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence>::value>>
+ void seed(SeedSequence&& seq) {
+ // Zeroes the state and absorbs seed material.
+ AbsorbSeed</*kMixExistingState=*/false>(seq);
}
void seed(result_type seed_value = result_type{0}) {
@@ -121,57 +128,10 @@
// Inserts entropy into (part of) the state. Calling this periodically with
// sufficient entropy ensures prediction resistance (attackers cannot predict
// future outputs even if state is compromised).
- template <class SeedSequence>
+ template <class SeedSequence,
+ typename = std::enable_if_t<EnableIfSeedSeq<SeedSequence&>::value>>
void reseed(SeedSequence& seq) {
- using sequence_result_type = typename SeedSequence::result_type;
- static_assert(sizeof(sequence_result_type) == 4,
- "SeedSequence::result_type must be 32-bit");
- constexpr size_t kBufferSize =
- Randen::kSeedBytes / sizeof(sequence_result_type);
- alignas(16) sequence_result_type buffer[kBufferSize];
-
- // Randen::Absorb XORs the seed into state, which is then mixed by a call
- // to Randen::Generate. Seeding with only the provided entropy is preferred
- // to using an arbitrary generate() call, so use [rand.req.seed_seq]
- // size as a proxy for the number of entropy units that can be generated
- // without relying on seed sequence mixing...
- const size_t entropy_size = seq.size();
- if (entropy_size < kBufferSize) {
- // ... and only request that many values, or 256-bits, when unspecified.
- const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
- std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
- seq.generate(buffer, buffer + requested_entropy);
- // The Randen paper suggests preferentially initializing even-numbered
- // 128-bit vectors of the randen state (there are 16 such vectors).
- // The seed data is merged into the state offset by 128-bits, which
- // implies preferring seed bytes [16..31, ..., 208..223]. Since the
- // buffer is 32-bit values, we swap the corresponding buffer positions in
- // 128-bit chunks.
- size_t dst = kBufferSize;
- while (dst > 7) {
- // leave the odd bucket as-is.
- dst -= 4;
- size_t src = dst >> 1;
- // swap 128-bits into the even bucket
- std::swap(buffer[--dst], buffer[--src]);
- std::swap(buffer[--dst], buffer[--src]);
- std::swap(buffer[--dst], buffer[--src]);
- std::swap(buffer[--dst], buffer[--src]);
- }
- } else {
- seq.generate(buffer, buffer + kBufferSize);
- }
-#ifdef ABSL_IS_BIG_ENDIAN
- // Randen expects the seed buffer to be in Little Endian; reverse it on
- // Big Endian platforms.
- for (sequence_result_type& e : buffer) {
- e = absl::little_endian::FromHost(e);
- }
-#endif
- impl_.Absorb(buffer, state());
-
- // Generate will be called when operator() is called
- next_ = kStateSizeT;
+ AbsorbSeed</*kMixExistingState=*/true>(seq);
}
void discard(uint64_t count) {
@@ -226,6 +186,8 @@
auto saver = random_internal::make_istream_state_saver(is);
result_type state[kStateSizeT];
for (auto& elem : state) {
+ // It is not possible to read uint8_t from a stream, so it is necessary to
+ // read a wider type and then cast it to uint8_t.
result_type value = 0;
if (!random_internal::read_integral(is, value)) {
return is;
@@ -251,6 +213,126 @@
static constexpr size_t kCapacityT =
Randen::kCapacityBytes / sizeof(result_type);
+ static void XorLane128(unsigned char* dst, const uint32_t* src) noexcept {
+ for (size_t i = 0; i < 16; i += sizeof(uint64_t)) {
+ uint64_t s = 0;
+ uint64_t d = 0;
+ std::memcpy(&s, reinterpret_cast<const unsigned char*>(src) + i,
+ sizeof(s));
+ std::memcpy(&d, dst + i, sizeof(d));
+ d ^= s;
+ std::memcpy(dst + i, &d, sizeof(d));
+ }
+ }
+
+ template <bool kMixExistingState>
+ void PrepareStateForSeed(result_type* begin) {
+ if constexpr (kMixExistingState) {
+ // Permute the existing sponge state before absorbing new seed material so
+ // repeated reseed(s) calls cannot XOR-cancel and mid-buffer reseeds do
+ // not XOR directly onto already-emitted rate words. Also fold a nonzero
+ // domain tag and the current byte offset into the inner capacity (which
+ // Absorb() leaves untouched) to separate reseed() from ordinary block
+ // refills and distinguish reseeds at different mid-buffer positions.
+ static_assert(Randen::kCapacityBytes >= 4,
+ "Randen capacity must hold domain separator bytes");
+ const size_t byte_offset = next_ * sizeof(result_type);
+ impl_.Generate(begin);
+ auto* capacity = reinterpret_cast<unsigned char*>(begin);
+ capacity[0] ^= 0x01;
+ capacity[1] ^= static_cast<unsigned char>(byte_offset & 0xff);
+ capacity[2] ^= static_cast<unsigned char>((byte_offset >> 8) & 0xff);
+ } else {
+ seed();
+ }
+ }
+
+ template <bool kMixExistingState, class SeedSequence>
+ void AbsorbSeed(SeedSequence& seq) {
+ if constexpr (IsDirectEntropySeedSeq<
+ absl::remove_cvref_t<SeedSequence>>::value) {
+ // Direct entropy sources (such as RandenPoolSeedSeq) yield full-entropy
+ // words without needing full-rate [rand.req.seedseq] mixing. Draw 8 words
+ // (256 bits) rather than all 60 rate words (which would drain an entire
+ // RandenPool refill per BitGen construction) and place them directly into
+ // two even-numbered 128-bit sponge lanes (state[2] and state[4]), leaving
+ // the remaining 52 rate words zeroed (on seed) or unperturbed (on
+ // reseed).
+ constexpr size_t kDirectEntropyWords = 8;
+ constexpr size_t kLane0Offset = Randen::kCapacityBytes + 16;
+ constexpr size_t kLane1Offset = Randen::kCapacityBytes + 48;
+ static_assert(kLane1Offset + 16 <= Randen::kStateBytes,
+ "Randen state must contain even 128-bit lanes 2 and 4");
+ alignas(16) uint32_t entropy[kDirectEntropyWords];
+ seq.generate(entropy, entropy + kDirectEntropyWords);
+#ifdef ABSL_IS_BIG_ENDIAN
+ for (uint32_t& e : entropy) {
+ e = absl::little_endian::FromHost(e);
+ }
+#endif
+ auto* begin = state();
+ PrepareStateForSeed<kMixExistingState>(begin);
+ auto* state_bytes = reinterpret_cast<unsigned char*>(begin);
+ if constexpr (kMixExistingState) {
+ XorLane128(state_bytes + kLane0Offset, entropy);
+ XorLane128(state_bytes + kLane1Offset, entropy + 4);
+ } else {
+ std::memcpy(state_bytes + kLane0Offset, entropy, 16);
+ std::memcpy(state_bytes + kLane1Offset, entropy + 4, 16);
+ }
+ next_ = kStateSizeT;
+ return;
+ }
+
+ constexpr size_t kBufferSize = Randen::kSeedBytes / sizeof(uint32_t);
+ alignas(16) uint32_t buffer[kBufferSize];
+
+ // Randen::Absorb XORs the seed into state, which is then mixed by a call
+ // to Randen::Generate. Seeding with only the provided entropy is preferred
+ // to using an arbitrary generate() call, so use [rand.req.seed_seq]
+ // size as a proxy for the number of entropy units that can be generated
+ // without relying on seed sequence mixing...
+ const size_t entropy_size = seq.size();
+ if (entropy_size < kBufferSize) {
+ // ... and only request that many values, or 256-bits, when unspecified.
+ const size_t requested_entropy = (entropy_size == 0) ? 8u : entropy_size;
+ std::fill(buffer + requested_entropy, buffer + kBufferSize, 0);
+ seq.generate(buffer, buffer + requested_entropy);
+ // The Randen paper suggests preferentially initializing even-numbered
+ // 128-bit vectors of the randen state (there are 16 such vectors).
+ // The seed data is merged into the state offset by 128-bits, which
+ // implies preferring seed bytes [16..31, ..., 208..223]. Since the
+ // buffer is 32-bit values, we swap the corresponding buffer positions in
+ // 128-bit chunks.
+ size_t dst = kBufferSize;
+ while (dst > 7) {
+ // leave the odd bucket as-is.
+ dst -= 4;
+ size_t src = dst >> 1;
+ // swap 128-bits into the even bucket
+ std::swap(buffer[--dst], buffer[--src]);
+ std::swap(buffer[--dst], buffer[--src]);
+ std::swap(buffer[--dst], buffer[--src]);
+ std::swap(buffer[--dst], buffer[--src]);
+ }
+ } else {
+ seq.generate(buffer, buffer + kBufferSize);
+ }
+#ifdef ABSL_IS_BIG_ENDIAN
+ // Randen expects the seed buffer to be in Little Endian; reverse it on
+ // Big Endian platforms.
+ for (uint32_t& e : buffer) {
+ e = absl::little_endian::FromHost(e);
+ }
+#endif
+ auto* begin = state();
+ PrepareStateForSeed<kMixExistingState>(begin);
+ impl_.Absorb(buffer, begin);
+
+ // Generate will be called when operator() is called.
+ next_ = kStateSizeT;
+ }
+
// Returns the state array pointer, which is aligned to 16 bytes.
// The first kCapacityT are the `inner' sponge; the remainder are available.
result_type* state() {
diff --git a/absl/random/internal/randen_engine_test.cc b/absl/random/internal/randen_engine_test.cc
index 3f58184..e961371 100644
--- a/absl/random/internal/randen_engine_test.cc
+++ b/absl/random/internal/randen_engine_test.cc
@@ -30,6 +30,7 @@
#include "gmock/gmock.h"
#include "gtest/gtest.h"
+#include "absl/base/config.h"
#include "absl/log/log.h"
#include "absl/random/internal/explicit_seed_seq.h"
#include "absl/time/clock.h"
@@ -255,11 +256,30 @@
engine = std::move(*self_ptr);
EXPECT_TRUE(engine == expected);
+ randen assigned;
+ assigned = expected;
+ EXPECT_TRUE(assigned == expected);
+
for (int i = 0; i < 16; ++i) {
EXPECT_EQ(engine(), expected());
}
}
+TYPED_TEST(RandenEngineTypedTest, NonConstCopyConstruction) {
+ using E = absl::random_internal::randen_engine<TypeParam>;
+ ExplicitSeedSeq seed_sequence{12, 34, 56};
+ E v(seed_sequence);
+ v.discard(5);
+
+ E copy_paren(v);
+ E copy_brace{v};
+ EXPECT_TRUE(copy_paren == v);
+ EXPECT_TRUE(copy_brace == v);
+ const auto expected = v();
+ EXPECT_EQ(copy_paren(), expected);
+ EXPECT_EQ(copy_brace(), expected);
+}
+
TYPED_TEST(RandenEngineTypedTest, RandenEngineSFINAETest) {
using randen = typename absl::random_internal::randen_engine<TypeParam>;
using result_type = typename randen::result_type;
@@ -457,6 +477,430 @@
FailsLeavingUnchanged());
}
+template <typename Engine, typename Arg, typename = void>
+struct HasSeedMethod : std::false_type {};
+
+template <typename Engine, typename Arg>
+struct HasSeedMethod<
+ Engine, Arg,
+ std::void_t<decltype(std::declval<Engine&>().seed(std::declval<Arg>()))>>
+ : std::true_type {};
+
+template <typename Engine, typename Arg, typename = void>
+struct HasReseedMethod : std::false_type {};
+
+template <typename Engine, typename Arg>
+struct HasReseedMethod<
+ Engine, Arg,
+ std::void_t<decltype(std::declval<Engine&>().reseed(std::declval<Arg>()))>>
+ : std::true_type {};
+
+struct NoResultTypeSeedSeq {
+ size_t size() const { return 4; }
+ template <typename OutIt>
+ void generate(OutIt begin, OutIt end) const {
+ for (OutIt it = begin; it != end; ++it) *it = 1u;
+ }
+};
+
+struct ConvertibleSeedSeq {
+ using result_type = uint32_t;
+ size_t size() const { return 4; }
+ template <typename OutIt>
+ void generate(OutIt begin, OutIt end) const {
+ for (OutIt it = begin; it != end; ++it) *it = 1u;
+ }
+ operator uint64_t() const {
+ return 7u;
+ } // NOLINT(google-explicit-constructor)
+};
+
+template <typename Engine>
+struct DerivedRanden : Engine {
+ using Engine::Engine;
+ size_t size() const { return 4; }
+ void generate(uint32_t*, uint32_t*) const {}
+};
+
+template <typename ResultT, bool kConstGenerate = true, uint32_t kStart = 1,
+ bool kConstSize = true, bool kHasSize = true>
+struct TestSeedSeq {
+ using result_type = ResultT;
+ size_t count = 4;
+
+ explicit TestSeedSeq(size_t n = 4) : count(n) {}
+
+ template <bool H = kHasSize, bool C = kConstSize,
+ std::enable_if_t<H && C, int> = 0>
+ size_t size() const {
+ return count;
+ }
+ template <bool H = kHasSize, bool C = kConstSize,
+ std::enable_if_t<H && !C, int> = 0>
+ size_t size() {
+ return count;
+ }
+
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<C, int> = 0>
+ void generate(OutIt begin, OutIt end) const {
+ uint32_t v = kStart;
+ for (OutIt it = begin; it != end; ++it) *it = v++;
+ }
+ template <typename OutIt, bool C = kConstGenerate,
+ std::enable_if_t<!C, int> = 0>
+ void generate(OutIt begin, OutIt end) {
+ uint32_t v = kStart;
+ for (OutIt it = begin; it != end; ++it) *it = v++;
+ }
+};
+
+using NonConstGenerateSeedSeq = TestSeedSeq<uint32_t, /*kConstGenerate=*/false>;
+using ConstGenerateSeedSeq = TestSeedSeq<uint32_t>;
+using ConstGenerateNonConstSizeSeedSeq =
+ TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/false>;
+using NoSizeSeedSeq =
+ TestSeedSeq<uint32_t, /*kConstGenerate=*/true, 1, /*kConstSize=*/true,
+ /*kHasSize=*/false>;
+using SeedSeq64 = TestSeedSeq<uint64_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SeedSeq32 = TestSeedSeq<uint32_t, /*kConstGenerate=*/false, 0xdeadbeefu>;
+using SignedResultSeedSeq = TestSeedSeq<int32_t>;
+using NarrowResultSeedSeq = TestSeedSeq<uint16_t>;
+using BoolResultSeedSeq = TestSeedSeq<bool>;
+using ConstResultSeedSeq = TestSeedSeq<const uint32_t>;
+using RefResultSeedSeq = TestSeedSeq<uint32_t&>;
+using VoidResultSeedSeq = TestSeedSeq<void>;
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+struct ThrowingRandenSeedSeq {
+ using result_type = uint32_t;
+ size_t size() const { return 8; }
+ void generate(uint32_t* begin, uint32_t*) {
+ *begin = 0x12345678u;
+ throw 42;
+ }
+};
+#endif
+
+struct FixedEightWordSeedSeqBase {
+ using result_type = uint32_t;
+ mutable size_t calls = 0;
+ mutable size_t last_words_requested = 0;
+ size_t size() const { return 0; }
+ template <typename OutIt>
+ void generate(OutIt begin, OutIt end) const {
+ static constexpr uint32_t kWords[8] = {
+ 0x01234567u, 0x89abcdefu, 0xfedcba98u, 0x76543210u,
+ 0x13579bdfu, 0x2468ace0u, 0xdeadbeefu, 0xcafebabeu,
+ };
+ ++calls;
+ last_words_requested = static_cast<size_t>(std::distance(begin, end));
+ size_t i = 0;
+ for (OutIt it = begin; it != end; ++it, ++i) {
+ *it = kWords[i % 8];
+ }
+ }
+};
+
+struct GeneralZeroSizeEightWordSeedSeq : FixedEightWordSeedSeqBase {};
+struct DirectEntropyEightWordSeedSeq : FixedEightWordSeedSeqBase {};
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+struct DirectThrowingRandenSeedSeq {
+ using result_type = uint32_t;
+ size_t size() const { return 0; }
+ void generate(uint32_t* begin, uint32_t*) const {
+ *begin = 0xabcdef01u;
+ throw 77;
+ }
+};
+#endif
+
+} // namespace
+
+namespace absl {
+ABSL_NAMESPACE_BEGIN
+namespace random_internal {
+template <>
+struct IsDirectEntropySeedSeq<DirectEntropyEightWordSeedSeq> : std::true_type {
+};
+#ifdef ABSL_HAVE_EXCEPTIONS
+template <>
+struct IsDirectEntropySeedSeq<DirectThrowingRandenSeedSeq> : std::true_type {};
+#endif
+} // namespace random_internal
+ABSL_NAMESPACE_END
+} // namespace absl
+
+namespace {
+
+TYPED_TEST(RandenEngineTypedTest, SeedSequenceConstraintsAndConstSeeding) {
+ using randen = typename absl::random_internal::randen_engine<TypeParam>;
+
+ {
+ const ConstGenerateSeedSeq const_seq;
+ ConstGenerateSeedSeq mutable_seq;
+ randen engine(const_seq);
+ randen seeded;
+ seeded.seed(const_seq);
+ EXPECT_TRUE(engine == seeded);
+
+ engine.reseed(const_seq);
+ seeded.reseed(mutable_seq);
+ EXPECT_TRUE(engine == seeded);
+ }
+
+ {
+ ConstGenerateNonConstSizeSeedSeq seq;
+ randen engine(seq);
+ randen seeded;
+ seeded.seed(seq);
+ EXPECT_TRUE(engine == seeded);
+
+ ConstGenerateNonConstSizeSeedSeq seq2;
+ engine.reseed(seq);
+ seeded.reseed(seq2);
+ EXPECT_TRUE(engine == seeded);
+ }
+
+ static_assert(!std::is_constructible_v<randen, int*>);
+ static_assert(!std::is_constructible_v<randen, void*>);
+ static_assert(!HasSeedMethod<randen, int*>::value);
+ static_assert(!HasSeedMethod<randen, void*>::value);
+ static_assert(!HasReseedMethod<randen, int&>::value);
+ static_assert(!HasReseedMethod<randen, TypeParam&>::value);
+ static_assert(!HasReseedMethod<randen, int*&>::value);
+ static_assert(!HasReseedMethod<randen, void*&>::value);
+ static_assert(!HasReseedMethod<randen, randen&>::value);
+ static_assert(!HasReseedMethod<randen, DerivedRanden<randen>&>::value);
+ static_assert(!HasReseedMethod<randen, ConvertibleSeedSeq&>::value);
+
+ static_assert(std::is_constructible_v<randen, DerivedRanden<randen>&>);
+ static_assert(std::is_constructible_v<randen, std::seed_seq&>);
+ static_assert(std::is_constructible_v<randen, std::seed_seq&&>);
+ static_assert(HasSeedMethod<randen, std::seed_seq&>::value);
+ static_assert(HasSeedMethod<randen, std::seed_seq&&>::value);
+ static_assert(HasReseedMethod<randen, std::seed_seq&>::value);
+ static_assert(HasReseedMethod<randen, SeedSeq64&>::value);
+
+ // Test non-const generate() rejection with a dedicated type because MSVC STL
+ // marks std::seed_seq::generate() const while libc++/libstdc++ do not.
+ static_assert(std::is_constructible_v<randen, NonConstGenerateSeedSeq&>);
+ static_assert(std::is_constructible_v<randen, NonConstGenerateSeedSeq&&>);
+ static_assert(
+ !std::is_constructible_v<randen, const NonConstGenerateSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<randen, const NonConstGenerateSeedSeq&&>);
+ static_assert(HasSeedMethod<randen, NonConstGenerateSeedSeq&>::value);
+ static_assert(!HasSeedMethod<randen, const NonConstGenerateSeedSeq&>::value);
+ static_assert(HasReseedMethod<randen, NonConstGenerateSeedSeq&>::value);
+ static_assert(
+ !HasReseedMethod<randen, const NonConstGenerateSeedSeq&>::value);
+
+ static_assert(std::is_constructible_v<randen, const ConstGenerateSeedSeq&>);
+ static_assert(HasSeedMethod<randen, const ConstGenerateSeedSeq&>::value);
+ static_assert(HasReseedMethod<randen, const ConstGenerateSeedSeq&>::value);
+
+ static_assert(
+ std::is_constructible_v<randen, ConstGenerateNonConstSizeSeedSeq&>);
+ static_assert(
+ std::is_constructible_v<randen, ConstGenerateNonConstSizeSeedSeq&&>);
+ static_assert(
+ !std::is_constructible_v<randen,
+ const ConstGenerateNonConstSizeSeedSeq&>);
+ static_assert(
+ !std::is_constructible_v<randen,
+ const ConstGenerateNonConstSizeSeedSeq&&>);
+ static_assert(
+ HasSeedMethod<randen, ConstGenerateNonConstSizeSeedSeq&>::value);
+ static_assert(
+ !HasSeedMethod<randen, const ConstGenerateNonConstSizeSeedSeq&>::value);
+ static_assert(
+ HasReseedMethod<randen, ConstGenerateNonConstSizeSeedSeq&>::value);
+ static_assert(
+ !HasReseedMethod<randen, const ConstGenerateNonConstSizeSeedSeq&>::value);
+
+ static_assert(!std::is_constructible_v<randen, NoSizeSeedSeq&>);
+ static_assert(!std::is_constructible_v<randen, const NoSizeSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, NoSizeSeedSeq&>::value);
+ static_assert(!HasSeedMethod<randen, const NoSizeSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, NoSizeSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, const NoSizeSeedSeq&>::value);
+
+ // Reject missing or invalid [rand.req.seedseq] result_type across ctor,
+ // seed(), and reseed().
+ static_assert(!std::is_constructible_v<randen, NoResultTypeSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, NoResultTypeSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, NoResultTypeSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<randen, SignedResultSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, SignedResultSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, SignedResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<randen, NarrowResultSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, NarrowResultSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, NarrowResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<randen, BoolResultSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, BoolResultSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, BoolResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<randen, ConstResultSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, ConstResultSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, ConstResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<randen, RefResultSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, RefResultSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, RefResultSeedSeq&>::value);
+ static_assert(!std::is_constructible_v<randen, VoidResultSeedSeq&>);
+ static_assert(!HasSeedMethod<randen, VoidResultSeedSeq&>::value);
+ static_assert(!HasReseedMethod<randen, VoidResultSeedSeq&>::value);
+}
+
+TYPED_TEST(RandenEngineTypedTest, ReseedDoesNotSelfCancelAndDomainSeparates) {
+ using randen = typename absl::random_internal::randen_engine<TypeParam>;
+ constexpr size_t kRateT = (256 - 16) / sizeof(TypeParam);
+
+ ExplicitSeedSeq seq{12, 34, 56, 78};
+
+ // seed(s) followed immediately by reseed(s) must not XOR-cancel back to the
+ // default-seeded engine or stay equal to seed(s).
+ randen default_engine;
+ randen seeded_only(seq);
+ randen seed_then_reseed(seq);
+ seed_then_reseed.reseed(seq);
+ EXPECT_TRUE(seed_then_reseed != default_engine);
+ EXPECT_TRUE(seed_then_reseed != seeded_only);
+
+ // Back-to-back reseed(s); reseed(s) after emitting outputs must not cancel
+ // back to the pre-reseed state or equal a single reseed(s).
+ randen base(seq);
+ base.discard(3);
+ randen once = base;
+ once.reseed(seq);
+ randen twice = base;
+ twice.reseed(seq);
+ twice.reseed(seq);
+ EXPECT_TRUE(twice != base);
+ EXPECT_TRUE(twice != once);
+
+ // Also cover the full-rate (entropy_size >= 60) path in AbsorbSeed.
+ SeedSeq32 large_seq(64);
+ randen large_once(large_seq);
+ large_once.reseed(large_seq);
+ EXPECT_TRUE(large_once != default_engine);
+ EXPECT_TRUE(large_once != randen(large_seq));
+
+ // Reseeding with an all-zero sequence must still diverge from simply
+ // advancing across a block boundary (domain separation in capacity).
+ ExplicitSeedSeq zero_seq;
+ randen advanced(seq);
+ randen zero_reseeded = advanced;
+ advanced.discard(kRateT);
+ zero_reseeded.reseed(zero_seq);
+ EXPECT_TRUE(zero_reseeded != advanced);
+
+ // Reseeding at distinct mid-buffer positions must yield distinct states.
+ randen mid_a(seq);
+ randen mid_b(seq);
+ mid_a.discard(1);
+ mid_b.discard(5);
+ ASSERT_TRUE(mid_a != mid_b);
+ mid_a.reseed(seq);
+ mid_b.reseed(seq);
+ EXPECT_TRUE(mid_a != mid_b);
+
+#ifdef ABSL_HAVE_EXCEPTIONS
+ ThrowingRandenSeedSeq throwing_seq;
+ DirectThrowingRandenSeedSeq direct_throwing_seq;
+ randen survivor(seq);
+ survivor.discard(2);
+ const randen snapshot = survivor;
+ EXPECT_THROW(survivor.seed(throwing_seq), int);
+ EXPECT_TRUE(survivor == snapshot);
+ EXPECT_THROW(survivor.reseed(throwing_seq), int);
+ EXPECT_TRUE(survivor == snapshot);
+ EXPECT_THROW(survivor.seed(direct_throwing_seq), int);
+ EXPECT_TRUE(survivor == snapshot);
+ EXPECT_THROW(survivor.reseed(direct_throwing_seq), int);
+ EXPECT_TRUE(survivor == snapshot);
+#endif
+}
+
+TYPED_TEST(RandenEngineTypedTest, DirectEntropySeedSeqDraws8WordsAndMatches) {
+ using randen = typename absl::random_internal::randen_engine<TypeParam>;
+
+ DirectEntropyEightWordSeedSeq direct_seq;
+ const DirectEntropyEightWordSeedSeq const_direct_seq;
+ GeneralZeroSizeEightWordSeedSeq general_seq;
+
+ randen from_direct(direct_seq);
+ EXPECT_EQ(direct_seq.calls, 1u);
+ EXPECT_EQ(direct_seq.last_words_requested, 8u);
+
+ randen from_const_direct(const_direct_seq);
+ EXPECT_EQ(const_direct_seq.calls, 1u);
+ EXPECT_EQ(const_direct_seq.last_words_requested, 8u);
+
+ randen from_general(general_seq);
+ EXPECT_EQ(general_seq.calls, 1u);
+ EXPECT_EQ(general_seq.last_words_requested, 8u);
+
+ EXPECT_TRUE(from_direct == from_general);
+ EXPECT_TRUE(from_const_direct == from_general);
+
+ // Advance mid-buffer and verify reseed() also draws 8 words into even lanes
+ // state[2] and state[4] with bit-identical state and stream.
+ from_direct.discard(3);
+ from_general.discard(3);
+ from_direct.reseed(direct_seq);
+ from_general.reseed(general_seq);
+ EXPECT_EQ(direct_seq.calls, 2u);
+ EXPECT_EQ(direct_seq.last_words_requested, 8u);
+ EXPECT_TRUE(from_direct == from_general);
+
+ for (int i = 0; i < 64; ++i) {
+ EXPECT_EQ(from_direct(), from_general());
+ }
+}
+
+TEST(RandenTest, ReseedPreservesCrossWidthByteStream) {
+ ExplicitSeedSeq init_seq{1, 2, 3, 4};
+ ExplicitSeedSeq reseed_seq{9, 8, 7, 6};
+
+ randen_u64 e64(init_seq);
+ randen_u32 e32(init_seq);
+ // Advance both by 16 bytes so their mid-buffer byte offsets match.
+ e64.discard(2);
+ e32.discard(4);
+ e64.reseed(reseed_seq);
+ e32.reseed(reseed_seq);
+
+ for (int i = 0; i < 40; ++i) {
+ const uint64_t v64 = e64();
+ const uint64_t lo = e32();
+ const uint64_t hi = e32();
+ EXPECT_EQ(v64, lo | (hi << 32)) << "i=" << i;
+ }
+}
+
+TYPED_TEST(RandenEngineTypedTest, SeedSequenceWith64BitResultTypeMatches32Bit) {
+ using randen = typename absl::random_internal::randen_engine<TypeParam>;
+ static_assert(std::is_constructible_v<randen, SeedSeq64&>,
+ "randen_engine must be constructible from SeedSeq64&");
+ static_assert(HasSeedMethod<randen, SeedSeq64&>::value,
+ "randen_engine::seed must accept SeedSeq64&");
+
+ for (size_t seed_size : {size_t{4}, size_t{64}}) {
+ SeedSeq64 seq64(seed_size);
+ SeedSeq32 seq32(seed_size);
+ randen e64(seq64);
+ randen e32(seq32);
+ EXPECT_TRUE(e64 == e32);
+ EXPECT_EQ(e64(), e32());
+
+ e64.seed(seq64);
+ e32.seed(seq32);
+ EXPECT_TRUE(e64 == e32);
+ EXPECT_EQ(e64(), e32());
+ }
+}
+
TEST(RandenTest, VerifyGoldenRanden64Default) {
constexpr uint64_t kGolden[kNumGoldenOutputs] = {
0xc3c14f134e433977, 0xdda9f47cd90410ee, 0x887bf3087fd8ca10,
diff --git a/absl/random/internal/salted_seed_seq.h b/absl/random/internal/salted_seed_seq.h
index 858a90f..ea77684 100644
--- a/absl/random/internal/salted_seed_seq.h
+++ b/absl/random/internal/salted_seed_seq.h
@@ -15,6 +15,8 @@
#ifndef ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
#define ABSL_RANDOM_INTERNAL_SALTED_SEED_SEQ_H_
+#include <algorithm>
+#include <cstddef>
#include <cstdint>
#include <cstdlib>
#include <initializer_list>
@@ -29,6 +31,7 @@
#include "absl/container/inlined_vector.h"
#include "absl/meta/type_traits.h"
#include "absl/random/internal/seed_material.h"
+#include "absl/random/internal/traits.h"
#include "absl/types/optional.h"
#include "absl/types/span.h"
@@ -36,6 +39,20 @@
ABSL_NAMESPACE_BEGIN
namespace random_internal {
+template <typename Iterator, bool IsPointer = std::is_pointer_v<Iterator>,
+ typename = void>
+struct IsIntegralIterator : std::false_type {};
+
+template <typename Iterator>
+struct IsIntegralIterator<Iterator, true, void>
+ : std::is_integral<std::remove_pointer_t<Iterator>> {};
+
+template <typename Iterator>
+struct IsIntegralIterator<
+ Iterator, false,
+ std::void_t<typename std::iterator_traits<Iterator>::value_type>>
+ : std::is_integral<typename std::iterator_traits<Iterator>::value_type> {};
+
// This class conforms to the C++ Standard "Seed Sequence" concept
// [rand.req.seedseq].
//
@@ -46,19 +63,41 @@
// not modified.
template <typename SSeq>
class SaltedSeedSeq {
+ static_assert(!std::is_rvalue_reference_v<SSeq>,
+ "SaltedSeedSeq cannot be instantiated with an rvalue "
+ "reference; use an owning type or an lvalue reference.");
+ using raw_sequence_type = std::remove_reference_t<SSeq>;
+
public:
using inner_sequence_type = SSeq;
- using result_type = typename SSeq::result_type;
+ using result_type = typename raw_sequence_type::result_type;
- SaltedSeedSeq() : seq_(std::make_unique<SSeq>()) {}
+ template <typename U = SSeq,
+ typename = std::enable_if_t<std::conjunction_v<
+ std::negation<std::is_reference<U>>,
+ std::is_default_constructible<std::remove_reference_t<U>>>>>
+ SaltedSeedSeq() : seq_(std::make_unique<raw_sequence_type>()) {}
- template <typename Iterator>
+ template <
+ typename Iterator, typename U = SSeq,
+ typename = std::enable_if_t<std::conjunction_v<
+ std::negation<std::is_reference<U>>, IsIntegralIterator<Iterator>,
+ std::is_constructible<std::remove_reference_t<U>, Iterator,
+ Iterator>>>>
SaltedSeedSeq(Iterator begin, Iterator end)
- : seq_(std::make_unique<SSeq>(begin, end)) {}
+ : seq_(std::make_unique<raw_sequence_type>(begin, end)) {}
- template <typename T>
+ template <typename T, typename U = SSeq,
+ typename = std::enable_if_t<std::conjunction_v<
+ std::negation<std::is_reference<U>>, std::is_integral<T>,
+ std::is_constructible<std::remove_reference_t<U>,
+ std::initializer_list<T>>>>>
SaltedSeedSeq(std::initializer_list<T> il)
- : SaltedSeedSeq(il.begin(), il.end()) {}
+ : seq_(std::make_unique<raw_sequence_type>(il)) {}
+
+ template <typename U = SSeq,
+ typename = std::enable_if_t<std::is_lvalue_reference_v<U>>>
+ explicit SaltedSeedSeq(raw_sequence_type& seq) : seq_(&seq) {}
SaltedSeedSeq(const SaltedSeedSeq&) = delete;
SaltedSeedSeq& operator=(const SaltedSeedSeq&) = delete;
@@ -66,45 +105,82 @@
SaltedSeedSeq(SaltedSeedSeq&&) = default;
SaltedSeedSeq& operator=(SaltedSeedSeq&&) = default;
- template <typename RandomAccessIterator>
+ template <typename RandomAccessIterator, typename U = raw_sequence_type,
+ typename = std::void_t<decltype(std::declval<U&>().generate(
+ std::declval<uint32_t*>(), std::declval<uint32_t*>()))>>
void generate(RandomAccessIterator begin, RandomAccessIterator end) {
- using U = typename std::iterator_traits<RandomAccessIterator>::value_type;
+ using V = typename std::iterator_traits<RandomAccessIterator>::value_type;
+ using Ref = typename std::iterator_traits<RandomAccessIterator>::reference;
// The common case is that generate is called with ContiguousIterators
- // to uint arrays. Such contiguous memory regions may be optimized,
+ // to uint32_t arrays. Such contiguous memory regions may be optimized,
// which we detect here.
using TagType = std::conditional_t<
- (std::is_same_v<U, uint32_t> &&
+ (std::is_same_v<V, uint32_t> && std::is_same_v<Ref, uint32_t&> &&
(std::is_pointer_v<RandomAccessIterator> ||
std::is_same_v<RandomAccessIterator,
- typename std::vector<U>::iterator>)),
+ typename std::vector<uint32_t>::iterator>)),
ContiguousAndUint32Tag, DefaultTag>;
if (begin != end) {
- generate_impl(TagType{}, begin, end, std::distance(begin, end));
+ generate_impl(TagType{}, begin, end,
+ static_cast<size_t>(std::distance(begin, end)));
}
}
- template <typename OutIterator>
+ template <typename OutIterator, typename U = raw_sequence_type,
+ typename = std::void_t<decltype(std::declval<U&>().param(
+ std::declval<OutIterator>()))>>
void param(OutIterator out) const {
seq_->param(out);
}
- size_t size() const { return seq_->size(); }
+ template <typename U = raw_sequence_type,
+ typename = std::enable_if_t<std::is_convertible_v<
+ decltype(std::declval<U&>().size()), size_t>>>
+ size_t size() const {
+ return seq_->size();
+ }
private:
struct ContiguousAndUint32Tag {};
struct DefaultTag {};
// Generate which requires the iterators are contiguous pointers to uint32_t.
- // Fills the initial seed buffer the underlying SSeq::generate() call,
- // then mixes in the salt material.
+ // Fills the initial seed buffer from the underlying SSeq::generate() call,
+ // then mixes in the salt material if available. When `n < min(60, 2 * s)`,
+ // expands `generate()` to `min(60, 2 * s)` words first (satisfying
+ // `s <= m - p(m)` for all `1 <= s <= 33` so narrow requests such as `n = 2`
+ // or `n = 4` do not suffer `[rand.util.seedseq]` truncation collisions) and
+ // folds both the salt and the excess words into the `n`-word output.
template <typename Contiguous>
void generate_impl(ContiguousAndUint32Tag, Contiguous begin, Contiguous end,
size_t n) {
+ const auto salt = absl::random_internal::GetSaltMaterial();
+ if (!salt.has_value()) {
+ seq_->generate(begin, end);
+ return;
+ }
+ constexpr size_t kMaxExpanded = 60;
+ auto out = absl::Span<uint32_t>(&*begin, n);
+ if (n < kMaxExpanded) {
+ size_t s = 0;
+ if constexpr (HasSeedSeqSize<raw_sequence_type>::value) {
+ s = seq_->size();
+ }
+ const size_t target = (s >= kMaxExpanded / 2) ? kMaxExpanded : (2 * s);
+ if (n < target) {
+ uint32_t expanded[kMaxExpanded];
+ std::fill_n(expanded, target, uint32_t{0});
+ seq_->generate(expanded, expanded + target);
+ std::copy_n(expanded, n, out.data());
+ expanded[n - 1] = *salt;
+ MixIntoSeedMaterial(
+ absl::MakeConstSpan(expanded + (n - 1), target - n + 1), out);
+ return;
+ }
+ }
seq_->generate(begin, end);
- const uint32_t salt = absl::random_internal::GetSaltMaterial().value_or(0);
- auto span = absl::Span<uint32_t>(&*begin, n);
- MixIntoSeedMaterial(absl::MakeConstSpan(&salt, 1), span);
+ MixIntoSeedMaterial(absl::MakeConstSpan(&*salt, 1), out);
}
// The uncommon case for generate is that it is called with iterators over
@@ -122,42 +198,66 @@
}
// Because [rand.req.seedseq] is not required to be copy-constructible,
- // copy-assignable nor movable, we wrap it with unique pointer to be able
- // to move SaltedSeedSeq.
- std::unique_ptr<SSeq> seq_;
+ // copy-assignable nor movable, owning instances wrap it with unique_ptr to be
+ // movable, while SaltedSeedSeq<SSeq&> holds a non-owning pointer.
+ std::conditional_t<std::is_lvalue_reference_v<SSeq>, raw_sequence_type*,
+ std::unique_ptr<raw_sequence_type>>
+ seq_;
};
-// is_salted_seed_seq indicates whether the type is a SaltedSeedSeq.
+// is_salted_seed_seq indicates whether the type (ignoring cvref) is a
+// SaltedSeedSeq.
template <typename T, typename = void>
struct is_salted_seed_seq : public std::false_type {};
template <typename T>
struct is_salted_seed_seq<
- T, std::enable_if_t<
- std::is_same_v<T, SaltedSeedSeq<typename T::inner_sequence_type>>>>
+ T,
+ std::enable_if_t<std::is_same_v<
+ absl::remove_cvref_t<T>,
+ SaltedSeedSeq<typename absl::remove_cvref_t<T>::inner_sequence_type>>>>
: public std::true_type {};
+// UnwrappedSeedSeq unwraps `SaltedSeedSeq<Inner>` to
+// `absl::remove_cvref_t<Inner>`, or decays any other seed sequence type via
+// `absl::remove_cvref_t`.
+template <typename SSeq, bool = is_salted_seed_seq<SSeq>::value>
+struct UnwrappedSeedSeq {
+ using type = absl::remove_cvref_t<SSeq>;
+};
+
+template <typename SSeq>
+struct UnwrappedSeedSeq<SSeq, true> {
+ using type = absl::remove_cvref_t<
+ typename absl::remove_cvref_t<SSeq>::inner_sequence_type>;
+};
+
+template <typename SSeq>
+struct is_movable_owning_salted_seed_seq : std::false_type {};
+
+template <typename Inner>
+struct is_movable_owning_salted_seed_seq<SaltedSeedSeq<Inner>>
+ : std::negation<std::is_reference<Inner>> {};
+
// MakeSaltedSeedSeq returns a salted variant of the seed sequence.
-// When provided with an existing SaltedSeedSeq, returns the input parameter,
+// When provided with an existing SaltedSeedSeq, preserves single salting,
// otherwise constructs a new SaltedSeedSeq which embodies the original
// non-salted seed parameters.
-template <
- typename SSeq, //
- typename EnableIf = std::enable_if_t<is_salted_seed_seq<SSeq>::value>>
-SSeq MakeSaltedSeedSeq(SSeq&& seq) {
- return SSeq(std::forward<SSeq>(seq));
-}
+template <typename SSeq>
+auto MakeSaltedSeedSeq(SSeq&& seq) {
+ if constexpr (is_movable_owning_salted_seed_seq<SSeq>::value) {
+ return SSeq(std::forward<SSeq>(seq));
+ } else {
+ using target_type = typename UnwrappedSeedSeq<SSeq>::type;
+ using result_type = typename target_type::result_type;
-template <
- typename SSeq, //
- typename EnableIf = std::enable_if_t<!is_salted_seed_seq<SSeq>::value>>
-SaltedSeedSeq<std::decay_t<SSeq>> MakeSaltedSeedSeq(SSeq&& seq) {
- using sseq_type = std::decay_t<SSeq>;
- using result_type = typename sseq_type::result_type;
-
- absl::InlinedVector<result_type, 8> data;
- seq.param(std::back_inserter(data));
- return SaltedSeedSeq<sseq_type>(data.begin(), data.end());
+ absl::InlinedVector<result_type, 8> data;
+ if constexpr (HasSeedSeqSize<SSeq>::value) {
+ data.reserve(seq.size());
+ }
+ seq.param(std::back_inserter(data));
+ return SaltedSeedSeq<target_type>(data.begin(), data.end());
+ }
}
} // namespace random_internal
diff --git a/absl/random/internal/salted_seed_seq_test.cc b/absl/random/internal/salted_seed_seq_test.cc
index 3e8dfeb..d64f757 100644
--- a/absl/random/internal/salted_seed_seq_test.cc
+++ b/absl/random/internal/salted_seed_seq_test.cc
@@ -16,8 +16,11 @@
#include <cstddef>
#include <cstdint>
+#include <initializer_list>
#include <iterator>
+#include <optional>
#include <random>
+#include <type_traits>
#include <utility>
#include <vector>
@@ -103,7 +106,7 @@
uint32_t a[16];
salted_seq.generate(std::begin(a), std::end(a));
- // The second salting.
+ // The second salting (rvalue).
SaltedSeedSeq<std::seed_seq> salted_salted_seq =
MakeSaltedSeedSeq(std::move(salted_seq));
uint32_t b[16];
@@ -111,6 +114,129 @@
// ... both should be equal.
EXPECT_THAT(b, Pointwise(Eq(), a)) << "a[0] " << a[0];
+
+ // Lvalue SaltedSeedSeq must also not be double-salted.
+ auto lvalue_salted_seq = MakeSaltedSeedSeq(salted_salted_seq);
+ uint32_t c[16];
+ lvalue_salted_seq.generate(std::begin(c), std::end(c));
+ EXPECT_THAT(c, Pointwise(Eq(), a));
+
+ // Const lvalue and const rvalue SaltedSeedSeq must also not be double-salted.
+ const SaltedSeedSeq<std::seed_seq> const_salted_seq(std::begin(init),
+ std::end(init));
+ auto from_const_lvalue = MakeSaltedSeedSeq(const_salted_seq);
+ uint32_t e[16];
+ from_const_lvalue.generate(std::begin(e), std::end(e));
+ EXPECT_THAT(e, Pointwise(Eq(), a));
+
+ auto from_const_rvalue = MakeSaltedSeedSeq(std::move(const_salted_seq));
+ uint32_t f[16];
+ from_const_rvalue.generate(std::begin(f), std::end(f));
+ EXPECT_THAT(f, Pointwise(Eq(), a));
+}
+
+TEST(SaltedSeedSeq, BraceMoveInvokesMoveConstructor) {
+ SaltedSeedSeq<std::seed_seq> expected_seq{1, 3, 5, 7, 9};
+ uint32_t expected[16];
+ expected_seq.generate(std::begin(expected), std::end(expected));
+
+ SaltedSeedSeq<std::seed_seq> source{1, 3, 5, 7, 9};
+ SaltedSeedSeq<std::seed_seq> brace_moved{std::move(source)};
+ uint32_t actual[16];
+ brace_moved.generate(std::begin(actual), std::end(actual));
+ EXPECT_THAT(actual, Pointwise(Eq(), expected));
+}
+
+TEST(SaltedSeedSeq, MakeSaltedSeedSeqReturnsOwningFromNonOwningRef) {
+ uint32_t init[] = {1, 3, 5, 7, 9};
+ SaltedSeedSeq<std::seed_seq> expected_seq(std::begin(init), std::end(init));
+ uint32_t expected[16];
+ expected_seq.generate(std::begin(expected), std::end(expected));
+
+ std::optional<SaltedSeedSeq<std::seed_seq>> owned_from_mutable;
+ std::optional<SaltedSeedSeq<std::seed_seq>> owned_from_const;
+ {
+ std::seed_seq raw(std::begin(init), std::end(init));
+ auto made_mutable = MakeSaltedSeedSeq(SaltedSeedSeq<std::seed_seq&>(raw));
+ static_assert(
+ std::is_same_v<decltype(made_mutable), SaltedSeedSeq<std::seed_seq>>);
+ owned_from_mutable.emplace(std::move(made_mutable));
+
+ const std::seed_seq const_raw(std::begin(init), std::end(init));
+ auto made_const =
+ MakeSaltedSeedSeq(SaltedSeedSeq<const std::seed_seq&>(const_raw));
+ static_assert(
+ std::is_same_v<decltype(made_const), SaltedSeedSeq<std::seed_seq>>);
+ owned_from_const.emplace(std::move(made_const));
+ }
+
+ uint32_t from_mutable[16];
+ owned_from_mutable->generate(std::begin(from_mutable),
+ std::end(from_mutable));
+ EXPECT_THAT(from_mutable, Pointwise(Eq(), expected));
+
+ uint32_t from_const[16];
+ owned_from_const->generate(std::begin(from_const), std::end(from_const));
+ EXPECT_THAT(from_const, Pointwise(Eq(), expected));
+}
+
+TEST(SaltedSeedSeq, ConstructorConstraints) {
+ static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+ std::initializer_list<int>>);
+ static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+ std::initializer_list<uint32_t>>);
+ static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+ std::initializer_list<uint64_t>>);
+ static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+ std::initializer_list<double>>);
+ static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq>,
+ std::initializer_list<const char*>>);
+ static_assert(std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, uint32_t*,
+ uint32_t*>);
+ static_assert(
+ !std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, double*, double*>);
+ static_assert(
+ !std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, double, double>);
+ static_assert(
+ !std::is_constructible_v<SaltedSeedSeq<std::seed_seq>, void*, void*>);
+
+ static_assert(
+ !std::is_default_constructible_v<SaltedSeedSeq<std::seed_seq&>>);
+ static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq&>,
+ std::initializer_list<uint32_t>>);
+ static_assert(!std::is_constructible_v<SaltedSeedSeq<std::seed_seq&>,
+ uint32_t*, uint32_t*>);
+ static_assert(
+ std::is_constructible_v<SaltedSeedSeq<std::seed_seq&>, std::seed_seq&>);
+
+ // Note: SaltedSeedSeq<T&&> is rejected by a class-scope static_assert.
+ static_assert(absl::random_internal::is_movable_owning_salted_seed_seq<
+ SaltedSeedSeq<std::seed_seq>>::value);
+ static_assert(!absl::random_internal::is_movable_owning_salted_seed_seq<
+ SaltedSeedSeq<std::seed_seq&>>::value);
+ static_assert(!absl::random_internal::is_movable_owning_salted_seed_seq<
+ const SaltedSeedSeq<std::seed_seq>>::value);
+
+ // Also cover >8 elements in MakeSaltedSeedSeq (out-of-line InlinedVector).
+ std::vector<uint32_t> large_init(20);
+ for (size_t i = 0; i < large_init.size(); ++i) {
+ large_init[i] = static_cast<uint32_t>(i * 3 + 1);
+ }
+ const std::seed_seq large_const(large_init.begin(), large_init.end());
+ SaltedSeedSeq<std::seed_seq> large_direct(large_init.begin(),
+ large_init.end());
+ auto large_made = MakeSaltedSeedSeq(large_const);
+ uint32_t expected_large[16];
+ uint32_t actual_large[16];
+ large_direct.generate(std::begin(expected_large), std::end(expected_large));
+ large_made.generate(std::begin(actual_large), std::end(actual_large));
+ EXPECT_THAT(actual_large, Pointwise(Eq(), expected_large));
+
+ SaltedSeedSeq<std::seed_seq> from_u32{1u, 2u, 3u};
+ EXPECT_EQ(from_u32.size(), 3u);
+
+ SaltedSeedSeq<std::seed_seq> from_u64{uint64_t{1}, uint64_t{2}};
+ EXPECT_EQ(from_u64.size(), 2u);
}
TEST(SaltedSeedSeq, SeedMaterialIsSalted) {
@@ -171,6 +297,144 @@
seq.generate(std::begin(seed_material), std::end(seed_material));
EXPECT_THAT(seed_material, Pointwise(Eq(), expected));
}
+
+ // Volatile uint32_t outputs (routes through DefaultTag rather than Span).
+ {
+ volatile uint32_t seed_material[kNumBlocks] = {};
+ seq.generate(std::begin(seed_material), std::end(seed_material));
+ for (size_t i = 0; i < kNumBlocks; ++i) {
+ EXPECT_EQ(seed_material[i], expected[i]);
+ }
+ }
+
+ // Out-of-line (>8) DefaultTag buffer path.
+ {
+ constexpr size_t kLargeBlocks = 12;
+ uint32_t expected_large[kLargeBlocks];
+ uint64_t actual_large[kLargeBlocks];
+ seq.generate(std::begin(expected_large), std::end(expected_large));
+ seq.generate(std::begin(actual_large), std::end(actual_large));
+ EXPECT_THAT(actual_large, Pointwise(Eq(), expected_large));
+ }
+}
+
+struct CountingSeedSeq {
+ using result_type = uint32_t;
+ size_t reported_size = 0;
+ size_t calls = 0;
+ size_t last_requested = 0;
+
+ explicit CountingSeedSeq(size_t s) : reported_size(s) {}
+ size_t size() const { return reported_size; }
+ template <typename OutIt>
+ void generate(OutIt begin, OutIt end) {
+ ++calls;
+ last_requested = static_cast<size_t>(std::distance(begin, end));
+ uint32_t v = 1;
+ for (OutIt it = begin; it != end; ++it) {
+ *it = v++;
+ }
+ }
+};
+
+template <size_t S, size_t N>
+void VerifyTruncatedCollisionSeparated(const uint32_t (&seed_a)[S],
+ const uint32_t (&seed_b)[S]) {
+ std::seed_seq raw_a(std::begin(seed_a), std::end(seed_a));
+ std::seed_seq raw_b(std::begin(seed_b), std::end(seed_b));
+ uint32_t raw_out_a[N] = {};
+ uint32_t raw_out_b[N] = {};
+ raw_a.generate(std::begin(raw_out_a), std::end(raw_out_a));
+ raw_b.generate(std::begin(raw_out_b), std::end(raw_out_b));
+ // Precondition: raw std::seed_seq genuinely collides at width N.
+ ASSERT_THAT(raw_out_a, Pointwise(Eq(), raw_out_b));
+
+ SaltedSeedSeq<std::seed_seq> salted_a(std::begin(seed_a), std::end(seed_a));
+ SaltedSeedSeq<std::seed_seq> salted_b(std::begin(seed_b), std::end(seed_b));
+
+ // size() and param() remain unsalted per [rand.req.seedseq].
+ EXPECT_EQ(salted_a.size(), S);
+ EXPECT_EQ(salted_b.size(), S);
+ std::vector<uint32_t> params_a;
+ salted_a.param(std::back_inserter(params_a));
+ EXPECT_THAT(params_a, Pointwise(Eq(), seed_a));
+
+ if (GetSaltMaterial().has_value()) {
+ uint32_t salted_out_a[N] = {};
+ uint32_t salted_out_b[N] = {};
+ salted_a.generate(std::begin(salted_out_a), std::end(salted_out_a));
+ salted_b.generate(std::begin(salted_out_b), std::end(salted_out_b));
+ EXPECT_THAT(salted_out_a, testing::Not(Pointwise(Eq(), salted_out_b)));
+ }
+}
+
+TEST(SaltedSeedSeq, EliminatesKnownStdSeedSeqTruncationCollisions) {
+ // Exact [rand.util.seedseq] collision pairs where two distinct s-word seeds
+ // yield bit-for-bit identical n-word std::seed_seq::generate() outputs.
+ constexpr uint32_t kS2A[2] = {0x00000003u, 0xef243a0au};
+ constexpr uint32_t kS2B[2] = {0x0b8bb54eu, 0xfaafef55u};
+ VerifyTruncatedCollisionSeparated<2, 2>(kS2A, kS2B);
+
+ constexpr uint32_t kS3A[3] = {0x0000269du, 0x4cc2d2d4u, 0x507fd03cu};
+ constexpr uint32_t kS3B[3] = {0x00033c9bu, 0xa08a4e6cu, 0x5082e63au};
+ VerifyTruncatedCollisionSeparated<3, 3>(kS3A, kS3B);
+
+ constexpr uint32_t kS4A[4] = {0x00010253u, 0x4c1127d0u, 0xc406ad4cu,
+ 0x13a2704du};
+ constexpr uint32_t kS4B[4] = {0x000135d7u, 0xc89ecda0u, 0x24996d88u,
+ 0x13a2a3d1u};
+ VerifyTruncatedCollisionSeparated<4, 4>(kS4A, kS4B);
+
+ constexpr uint32_t kS8N8A[8] = {0x7496df94u, 0x2f701878u, 0xf374430bu,
+ 0x33e4d291u, 0x8e5b51a3u, 0x0f511665u,
+ 0xd44a6ec8u, 0xbb00fd0au};
+ constexpr uint32_t kS8N8B[8] = {0x64e949bau, 0x47fb3261u, 0xdeaae914u,
+ 0xfdd32ba0u, 0xa4d1fd8du, 0x357706e1u,
+ 0xc49cd8eeu, 0xbb01dbdfu};
+ VerifyTruncatedCollisionSeparated<8, 8>(kS8N8A, kS8N8B);
+
+ constexpr uint32_t kS8N4A[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+ 0x00000004u, 0x0000bf91u, 0x67c0a593u,
+ 0x313389e7u, 0xee5c8e5cu};
+ constexpr uint32_t kS8N4B[8] = {0x00000001u, 0x00000002u, 0x00000003u,
+ 0x00000004u, 0x00011835u, 0xa5168553u,
+ 0xcee80a7au, 0xee5ce700u};
+ VerifyTruncatedCollisionSeparated<8, 4>(kS8N4A, kS8N4B);
+}
+
+TEST(SaltedSeedSeq, ExpansionRespectsZeroSizeAndCapsAt60Words) {
+ uint32_t out4[4] = {};
+
+ // Zero-size sequences (e.g. stateful entropy seeders) must never over-pull.
+ CountingSeedSeq zero_seq(0);
+ SaltedSeedSeq<CountingSeedSeq&> salted_zero(zero_seq);
+ salted_zero.generate(std::begin(out4), std::end(out4));
+ EXPECT_EQ(zero_seq.calls, 1u);
+ EXPECT_EQ(zero_seq.last_requested, 4u);
+
+ if (GetSaltMaterial().has_value()) {
+ // s = 4, n = 4 expands to 2 * s = 8.
+ CountingSeedSeq seq4(4);
+ SaltedSeedSeq<CountingSeedSeq&> salted4(seq4);
+ salted4.generate(std::begin(out4), std::end(out4));
+ EXPECT_EQ(seq4.last_requested, 8u);
+
+ // s >= 30 caps expansion at 60 without overflow even at SIZE_MAX.
+ CountingSeedSeq seq40(40);
+ SaltedSeedSeq<CountingSeedSeq&> salted40(seq40);
+ salted40.generate(std::begin(out4), std::end(out4));
+ EXPECT_EQ(seq40.last_requested, 60u);
+
+ CountingSeedSeq seq_max(static_cast<size_t>(-1));
+ SaltedSeedSeq<CountingSeedSeq&> salted_max(seq_max);
+ salted_max.generate(std::begin(out4), std::end(out4));
+ EXPECT_EQ(seq_max.last_requested, 60u);
+
+ // Requests already >= min(60, 2 * s) do not expand further.
+ uint32_t out8[8] = {};
+ salted4.generate(std::begin(out8), std::end(out8));
+ EXPECT_EQ(seq4.last_requested, 8u);
+ }
}
} // namespace
diff --git a/absl/random/internal/traits.h b/absl/random/internal/traits.h
index 8404d93..d57718b 100644
--- a/absl/random/internal/traits.h
+++ b/absl/random/internal/traits.h
@@ -19,6 +19,7 @@
#include <cstdint>
#include <limits>
#include <type_traits>
+#include <utility>
#include "absl/base/config.h"
#include "absl/meta/type_traits.h"
@@ -162,6 +163,52 @@
}
}
+// Detects whether `T` is a valid `[rand.req.seedseq]` `result_type`
+// (an unqualified unsigned integer type of at least 32 bits).
+template <typename T, typename = void>
+struct IsValidSeedSeqResultType : std::false_type {};
+
+template <typename T>
+struct IsValidSeedSeqResultType<
+ T, std::enable_if_t<std::is_same_v<T, absl::remove_cvref_t<T>> &&
+ std::is_integral_v<T> && std::is_unsigned_v<T>>>
+ : std::bool_constant<(std::numeric_limits<T>::digits >= 32)> {};
+
+// Detects whether `std::remove_reference_t<SSeq>` has a valid `result_type`
+// and supports `seq.generate(uint32_t*, uint32_t*)` on an lvalue (preserving
+// `const`).
+template <typename SSeq, typename = void>
+struct HasSeedSeqGenerate : std::false_type {};
+
+template <typename SSeq>
+struct HasSeedSeqGenerate<
+ SSeq,
+ std::enable_if_t<
+ IsValidSeedSeqResultType<
+ typename std::remove_reference_t<SSeq>::result_type>::value,
+ std::void_t<
+ decltype(std::declval<std::remove_reference_t<SSeq>&>().generate(
+ std::declval<uint32_t*>(), std::declval<uint32_t*>()))>>>
+ : std::true_type {};
+
+// Detects whether `std::remove_reference_t<SSeq>` supports `seq.size()`
+// convertible to `size_t` on an lvalue (preserving `const`).
+template <typename SSeq, typename = void>
+struct HasSeedSeqSize : std::false_type {};
+
+template <typename SSeq>
+struct HasSeedSeqSize<
+ SSeq, std::enable_if_t<std::is_convertible_v<
+ decltype(std::declval<std::remove_reference_t<SSeq>&>().size()),
+ size_t>>> : std::true_type {};
+
+// Marks internal SeedSequence types (such as `RandenPoolSeedSeq`) that yield
+// full-entropy words directly from an internal entropy pool and can seed
+// `randen_engine` with a fixed 256-bit (8-word) draw rather than expanding
+// through general `[rand.req.seedseq]` mixing.
+template <typename SSeq>
+struct IsDirectEntropySeedSeq : std::false_type {};
+
} // namespace random_internal
ABSL_NAMESPACE_END
} // namespace absl
diff --git a/absl/random/internal/traits_test.cc b/absl/random/internal/traits_test.cc
index 08361a4..b328833 100644
--- a/absl/random/internal/traits_test.cc
+++ b/absl/random/internal/traits_test.cc
@@ -14,6 +14,7 @@
#include "absl/random/internal/traits.h"
+#include <cstddef>
#include <cstdint>
#include <random>
#include <type_traits>
@@ -22,8 +23,12 @@
namespace {
+using absl::random_internal::HasSeedSeqGenerate;
+using absl::random_internal::HasSeedSeqSize;
using absl::random_internal::is_urbg;
using absl::random_internal::is_widening_convertible;
+using absl::random_internal::IsDirectEntropySeedSeq;
+using absl::random_internal::IsValidSeedSeqResultType;
static_assert(is_urbg<std::minstd_rand>::value);
static_assert(!is_urbg<uint64_t>::value);
@@ -125,4 +130,62 @@
CheckWideningConvertsTo<bool, float>();
}
+enum UnscopedU32Enum : uint32_t { kZero = 0 };
+enum class ScopedU32Enum : uint32_t { kZero = 0 };
+struct EmptyStruct {};
+
+struct NoResultSeedSeq {
+ size_t size() const { return 1; }
+ void generate(uint32_t*, uint32_t*) {}
+};
+
+struct MutableOnlySeedSeq {
+ using result_type = uint32_t;
+ size_t size() { return 1; }
+ void generate(uint32_t*, uint32_t*) {}
+};
+
+struct ConstSeedSeq {
+ using result_type = uint64_t;
+ size_t size() const { return 1; }
+ void generate(uint32_t*, uint32_t*) const {}
+};
+
+static_assert(IsValidSeedSeqResultType<uint32_t>::value);
+static_assert(IsValidSeedSeqResultType<uint64_t>::value);
+static_assert(IsValidSeedSeqResultType<unsigned int>::value);
+static_assert(IsValidSeedSeqResultType<unsigned long>::value); // NOLINT
+static_assert(IsValidSeedSeqResultType<unsigned long long>::value); // NOLINT
+static_assert(IsValidSeedSeqResultType<std::seed_seq::result_type>::value);
+
+static_assert(!IsValidSeedSeqResultType<bool>::value);
+static_assert(!IsValidSeedSeqResultType<uint8_t>::value);
+static_assert(!IsValidSeedSeqResultType<uint16_t>::value);
+static_assert(!IsValidSeedSeqResultType<int32_t>::value);
+static_assert(!IsValidSeedSeqResultType<int64_t>::value);
+static_assert(!IsValidSeedSeqResultType<const uint32_t>::value);
+static_assert(!IsValidSeedSeqResultType<volatile uint32_t>::value);
+static_assert(!IsValidSeedSeqResultType<uint32_t&>::value);
+static_assert(!IsValidSeedSeqResultType<uint32_t&&>::value);
+static_assert(!IsValidSeedSeqResultType<float>::value);
+static_assert(!IsValidSeedSeqResultType<double>::value);
+static_assert(!IsValidSeedSeqResultType<void>::value);
+static_assert(!IsValidSeedSeqResultType<UnscopedU32Enum>::value);
+static_assert(!IsValidSeedSeqResultType<ScopedU32Enum>::value);
+static_assert(!IsValidSeedSeqResultType<EmptyStruct>::value);
+
+static_assert(!HasSeedSeqGenerate<NoResultSeedSeq>::value);
+static_assert(HasSeedSeqGenerate<MutableOnlySeedSeq&>::value);
+static_assert(!HasSeedSeqGenerate<const MutableOnlySeedSeq&>::value);
+static_assert(HasSeedSeqGenerate<const ConstSeedSeq&>::value);
+
+static_assert(HasSeedSeqSize<MutableOnlySeedSeq&>::value);
+static_assert(!HasSeedSeqSize<const MutableOnlySeedSeq&>::value);
+static_assert(HasSeedSeqSize<const ConstSeedSeq&>::value);
+static_assert(!HasSeedSeqSize<EmptyStruct>::value);
+
+static_assert(!IsDirectEntropySeedSeq<std::seed_seq>::value);
+static_assert(!IsDirectEntropySeedSeq<ConstSeedSeq>::value);
+static_assert(!IsDirectEntropySeedSeq<EmptyStruct>::value);
+
} // namespace