Validate stream deserialization invariants across absl/random. Deserializing malformed or out-of-range text via `operator>>` into `absl/random` distributions and engines previously bypassed constructor preconditions: * Invalid parameters (such as negative probabilities, inverted bounds, non-finite weights, oversized `discrete_distribution` weight counts, or out-of-range `randen_engine` buffer indices) were accepted without setting `failbit`, leaving objects with violated invariants, unbounded allocations, or out-of-bounds state reads on subsequent draws. * Unsigned integer stream reads accepted negative tokens via wraparound, 1-byte integer reads truncated out-of-range values, failed floating-point reads left uninitialized outputs, and engine `operator>>` leaked stream formatting flags. Reject invalid serialized inputs with `failbit` while leaving the target distribution or engine unchanged. PiperOrigin-RevId: 1022532452
diff --git a/absl/random/BUILD.bazel b/absl/random/BUILD.bazel index 42b59d3..162e328 100644 --- a/absl/random/BUILD.bazel +++ b/absl/random/BUILD.bazel
@@ -202,6 +202,7 @@ deps = [ ":distributions", ":random", + "//absl/random/internal:distribution_test_util", "//absl/random/internal:pcg_engine", "//absl/random/internal:sequence_urbg", "@googletest//:gtest",
diff --git a/absl/random/CMakeLists.txt b/absl/random/CMakeLists.txt index 700c271..cef4ab5 100644 --- a/absl/random/CMakeLists.txt +++ b/absl/random/CMakeLists.txt
@@ -268,6 +268,7 @@ ${ABSL_DEFAULT_LINKOPTS} DEPS absl::random_distributions + absl::random_internal_distribution_test_util absl::random_internal_pcg_engine absl::random_internal_sequence_urbg absl::random_random @@ -1263,6 +1264,7 @@ ${ABSL_DEFAULT_LINKOPTS} DEPS absl::random_internal_iostream_state_saver + GTest::gmock GTest::gtest_main )
diff --git a/absl/random/bernoulli_distribution.h b/absl/random/bernoulli_distribution.h index 10c24e6..efe1990 100644 --- a/absl/random/bernoulli_distribution.h +++ b/absl/random/bernoulli_distribution.h
@@ -17,6 +17,7 @@ #include <cassert> #include <cstdint> +#include <ios> #include <istream> #include <ostream> @@ -123,7 +124,11 @@ auto saver = random_internal::make_istream_state_saver(is); auto p = random_internal::read_floating_point<double>(is); if (!is.fail()) { - x.param(bernoulli_distribution::param_type(p)); + if (p >= 0.0 && p <= 1.0) { + x.param(bernoulli_distribution::param_type(p)); + } else { + is.setstate(std::ios_base::failbit); + } } return is; }
diff --git a/absl/random/bernoulli_distribution_test.cc b/absl/random/bernoulli_distribution_test.cc index 9c04bf6..ae2c846 100644 --- a/absl/random/bernoulli_distribution_test.cc +++ b/absl/random/bernoulli_distribution_test.cc
@@ -22,7 +22,9 @@ #include <string> #include <utility> +#include "gmock/gmock.h" #include "gtest/gtest.h" +#include "absl/random/internal/distribution_test_util.h" #include "absl/random/internal/pcg_engine.h" #include "absl/random/internal/sequence_urbg.h" #include "absl/random/random.h" @@ -216,4 +218,47 @@ } } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(BernoulliTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::bernoulli_distribution kInitial(0.25); + + // Valid boundary and subnormal probabilities. + EXPECT_THAT(ParseFromStream(kInitial, "0.0"), + ParsesEqualTo(absl::bernoulli_distribution(0.0))); + EXPECT_THAT(ParseFromStream(kInitial, "0.5"), + ParsesEqualTo(absl::bernoulli_distribution(0.5))); + EXPECT_THAT(ParseFromStream(kInitial, "1.0"), + ParsesEqualTo(absl::bernoulli_distribution(1.0))); + EXPECT_THAT(ParseFromStream(kInitial, "1e-320"), + ParsesEqualTo(absl::bernoulli_distribution(1e-320))); + + // Empty, out-of-range, and non-finite inputs under the default locale. + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, " "), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-0.1"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1.5"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "nan"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf"), FailsLeavingUnchanged()); + + // Non-finite values delivered with goodbit by a custom num_get facet. + EXPECT_THAT(ParseFromStream(kInitial, "nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); +} + } // namespace
diff --git a/absl/random/beta_distribution.h b/absl/random/beta_distribution.h index a2cdd25..b2d0f8f 100644 --- a/absl/random/beta_distribution.h +++ b/absl/random/beta_distribution.h
@@ -18,6 +18,7 @@ #include <cassert> #include <cmath> #include <cstdint> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -409,14 +410,21 @@ beta_distribution<RealType>& x) { // NOLINT(runtime/references) using result_type = typename beta_distribution<RealType>::result_type; using param_type = typename beta_distribution<RealType>::param_type; - result_type alpha, beta; auto saver = random_internal::make_istream_state_saver(is); - alpha = random_internal::read_floating_point<result_type>(is); + const result_type alpha = + random_internal::read_floating_point<result_type>(is); if (is.fail()) return is; - beta = random_internal::read_floating_point<result_type>(is); + const result_type beta = + random_internal::read_floating_point<result_type>(is); if (!is.fail()) { - x.param(param_type(alpha, beta)); + constexpr result_type kMax = (std::numeric_limits<result_type>::max)(); + if (alpha >= result_type(0) && beta >= result_type(0) && alpha <= kMax && + beta <= kMax) { + x.param(param_type(alpha, beta)); + } else { + is.setstate(std::ios_base::failbit); + } } return is; }
diff --git a/absl/random/beta_distribution_test.cc b/absl/random/beta_distribution_test.cc index 7e06cb2..b44bde0 100644 --- a/absl/random/beta_distribution_test.cc +++ b/absl/random/beta_distribution_test.cc
@@ -617,4 +617,67 @@ } } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(BetaDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::beta_distribution<double> kInitial(2.0, 3.0); + const absl::beta_distribution<float> kFloatInitial(2.0f, 3.0f); + + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-1.0 2.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2.0 -1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "nan 2.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2.0 nan"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf 2.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2.0 inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf 2.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2.0 -inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1e500 3.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2.0 1e500"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kFloatInitial, "1e40 1.0"), + FailsLeavingUnchanged()); + + // Non-finite values delivered with goodbit by a custom num_get facet. + EXPECT_THAT( + ParseFromStream(kInitial, "nan 2.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "2.0 nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "inf 2.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "2.0 inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "-inf 2.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "2.0 -inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "nan 2.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "2.0 inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + + EXPECT_THAT(ParseFromStream(kInitial, "0.0 0.0"), + ParsesEqualTo(absl::beta_distribution<double>(0.0, 0.0))); + EXPECT_THAT(ParseFromStream(kInitial, "1.5 2.5"), + ParsesEqualTo(absl::beta_distribution<double>(1.5, 2.5))); +} + } // namespace
diff --git a/absl/random/discrete_distribution.h b/absl/random/discrete_distribution.h index 35d42c8..de710a9 100644 --- a/absl/random/discrete_distribution.h +++ b/absl/random/discrete_distribution.h
@@ -15,9 +15,12 @@ #ifndef ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_ #define ABSL_RANDOM_DISCRETE_DISTRIBUTION_H_ +#include <algorithm> #include <cassert> +#include <cmath> #include <cstddef> #include <initializer_list> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -226,19 +229,42 @@ using param_type = typename discrete_distribution<IntType>::param_type; auto saver = random_internal::make_istream_state_saver(is); - size_t n; - std::vector<double> p; - - is >> n; - if (is.fail()) return is; - if (n > 0) { - p.reserve(n); - for (IntType i = 0; i < n && !is.fail(); ++i) { - auto tmp = random_internal::read_floating_point<double>(is); - if (is.fail()) return is; - p.push_back(tmp); + size_t n = 0; + if (!random_internal::read_integral(is, n)) { + return is; + } + if (n == 0) { + is.setstate(std::ios_base::failbit); + return is; + } + if constexpr (std::numeric_limits<IntType>::digits < + std::numeric_limits<size_t>::digits) { + if (n - 1 > static_cast<size_t>((std::numeric_limits<IntType>::max)())) { + is.setstate(std::ios_base::failbit); + return is; } } + std::vector<double> p; + p.reserve((std::min)(n, size_t{1024})); + double sum = 0.0; + for (size_t i = 0; i < n; ++i) { + auto tmp = random_internal::read_floating_point<double>(is); + if (is.fail()) return is; + if (!(tmp >= 0.0 && std::isfinite(tmp))) { + is.setstate(std::ios_base::failbit); + return is; + } + sum += tmp; + if (!std::isfinite(sum)) { + is.setstate(std::ios_base::failbit); + return is; + } + p.push_back(tmp); + } + if (!(sum > 0.0)) { + is.setstate(std::ios_base::failbit); + return is; + } x.param(param_type(p.begin(), p.end())); return is; }
diff --git a/absl/random/discrete_distribution_test.cc b/absl/random/discrete_distribution_test.cc index 9d961f7..8fffb41 100644 --- a/absl/random/discrete_distribution_test.cc +++ b/absl/random/discrete_distribution_test.cc
@@ -249,4 +249,104 @@ EXPECT_THAT(output, testing::ElementsAre(3, 3, 0, 3, 0, 4)); } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(DiscreteDistributionTest, MaxNarrowTypeSerializationRoundTrips) { + // 256 weights for uint8_t (max == 255) previously wrapped uint8_t loop index + // at 255 -> 0; 128 weights for int8_t (max == 127) overflowed signed int8_t. + { + std::vector<double> weights(256, 1.0); + const absl::discrete_distribution<uint8_t> expected(weights.begin(), + weights.end()); + std::ostringstream oss; + oss << expected; + EXPECT_THAT(absl::random_internal::ParseFromStream( + absl::discrete_distribution<uint8_t>(), oss.str()), + ParsesEqualTo(expected)); + } + { + std::vector<double> weights(128, 1.0); + const absl::discrete_distribution<int8_t> expected(weights.begin(), + weights.end()); + std::ostringstream oss; + oss << expected; + EXPECT_THAT(absl::random_internal::ParseFromStream( + absl::discrete_distribution<int8_t>(), oss.str()), + ParsesEqualTo(expected)); + } +} + +TEST(DiscreteDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::discrete_distribution<int> kInitial({1.0, 2.0}); + const absl::discrete_distribution<int8_t> kI8Initial({1.0, 2.0}); + const absl::discrete_distribution<uint8_t> kU8Initial({1.0, 2.0}); + + // Valid streams including subnormal positive weight. + EXPECT_THAT(ParseFromStream(kInitial, "2 0.25 0.75"), + ParsesEqualTo(absl::discrete_distribution<int>({0.25, 0.75}))); + EXPECT_THAT(ParseFromStream(kInitial, "2 1e-320 1.0"), + ParsesEqualTo(absl::discrete_distribution<int>({1e-320, 1.0}))); + + // Empty, malformed, zero, and negative counts (including unsigned wraparound + // to n == 2 on 64-bit platforms). + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "abc"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-1 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-2 0.5 0.5"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-18446744073709551614 0.25 0.75"), + FailsLeavingUnchanged()); + + // Count exceeding IntType::max() + 1 or huge truncated count (must not OOM). + EXPECT_THAT(ParseFromStream(kI8Initial, "129 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "257 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1000000000000 1.0"), + FailsLeavingUnchanged()); + + // Truncated, all-zero, negative, overflowing-sum, and non-finite weights. + EXPECT_THAT(ParseFromStream(kInitial, "2 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1 0.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "3 0.0 0.0 0.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 -1.0 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 -1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 1e308 1e308"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "3 1e308 1e308 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 nan 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 nan"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 inf 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "2 1.0 -inf"), FailsLeavingUnchanged()); + + // Non-finite weights delivered with goodbit by a custom num_get facet. + EXPECT_THAT( + ParseFromStream(kInitial, "2 nan 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "2 1.0 nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "2 inf 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "2 1.0 inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "2 1.0 -inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); +} + } // namespace
diff --git a/absl/random/exponential_distribution.h b/absl/random/exponential_distribution.h index 21a0279..507a362 100644 --- a/absl/random/exponential_distribution.h +++ b/absl/random/exponential_distribution.h
@@ -18,6 +18,7 @@ #include <cassert> #include <cmath> #include <cstdint> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -152,12 +153,16 @@ exponential_distribution<RealType>& x) { // NOLINT(runtime/references) using result_type = typename exponential_distribution<RealType>::result_type; using param_type = typename exponential_distribution<RealType>::param_type; - result_type lambda; auto saver = random_internal::make_istream_state_saver(is); - lambda = random_internal::read_floating_point<result_type>(is); + const result_type lambda = + random_internal::read_floating_point<result_type>(is); if (!is.fail()) { - x.param(param_type(lambda)); + if (lambda > 0 && lambda <= (std::numeric_limits<result_type>::max)()) { + x.param(param_type(lambda)); + } else { + is.setstate(std::ios_base::failbit); + } } return is; }
diff --git a/absl/random/exponential_distribution_test.cc b/absl/random/exponential_distribution_test.cc index 71be99e..ea167c9 100644 --- a/absl/random/exponential_distribution_test.cc +++ b/absl/random/exponential_distribution_test.cc
@@ -423,4 +423,50 @@ } } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(ExponentialDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::exponential_distribution<double> kInitial(2.5); + const absl::exponential_distribution<float> kFloatInitial(2.5f); + + // Valid positive and subnormal lambdas. + EXPECT_THAT(ParseFromStream(kInitial, "1.0"), + ParsesEqualTo(absl::exponential_distribution<double>(1.0))); + EXPECT_THAT(ParseFromStream(kInitial, "1e-320"), + ParsesEqualTo(absl::exponential_distribution<double>(1e-320))); + + // Empty, non-positive, overflowing, and non-finite inputs. + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "nan"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1e400"), FailsLeavingUnchanged()); + + // Non-finite values delivered with goodbit by a custom num_get facet. + EXPECT_THAT(ParseFromStream(kInitial, "nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); +} + } // namespace
diff --git a/absl/random/gaussian_distribution.h b/absl/random/gaussian_distribution.h index d14de0b..9511b3d 100644 --- a/absl/random/gaussian_distribution.h +++ b/absl/random/gaussian_distribution.h
@@ -24,6 +24,7 @@ #include <cmath> #include <cstdint> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -197,11 +198,15 @@ using param_type = typename gaussian_distribution<RealType>::param_type; auto saver = random_internal::make_istream_state_saver(is); - auto mean = random_internal::read_floating_point<result_type>(is); + const auto mean = random_internal::read_floating_point<result_type>(is); if (is.fail()) return is; - auto stddev = random_internal::read_floating_point<result_type>(is); + const auto stddev = random_internal::read_floating_point<result_type>(is); if (!is.fail()) { - x.param(param_type(mean, stddev)); + if (std::isfinite(mean) && std::isfinite(stddev)) { + x.param(param_type(mean, stddev)); + } else { + is.setstate(std::ios_base::failbit); + } } return is; }
diff --git a/absl/random/gaussian_distribution_test.cc b/absl/random/gaussian_distribution_test.cc index 65fd85a..c876f94 100644 --- a/absl/random/gaussian_distribution_test.cc +++ b/absl/random/gaussian_distribution_test.cc
@@ -561,4 +561,69 @@ } } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(GaussianDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::gaussian_distribution<double> kInitial(1.0, 2.0); + const absl::gaussian_distribution<float> kFloatInitial(1.0f, 2.0f); + + // Valid streams including zero/negative stddev and subnormal values. + EXPECT_THAT(ParseFromStream(kInitial, "0.0 1.0"), + ParsesEqualTo(absl::gaussian_distribution<double>(0.0, 1.0))); + EXPECT_THAT(ParseFromStream(kInitial, "2.5 -1.5"), + ParsesEqualTo(absl::gaussian_distribution<double>(2.5, -1.5))); + EXPECT_THAT(ParseFromStream(kInitial, "0.0 0.0"), + ParsesEqualTo(absl::gaussian_distribution<double>(0.0, 0.0))); + EXPECT_THAT(ParseFromStream(kInitial, "1e-320 1.0"), + ParsesEqualTo(absl::gaussian_distribution<double>(1e-320, 1.0))); + + // Truncated, overflowing, and non-finite inputs under the default locale. + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "nan 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0 nan"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0 inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0 -inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1e400 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0 1e400"), FailsLeavingUnchanged()); + + // Non-finite values delivered with goodbit by a custom num_get facet. + EXPECT_THAT( + ParseFromStream(kInitial, "nan 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "0.0 nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "inf 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "0.0 inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "-inf 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "0.0 -inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "nan 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "0.0 inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); +} + } // namespace
diff --git a/absl/random/internal/distribution_test_util.cc b/absl/random/internal/distribution_test_util.cc index e342499..237a1c8 100644 --- a/absl/random/internal/distribution_test_util.cc +++ b/absl/random/internal/distribution_test_util.cc
@@ -16,7 +16,9 @@ #include <cassert> #include <cmath> +#include <ios> #include <limits> +#include <locale> #include <ostream> #include <string> @@ -497,6 +499,96 @@ return max_err; } +namespace { + +class NonFiniteNumGet final : public std::num_get<char> { + protected: + using std::num_get<char>::do_get; + + iter_type do_get(iter_type in, iter_type end, + std::ios_base& str, // NOLINT(runtime/references) + std::ios_base::iostate& err, // NOLINT(runtime/references) + float& v) const override { // NOLINT(runtime/references) + return ParseFloat(in, end, str, err, v); + } + + iter_type do_get(iter_type in, iter_type end, + std::ios_base& str, // NOLINT(runtime/references) + std::ios_base::iostate& err, // NOLINT(runtime/references) + double& v) const override { // NOLINT(runtime/references) + return ParseFloat(in, end, str, err, v); + } + + iter_type do_get( + iter_type in, iter_type end, + std::ios_base& str, // NOLINT(runtime/references) + std::ios_base::iostate& err, // NOLINT(runtime/references) + long double& v) const override { // NOLINT(runtime/references) + return ParseFloat(in, end, str, err, v); + } + + private: + template <typename T> + iter_type ParseFloat( + iter_type in, iter_type end, + std::ios_base& str, // NOLINT(runtime/references) + std::ios_base::iostate& err, // NOLINT(runtime/references) + T& v) const { // NOLINT(runtime/references) + if (in == end) { + return std::num_get<char>::do_get(in, end, str, err, v); + } + bool negative = false; + if (*in == '-' || *in == '+') { + negative = (*in == '-'); + ++in; + if (in == end || *in == '-' || *in == '+') { + v = T{0}; + err |= std::ios_base::failbit; + if (in == end) err |= std::ios_base::eofbit; + return in; + } + } + auto match_literal = [&](const char* literal, T result) { + for (const char* p = literal; *p != '\0'; ++p) { + if (in == end || *in != *p) { + v = T{0}; + err |= std::ios_base::failbit; + if (in == end) err |= std::ios_base::eofbit; + return in; + } + ++in; + } + if (in == end) { + err |= std::ios_base::eofbit; + } else if (*in != ' ' && *in != '\t' && *in != '\n' && *in != '\r') { + v = T{0}; + err |= std::ios_base::failbit; + return in; + } + v = negative ? -result : result; + return in; + }; + if (*in == 'n') { + return match_literal("nan", std::numeric_limits<T>::quiet_NaN()); + } + if (*in == 'i') { + return match_literal("inf", std::numeric_limits<T>::infinity()); + } + in = std::num_get<char>::do_get(in, end, str, err, v); + if (negative) { + v = -v; + } + return in; + } +}; + +} // namespace + +void ImbueNonFiniteLocale(std::ios* stream) { + ABSL_ASSERT(stream != nullptr); + stream->imbue(std::locale(stream->getloc(), new NonFiniteNumGet())); +} + } // namespace random_internal ABSL_NAMESPACE_END } // namespace absl
diff --git a/absl/random/internal/distribution_test_util.h b/absl/random/internal/distribution_test_util.h index e6e3544..b7afbf4 100644 --- a/absl/random/internal/distribution_test_util.h +++ b/absl/random/internal/distribution_test_util.h
@@ -16,7 +16,11 @@ #define ABSL_RANDOM_INTERNAL_DISTRIBUTION_TEST_UTIL_H_ #include <cstddef> +#include <ios> #include <ostream> +#include <sstream> +#include <string> +#include <utility> #include "absl/base/config.h" #include "absl/strings/string_view.h" @@ -105,6 +109,60 @@ // not flat to double precision. double BetaIncompleteInv(double p, double q, double alpha); +// Imbues `stream` with a test-only `std::num_get<char>` facet that parses +// "nan", "inf", and "-inf" with goodbit so stream deserialization tests can +// exercise distribution `std::isfinite()` and range guards even on libc++ and +// libstdc++, where the default `num_get` facet already sets failbit on those +// tokens. +void ImbueNonFiniteLocale(std::ios* stream); + +// Result of extracting a distribution from a test stream via `ParseFromStream`. +template <typename T> +struct StreamParseResult { + bool failed = false; + bool flags_preserved = false; + T value; + T initial; +}; + +template <typename T> +void PrintTo(const StreamParseResult<T>& result, std::ostream* os) { + *os << "{failed=" << (result.failed ? "true" : "false") + << ", flags_preserved=" << (result.flags_preserved ? "true" : "false") + << ", value=" << result.value << "}"; +} + +// Extracts a `T` from `input` into a copy of `initial`, setting non-default +// stream formatting flags (`hex | left | scientific`) beforehand to verify +// `istream_state_saver` flag restoration and optionally imbuing a non-finite +// `num_get` facet to exercise non-finite parameter validation. +template <typename T> +StreamParseResult<T> ParseFromStream(const T& initial, const std::string& input, + bool use_non_finite_facet = false) { + const std::ios_base::fmtflags kInitFlags = + std::ios_base::hex | std::ios_base::left | std::ios_base::scientific; + T value = initial; + std::istringstream is(input); + if (use_non_finite_facet) { + ImbueNonFiniteLocale(&is); + } + is.flags(kInitFlags); + is >> value; + return {is.fail(), is.flags() == kInitFlags, std::move(value), initial}; +} + +template <typename T> +StreamParseResult<T> ParseFromStream(const T& initial, + const std::wstring& input) { + const std::ios_base::fmtflags kInitFlags = + std::ios_base::hex | std::ios_base::left | std::ios_base::scientific; + T value = initial; + std::wistringstream is(input); + is.flags(kInitFlags); + is >> value; + return {is.fail(), is.flags() == kInitFlags, std::move(value), initial}; +} + } // namespace random_internal ABSL_NAMESPACE_END } // namespace absl
diff --git a/absl/random/internal/distribution_test_util_test.cc b/absl/random/internal/distribution_test_util_test.cc index f614e42..4a77774 100644 --- a/absl/random/internal/distribution_test_util_test.cc +++ b/absl/random/internal/distribution_test_util_test.cc
@@ -16,6 +16,9 @@ #include <cmath> #include <limits> +#include <ostream> +#include <sstream> +#include <string> #include <utility> #include <vector> @@ -27,6 +30,7 @@ using absl::random_internal::BetaIncomplete; using absl::random_internal::BetaIncompleteInv; using absl::random_internal::erfinv; +using absl::random_internal::ImbueNonFiniteLocale; using absl::random_internal::InverseNormalSurvival; using absl::random_internal::MaxErrorTolerance; using absl::random_internal::RequiredSuccessProbability; @@ -416,4 +420,94 @@ EXPECT_THAT(erfinv(kNan), IsNan()); } +template <typename T> +struct ImbuedParseResult { + bool failed = false; + T value = T{0}; +}; + +template <typename T> +void PrintTo(const ImbuedParseResult<T>& r, std::ostream* os) { + *os << "{failed=" << (r.failed ? "true" : "false") << ", value=" << r.value + << "}"; +} + +template <typename T> +ImbuedParseResult<T> ParseImbued(const std::string& input) { + std::istringstream is(input); + ImbueNonFiniteLocale(&is); + T v = T{42}; + is >> v; + return {is.fail(), v}; +} + +MATCHER_P(ParsesFinite, expected, "") { + return !arg.failed && arg.value == expected && + std::signbit(arg.value) == std::signbit(expected); +} + +MATCHER(ParsesNan, "") { return !arg.failed && std::isnan(arg.value); } + +MATCHER_P(ParsesInf, positive, "") { + return !arg.failed && std::isinf(arg.value) && + (positive ? arg.value > 0 : arg.value < 0); +} + +MATCHER(FailsImbuedParse, "") { return arg.failed; } + +TEST(ImbueNonFiniteLocale, ParsesNonFiniteAndDelegatesFiniteValues) { + EXPECT_THAT(ParseImbued<float>("nan"), ParsesNan()); + EXPECT_THAT(ParseImbued<float>("inf"), ParsesInf(true)); + EXPECT_THAT(ParseImbued<float>("-inf"), ParsesInf(false)); + EXPECT_THAT(ParseImbued<float>("+inf"), ParsesInf(true)); + EXPECT_THAT(ParseImbued<float>("1.5"), ParsesFinite(1.5f)); + EXPECT_THAT(ParseImbued<float>("-1.5"), ParsesFinite(-1.5f)); + EXPECT_THAT(ParseImbued<float>("-0.0"), ParsesFinite(-0.0f)); + EXPECT_THAT(ParseImbued<float>("-3.402823466e+38"), + ParsesFinite(std::numeric_limits<float>::lowest())); + + EXPECT_THAT(ParseImbued<double>("nan"), ParsesNan()); + EXPECT_THAT(ParseImbued<double>("inf"), ParsesInf(true)); + EXPECT_THAT(ParseImbued<double>("-inf"), ParsesInf(false)); + EXPECT_THAT(ParseImbued<double>("1.5"), ParsesFinite(1.5)); + EXPECT_THAT(ParseImbued<double>("-1.5"), ParsesFinite(-1.5)); + EXPECT_THAT(ParseImbued<double>("-0.0"), ParsesFinite(-0.0)); + EXPECT_THAT(ParseImbued<double>("-1.7976931348623157e+308"), + ParsesFinite(std::numeric_limits<double>::lowest())); + + EXPECT_THAT(ParseImbued<long double>("nan"), ParsesNan()); + EXPECT_THAT(ParseImbued<long double>("inf"), ParsesInf(true)); + EXPECT_THAT(ParseImbued<long double>("-inf"), ParsesInf(false)); + EXPECT_THAT(ParseImbued<long double>("1.5"), ParsesFinite(1.5L)); + EXPECT_THAT(ParseImbued<long double>("-1.5"), ParsesFinite(-1.5L)); + + // Multi-token extraction preserves stream position across non-finite and + // finite tokens, including integral extractions on the same stream. + std::istringstream seq("2 nan 1.5 -inf -2.25"); + ImbueNonFiniteLocale(&seq); + int count = 0; + double a = 0.0; + double b = 0.0; + double c = 0.0; + double d = 0.0; + seq >> count >> a >> b >> c >> d; + ASSERT_FALSE(seq.fail()); + EXPECT_EQ(count, 2); + EXPECT_TRUE(std::isnan(a)); + EXPECT_EQ(b, 1.5); + EXPECT_TRUE(std::isinf(c) && c < 0.0); + EXPECT_EQ(d, -2.25); + + EXPECT_THAT(ParseImbued<double>(""), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("-"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("+"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("--1.5"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("+-1.5"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("not_a_number"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("infxyz"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("nan1"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("1e400"), FailsImbuedParse()); + EXPECT_THAT(ParseImbued<double>("-1e400"), FailsImbuedParse()); +} + } // namespace
diff --git a/absl/random/internal/iostream_state_saver.h b/absl/random/internal/iostream_state_saver.h index 05d9f83..985e0f8 100644 --- a/absl/random/internal/iostream_state_saver.h +++ b/absl/random/internal/iostream_state_saver.h
@@ -177,6 +177,55 @@ struct stream_format_type : public std::conditional<(sizeof(T) == sizeof(char)), int, T> {}; +// Extracts an integral value of type `IntType` from `is`, storing it in `out` +// on success and returning `true`. On failure, sets `std::ios_base::failbit` +// (if not already failed) and returns `false` without modifying `out`. +// +// Rejects leading '-' for unsigned `IntType` (preventing standard `num_get` +// modular wraparound) and validates range bounds for 1-byte types widened to +// `int` via `stream_format_type`. +template <typename IntType, typename CharT, typename Traits> +inline bool read_integral( + std::basic_istream<CharT, Traits>& is, // NOLINT(runtime/references) + IntType& out) { // NOLINT(runtime/references) + static_assert(std::numeric_limits<IntType>::is_integer); + using stream_type = typename stream_format_type<IntType>::type; + if constexpr (!std::numeric_limits<IntType>::is_signed) { + { + typename std::basic_istream<CharT, Traits>::sentry ok(is); + if (!ok) { + return false; + } + } + const typename Traits::int_type ch = is.peek(); + if (is.fail()) { + return false; + } + if (!Traits::eq_int_type(ch, Traits::eof()) && + Traits::eq(Traits::to_char_type(ch), is.widen('-'))) { + is.setstate(std::ios_base::failbit); + return false; + } + } + stream_type val = 0; + is >> val; + if (is.fail()) { + return false; + } + if constexpr (!std::is_same_v<stream_type, IntType>) { + constexpr stream_type kMin = + static_cast<stream_type>((std::numeric_limits<IntType>::min)()); + constexpr stream_type kMax = + static_cast<stream_type>((std::numeric_limits<IntType>::max)()); + if (val < kMin || val > kMax) { + is.setstate(std::ios_base::failbit); + return false; + } + } + out = static_cast<IntType>(val); + return true; +} + // stream_u128_helper allows us to write out either absl::uint128 or // __uint128_t types in the same way, which enables their use as internal // state of PRNG engines. @@ -189,7 +238,9 @@ absl::uint128 read(IStream& in) { uint64_t h = 0; uint64_t l = 0; - in >> h >> l; + if (!read_integral(in, h) || !read_integral(in, l)) { + return absl::uint128{0}; + } return absl::MakeUint128(h, l); } @@ -208,7 +259,9 @@ __uint128_t read(IStream& in) { uint64_t h = 0; uint64_t l = 0; - in >> h >> l; + if (!read_integral(in, h) || !read_integral(in, l)) { + return 0; + } return (static_cast<__uint128_t>(h) << 64) | l; } @@ -224,7 +277,10 @@ template <typename FloatType, typename IStream> inline FloatType read_floating_point(IStream& is) { static_assert(std::is_floating_point_v<FloatType>); - FloatType dest; + if (is.fail()) { + return FloatType{0}; + } + FloatType dest = 0; is >> dest; // Parsing a double value may report a subnormal value as an error // despite being able to represent it. @@ -233,7 +289,7 @@ // ERANGE error, as the parsed value may be smaller than DOUBLE_MIN // and rounded up. // See: https://stackoverflow.com/q/42005462 - if (is.fail() && + if (is.fail() && !is.bad() && (std::fabs(dest) == (std::numeric_limits<FloatType>::min)() || std::fpclassify(dest) == FP_SUBNORMAL)) { is.clear(is.rdstate() & (~std::ios_base::failbit));
diff --git a/absl/random/internal/iostream_state_saver_test.cc b/absl/random/internal/iostream_state_saver_test.cc index a196ace..8edbfe7 100644 --- a/absl/random/internal/iostream_state_saver_test.cc +++ b/absl/random/internal/iostream_state_saver_test.cc
@@ -20,11 +20,14 @@ #include <cstdint> #include <cstdlib> #include <ios> +#include <istream> #include <limits> +#include <ostream> #include <sstream> #include <string> #include <type_traits> +#include "gmock/gmock.h" #include "gtest/gtest.h" namespace { @@ -375,4 +378,200 @@ // errno may equal ERANGE. } +template <typename FloatType> +struct FloatReadResult { + bool ok = false; + bool failed = false; + FloatType out = 0; + FloatType initial = 0; +}; + +template <typename FloatType> +void PrintTo(const FloatReadResult<FloatType>& r, std::ostream* os) { + *os << "{ok=" << (r.ok ? "true" : "false") + << ", failed=" << (r.failed ? "true" : "false") << ", out=" << r.out + << "}"; +} + +template <typename FloatType> +FloatReadResult<FloatType> ReadFloat(const std::string& input) { + std::istringstream is(input); + const FloatType val = + absl::random_internal::read_floating_point<FloatType>(is); + return {!is.fail(), is.fail(), val, FloatType{0}}; +} + +template <typename IntType> +struct IntReadResult { + bool ok = false; + bool failed = false; + IntType out; + IntType initial; +}; + +template <typename IntType> +void PrintTo(const IntReadResult<IntType>& r, std::ostream* os) { + using format_type = + typename absl::random_internal::stream_format_type<IntType>::type; + *os << "{ok=" << (r.ok ? "true" : "false") + << ", failed=" << (r.failed ? "true" : "false") + << ", out=" << static_cast<format_type>(r.out) + << ", initial=" << static_cast<format_type>(r.initial) << "}"; +} + +template <typename IntType> +IntReadResult<IntType> ReadInt(const std::string& input, IntType sentinel) { + IntType out = sentinel; + std::istringstream is(input); + const bool ok = absl::random_internal::read_integral(is, out); + return {ok, is.fail(), out, sentinel}; +} + +template <typename IntType> +IntReadResult<IntType> ReadInt(const std::wstring& input, IntType sentinel) { + IntType out = sentinel; + std::wistringstream is(input); + const bool ok = absl::random_internal::read_integral(is, out); + return {ok, is.fail(), out, sentinel}; +} + +MATCHER(FailsPreservingOut, + "fails extraction and leaves output equal to initial value") { + return !arg.ok && arg.failed && arg.out == arg.initial; +} + +MATCHER_P(ReadsValue, expected, + "succeeds without failbit and extracts expected value") { + return arg.ok && !arg.failed && arg.out == expected; +} + +TEST(ReadFloatingPointTest, EmptyAndInvalidStreamsPreserveFailbit) { + using absl::random_internal::read_floating_point; + + EXPECT_THAT(ReadFloat<double>(""), FailsPreservingOut()); + EXPECT_THAT(ReadFloat<double>(" "), FailsPreservingOut()); + EXPECT_THAT(ReadFloat<double>("invalid"), FailsPreservingOut()); + + // Underflow to 0.0: preserve whatever failbit std::num_get sets (libc++ and + // MSVC fail on ERANGE underflow; libstdc++ succeeds with 0.0). + { + std::istringstream raw("1e-400"); + double raw_val = 1.0; + raw >> raw_val; + + std::istringstream is("1e-400"); + const double val = read_floating_point<double>(is); + EXPECT_EQ(is.fail(), raw.fail()); + EXPECT_EQ(val, 0.0); + } + // Overflow: all standard libraries set failbit (assigning +inf or DBL_MAX). + { + std::istringstream is("1e400"); + const double val = read_floating_point<double>(is); + EXPECT_TRUE(is.fail()); + EXPECT_TRUE(std::isinf(val) || val == (std::numeric_limits<double>::max)()); + } + + // Pre-failed stream returns 0 without consuming input or clearing failbit. + { + std::istringstream is("1.5"); + is.setstate(std::ios_base::failbit); + const double val = read_floating_point<double>(is); + EXPECT_TRUE(is.fail()); + EXPECT_EQ(val, 0.0); + is.clear(); + double remaining = 0.0; + is >> remaining; + EXPECT_EQ(remaining, 1.5); + } + + // Pre-failed badbit streams short-circuit, preserving badbit and failbit. + { + std::istream null_is(nullptr); + const double val = read_floating_point<double>(null_is); + EXPECT_TRUE(null_is.bad()); + EXPECT_TRUE(null_is.fail()); + EXPECT_EQ(val, 0.0); + } + { + std::istringstream is("4.94065645841246544e-324"); + is.setstate(std::ios_base::badbit); + const double val = read_floating_point<double>(is); + EXPECT_TRUE(is.bad()); + EXPECT_TRUE(is.fail()); + EXPECT_EQ(val, 0.0); + } + + // Subnormal and min values continue to succeed without failbit. + EXPECT_THAT(ReadFloat<double>("4.94065645841246544e-324"), + ReadsValue(std::numeric_limits<double>::denorm_min())); +} + +TEST(ReadIntegralTest, UnsignedRejectsNegativeAndPreservesOut) { + using absl::random_internal::read_integral; + + EXPECT_THAT(ReadInt<uint64_t>("", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint64_t>(" ", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint64_t>("-", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint64_t>("-0", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint64_t>("-1", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint64_t>(" -42", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint64_t>("abc", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint64_t>("99999999999999999999999", 77), + FailsPreservingOut()); + + EXPECT_THAT(ReadInt<uint8_t>("-0", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint8_t>("-1", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint8_t>("256", 77), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint8_t>("300", 77), FailsPreservingOut()); + + EXPECT_THAT(ReadInt<bool>("-0", true), FailsPreservingOut()); + EXPECT_THAT(ReadInt<bool>("-1", true), FailsPreservingOut()); + EXPECT_THAT(ReadInt<bool>("2", true), FailsPreservingOut()); + + EXPECT_THAT(ReadInt<uint32_t>(L" -5", 99), FailsPreservingOut()); + EXPECT_THAT(ReadInt<uint32_t>(L" 42", 0), ReadsValue(42u)); + + uint32_t out = 55; + std::istream null_is(nullptr); + EXPECT_FALSE(read_integral(null_is, out)); + EXPECT_TRUE(null_is.bad()); + EXPECT_EQ(out, 55u); +} + +TEST(ReadIntegralTest, SignedAndNarrowBounds) { + using absl::random_internal::read_integral; + + EXPECT_THAT(ReadInt<int8_t>("", 11), FailsPreservingOut()); + EXPECT_THAT(ReadInt<int8_t>("abc", 11), FailsPreservingOut()); + EXPECT_THAT(ReadInt<int8_t>("-129", 11), FailsPreservingOut()); + EXPECT_THAT(ReadInt<int8_t>("128", 11), FailsPreservingOut()); + EXPECT_THAT(ReadInt<int8_t>("-254", 11), FailsPreservingOut()); + EXPECT_THAT(ReadInt<int8_t>("258", 11), FailsPreservingOut()); + + EXPECT_THAT(ReadInt<int8_t>("-128", 0), ReadsValue(int8_t{-128})); + EXPECT_THAT(ReadInt<int8_t>("127", 0), ReadsValue(int8_t{127})); + EXPECT_THAT(ReadInt<uint8_t>("0", 1), ReadsValue(uint8_t{0})); + EXPECT_THAT(ReadInt<uint8_t>("255", 1), ReadsValue(uint8_t{255})); + + { + int8_t lo = 0; + int8_t hi = 0; + std::istringstream is("-128 127"); + EXPECT_TRUE(read_integral(is, lo)); + EXPECT_TRUE(read_integral(is, hi)); + EXPECT_EQ(lo, -128); + EXPECT_EQ(hi, 127); + } + { + uint8_t lo = 1; + uint8_t hi = 1; + std::istringstream is("0 255"); + EXPECT_TRUE(read_integral(is, lo)); + EXPECT_TRUE(read_integral(is, hi)); + EXPECT_EQ(lo, 0u); + EXPECT_EQ(hi, 255u); + } +} + } // namespace
diff --git a/absl/random/internal/pcg_engine.h b/absl/random/internal/pcg_engine.h index f85a1ac..e785392 100644 --- a/absl/random/internal/pcg_engine.h +++ b/absl/random/internal/pcg_engine.h
@@ -144,18 +144,21 @@ operator>>( std::basic_istream<CharT, Traits>& is, // NOLINT(runtime/references) pcg_engine& engine) { // NOLINT(runtime/references) + auto saver = random_internal::make_istream_state_saver(is); random_internal::stream_u128_helper<state_type> helper; auto mult = helper.read(is); auto inc = helper.read(is); auto tmp = helper.read(is); + if (is.fail()) { + return is; + } if (mult != pcg_engine::params_type::multiplier() || inc != pcg_engine::params_type::increment()) { // signal failure by setting the failbit. - is.setstate(is.rdstate() | std::ios_base::failbit); + is.setstate(std::ios_base::failbit); + return is; } - if (!is.fail()) { - engine.state_ = tmp; - } + engine.state_ = tmp; return is; } @@ -165,16 +168,20 @@ operator>>( std::basic_istream<CharT, Traits>& is, // NOLINT(runtime/references) pcg_engine& engine) { // NOLINT(runtime/references) + auto saver = random_internal::make_istream_state_saver(is); state_type mult{}, inc{}, tmp{}; - is >> mult >> inc >> tmp; + if (!random_internal::read_integral(is, mult) || + !random_internal::read_integral(is, inc) || + !random_internal::read_integral(is, tmp)) { + return is; + } if (mult != pcg_engine::params_type::multiplier() || inc != pcg_engine::params_type::increment()) { // signal failure by setting the failbit. - is.setstate(is.rdstate() | std::ios_base::failbit); + is.setstate(std::ios_base::failbit); + return is; } - if (!is.fail()) { - engine.state_ = tmp; - } + engine.state_ = tmp; return is; }
diff --git a/absl/random/internal/pcg_engine_test.cc b/absl/random/internal/pcg_engine_test.cc index 9b34cfe..938dc85 100644 --- a/absl/random/internal/pcg_engine_test.cc +++ b/absl/random/internal/pcg_engine_test.cc
@@ -19,10 +19,15 @@ #include <cmath> #include <cstddef> #include <cstdint> +#include <ios> +#include <ostream> #include <random> #include <sstream> +#include <string> #include <type_traits> +#include <vector> +#include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/random/internal/explicit_seed_seq.h" @@ -271,6 +276,137 @@ } } +template <typename Engine> +std::vector<std::string> SerializeTokens(const Engine& engine) { + std::ostringstream oss; + oss << engine; + std::istringstream iss(oss.str()); + std::vector<std::string> tokens; + std::string token; + while (iss >> token) { + tokens.push_back(token); + } + return tokens; +} + +std::string JoinTokens(const std::vector<std::string>& tokens) { + std::ostringstream oss; + for (size_t i = 0; i < tokens.size(); ++i) { + if (i > 0) oss << ' '; + oss << tokens[i]; + } + return oss.str(); +} + +std::string ReplaceToken(std::vector<std::string> tokens, size_t index, + const std::string& value) { + tokens[index] = value; + return JoinTokens(tokens); +} + +std::string TruncateTokens(std::vector<std::string> tokens, size_t count) { + tokens.resize(count); + return JoinTokens(tokens); +} + +template <typename Engine> +struct EngineParseResult { + bool failed = false; + bool flags_preserved = false; + Engine value; + Engine initial; +}; + +template <typename Engine> +void PrintTo(const EngineParseResult<Engine>& r, std::ostream* os) { + *os << "{failed=" << (r.failed ? "true" : "false") + << ", flags_preserved=" << (r.flags_preserved ? "true" : "false") + << ", unchanged=" << (r.value == r.initial ? "true" : "false") << "}"; +} + +template <typename Engine> +EngineParseResult<Engine> ParseEngine(const Engine& initial, + const std::string& input) { + const std::ios_base::fmtflags kInitFlags = + std::ios_base::hex | std::ios_base::showbase | std::ios_base::skipws; + Engine target = initial; + std::istringstream iss(input); + iss.flags(kInitFlags); + iss >> target; + return {iss.fail(), iss.flags() == kInitFlags, target, initial}; +} + +MATCHER(FailsLeavingUnchanged, + "fails extraction while preserving engine state and stream flags") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualToPtr, expected, + "succeeds, restores expected engine state, and preserves flags") { + return !arg.failed && arg.flags_preserved && arg.value == *expected; +} + +template <typename Engine> +auto ParsesEqualTo(const Engine& expected) { + return ParsesEqualToPtr(&expected); +} + +TYPED_TEST(PCGEngineTest, StreamDeserializationValidation) { + using engine_type = TypeParam; + engine_type expected(42); + expected.discard(3); + const engine_type initial(7); + ASSERT_FALSE(initial == expected); + + const std::vector<std::string> tokens = SerializeTokens(expected); + ASSERT_TRUE(tokens.size() == 3u || tokens.size() == 6u); + const std::string valid_stream = JoinTokens(tokens); + const size_t n = tokens.size(); + + // Valid round-trip succeeds in decimal and restores caller stream flags. + EXPECT_THAT(ParseEngine(initial, valid_stream), ParsesEqualTo(expected)); + + // Mismatched multiplier and increment fail without modifying engine state. + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "0")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n / 3, "0")), + FailsLeavingUnchanged()); + + // Negative tokens (including "-0") are rejected at every field position + // (covering both 64-bit state_type and both words of 128-bit state_type). + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-0")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 1, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 2, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 3, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 2, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1, "-0")), + FailsLeavingUnchanged()); + + // Overflow, malformed, empty, and truncated streams fail and preserve flags. + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, + "99999999999999999999999999")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1, + "99999999999999999999999999")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, n - 1, "abc")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, 1)), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, n - 1)), + FailsLeavingUnchanged()); +} + // ------------------------------------------------------------------ // Stability tests for pcg64_2018_engine // ------------------------------------------------------------------
diff --git a/absl/random/internal/randen_engine.h b/absl/random/internal/randen_engine.h index 91a6025..0f51462 100644 --- a/absl/random/internal/randen_engine.h +++ b/absl/random/internal/randen_engine.h
@@ -20,6 +20,7 @@ #include <cstdint> #include <cstdlib> #include <cstring> +#include <ios> #include <istream> #include <iterator> #include <limits> @@ -222,19 +223,21 @@ friend std::basic_istream<CharT, Traits>& operator>>( std::basic_istream<CharT, Traits>& is, // NOLINT(runtime/references) randen_engine<T>& engine) { // NOLINT(runtime/references) - using numeric_type = - typename random_internal::stream_format_type<result_type>::type; + auto saver = random_internal::make_istream_state_saver(is); result_type state[kStateSizeT]; - size_t next; for (auto& elem : state) { - // It is not possible to read uint8_t from wide streams, so it is - // necessary to read a wider type and then cast it to uint8_t. - numeric_type value; - is >> value; - elem = little_endian::ToHost(static_cast<result_type>(value)); + result_type value = 0; + if (!random_internal::read_integral(is, value)) { + return is; + } + elem = little_endian::ToHost(value); } - is >> next; - if (is.fail()) { + size_t next = 0; + if (!random_internal::read_integral(is, next)) { + return is; + } + if (next < kCapacityT || next > kStateSizeT) { + is.setstate(std::ios_base::failbit); return is; } std::memcpy(engine.state(), state, sizeof(state));
diff --git a/absl/random/internal/randen_engine_test.cc b/absl/random/internal/randen_engine_test.cc index 73afaf3..3f58184 100644 --- a/absl/random/internal/randen_engine_test.cc +++ b/absl/random/internal/randen_engine_test.cc
@@ -19,11 +19,16 @@ #include <cmath> #include <cstddef> #include <cstdint> +#include <ios> +#include <ostream> #include <random> #include <sstream> +#include <string> #include <type_traits> #include <utility> +#include <vector> +#include "gmock/gmock.h" #include "gtest/gtest.h" #include "absl/log/log.h" #include "absl/random/internal/explicit_seed_seq.h" @@ -293,6 +298,165 @@ } } +template <typename Engine> +std::vector<std::string> SerializeTokens(const Engine& engine) { + std::ostringstream oss; + oss << engine; + std::istringstream iss(oss.str()); + std::vector<std::string> tokens; + std::string token; + while (iss >> token) { + tokens.push_back(token); + } + return tokens; +} + +std::string JoinTokens(const std::vector<std::string>& tokens) { + std::ostringstream oss; + for (size_t i = 0; i < tokens.size(); ++i) { + if (i > 0) oss << ' '; + oss << tokens[i]; + } + return oss.str(); +} + +std::string ReplaceToken(std::vector<std::string> tokens, size_t index, + const std::string& value) { + tokens[index] = value; + return JoinTokens(tokens); +} + +std::string TruncateTokens(std::vector<std::string> tokens, size_t count) { + tokens.resize(count); + return JoinTokens(tokens); +} + +template <typename Engine> +struct EngineParseResult { + bool failed = false; + bool flags_preserved = false; + Engine value; + Engine initial; +}; + +template <typename Engine> +void PrintTo(const EngineParseResult<Engine>& r, std::ostream* os) { + *os << "{failed=" << (r.failed ? "true" : "false") + << ", flags_preserved=" << (r.flags_preserved ? "true" : "false") + << ", unchanged=" << (r.value == r.initial ? "true" : "false") << "}"; +} + +template <typename Engine> +EngineParseResult<Engine> ParseEngine(const Engine& initial, + const std::string& input) { + const std::ios_base::fmtflags kInitFlags = + std::ios_base::hex | std::ios_base::showbase | std::ios_base::skipws; + Engine target = initial; + std::istringstream iss(input); + iss.flags(kInitFlags); + iss >> target; + return {iss.fail(), iss.flags() == kInitFlags, target, initial}; +} + +MATCHER(FailsLeavingUnchanged, + "fails extraction while preserving engine state and stream flags") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER(ParsesSuccessfully, "succeeds and preserves stream flags") { + return !arg.failed && arg.flags_preserved; +} + +MATCHER_P(ParsesEqualToPtr, expected, + "succeeds, restores expected engine state, and preserves flags") { + return !arg.failed && arg.flags_preserved && arg.value == *expected; +} + +template <typename Engine> +auto ParsesEqualTo(const Engine& expected) { + return ParsesEqualToPtr(&expected); +} + +TYPED_TEST(RandenEngineTypedTest, StreamDeserializationValidation) { + using randen = absl::random_internal::randen_engine<TypeParam>; + constexpr size_t kStateSizeT = 256 / sizeof(TypeParam); + constexpr size_t kCapacityT = 16 / sizeof(TypeParam); + + randen expected(static_cast<TypeParam>(123u)); + expected.discard(5); + const randen initial(static_cast<TypeParam>(99u)); + ASSERT_FALSE(initial == expected); + + const std::vector<std::string> tokens = SerializeTokens(expected); + ASSERT_EQ(tokens.size(), kStateSizeT + 1); + const std::string valid_stream = JoinTokens(tokens); + + // Valid round-trip must succeed in decimal and restore caller stream flags. + EXPECT_THAT(ParseEngine(initial, valid_stream), ParsesEqualTo(expected)); + + // Boundary next values kCapacityT and kStateSizeT are valid. + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, + std::to_string(kCapacityT))), + ParsesSuccessfully()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, + std::to_string(kStateSizeT))), + ParsesSuccessfully()); + + // Reject next outside [kCapacityT, kStateSizeT], negative, or overflowing. + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "0")), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, + std::to_string(kCapacityT - 1))), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, + std::to_string(kStateSizeT + 1))), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "1000")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, "-0")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT, + "99999999999999999999999999")), + FailsLeavingUnchanged()); + + // Reject negative or overflowing state words. + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "-0")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, kStateSizeT - 1, "-1")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, + "99999999999999999999999999")), + FailsLeavingUnchanged()); + + // Reject empty and truncated streams. + EXPECT_THAT(ParseEngine(initial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, 1)), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, TruncateTokens(tokens, kStateSizeT)), + FailsLeavingUnchanged()); +} + +TEST(RandenTest, StreamRejectsInvalidParameters) { + using randen_u8 = absl::random_internal::randen_engine<uint8_t>; + const randen_u8 expected(7u); + const randen_u8 initial(13u); + const std::vector<std::string> tokens = SerializeTokens(expected); + ASSERT_EQ(tokens.size(), 257u); + + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "256")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 0, "300")), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseEngine(initial, ReplaceToken(tokens, 255, "256")), + FailsLeavingUnchanged()); +} + TEST(RandenTest, VerifyGoldenRanden64Default) { constexpr uint64_t kGolden[kNumGoldenOutputs] = { 0xc3c14f134e433977, 0xdda9f47cd90410ee, 0x887bf3087fd8ca10,
diff --git a/absl/random/log_uniform_int_distribution.h b/absl/random/log_uniform_int_distribution.h index 99abe05..8bcb60e 100644 --- a/absl/random/log_uniform_int_distribution.h +++ b/absl/random/log_uniform_int_distribution.h
@@ -234,26 +234,22 @@ using param_type = typename log_uniform_int_distribution<IntType>::param_type; using result_type = typename log_uniform_int_distribution<IntType>::result_type; - using stream_type = - typename random_internal::stream_format_type<IntType>::type; - - stream_type min; - stream_type max; - stream_type base; auto saver = random_internal::make_istream_state_saver(is); - is >> min >> max >> base; - if (!is.fail()) { - const result_type min_val = static_cast<result_type>(min); - const result_type max_val = static_cast<result_type>(max); - const result_type base_val = static_cast<result_type>(base); - if (max_val < min_val || base_val <= 1) { - // The input violates the param_type preconditions; signal failure by - // setting the failbit instead of constructing an invalid param_type. - is.setstate(is.rdstate() | std::ios_base::failbit); - } else { - x.param(param_type(min_val, max_val, base_val)); - } + result_type min_val = 0; + result_type max_val = 0; + result_type base_val = 0; + if (!random_internal::read_integral(is, min_val) || + !random_internal::read_integral(is, max_val) || + !random_internal::read_integral(is, base_val)) { + return is; + } + if (max_val < min_val || base_val <= 1) { + // The input violates the param_type preconditions; signal failure by + // setting the failbit instead of constructing an invalid param_type. + is.setstate(std::ios_base::failbit); + } else { + x.param(param_type(min_val, max_val, base_val)); } return is; }
diff --git a/absl/random/log_uniform_int_distribution_test.cc b/absl/random/log_uniform_int_distribution_test.cc index 4404111..403aaea 100644 --- a/absl/random/log_uniform_int_distribution_test.cc +++ b/absl/random/log_uniform_int_distribution_test.cc
@@ -298,4 +298,123 @@ } } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(LogUniformIntDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::log_uniform_int_distribution<int8_t> kI8Initial(3, 6, 17); + const absl::log_uniform_int_distribution<uint8_t> kU8Initial(3, 6, 17); + + EXPECT_THAT( + ParseFromStream(kI8Initial, "-128 127 2"), + ParsesEqualTo(absl::log_uniform_int_distribution<int8_t>(-128, 127, 2))); + EXPECT_THAT( + ParseFromStream(kU8Initial, "0 255 2"), + ParsesEqualTo(absl::log_uniform_int_distribution<uint8_t>(0, 255, 2))); + + EXPECT_THAT(ParseFromStream(kI8Initial, "-254 10 2"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "-129 10 2"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "0 128 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "0 10 128"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "0 10 258"), FailsLeavingUnchanged()); + + EXPECT_THAT(ParseFromStream(kU8Initial, "0 256 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "0 300 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "0 10 256"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "0 10 258"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "-5 10 2"), FailsLeavingUnchanged()); +} + +template <typename IntType> +class LogUniformIntDistributionUnsignedTypeTest : public ::testing::Test {}; + +using UnsignedIntTypes = + ::testing::Types<uint8_t, uint16_t, uint32_t, uint64_t>; +TYPED_TEST_SUITE(LogUniformIntDistributionUnsignedTypeTest, UnsignedIntTypes); + +TYPED_TEST(LogUniformIntDistributionUnsignedTypeTest, + StreamDeserializationValidation) { + using absl::random_internal::ParseFromStream; + using Dist = absl::log_uniform_int_distribution<TypeParam>; + const Dist kInitial(3, 6, 17); + + EXPECT_THAT(ParseFromStream(kInitial, "0 10 2"), + ParsesEqualTo(Dist(0, 10, 2))); + EXPECT_THAT(ParseFromStream(kInitial, " 0 10 2"), + ParsesEqualTo(Dist(0, 10, 2))); + EXPECT_THAT(ParseFromStream(kInitial, "+0 +10 +2"), + ParsesEqualTo(Dist(0, 10, 2))); + EXPECT_THAT(ParseFromStream(kInitial, " +5 +20 +3"), + ParsesEqualTo(Dist(5, 20, 3))); + EXPECT_THAT(ParseFromStream(kInitial, L" 0 10 2"), + ParsesEqualTo(Dist(0, 10, 2))); + + EXPECT_THAT(ParseFromStream(kInitial, "0 100 1"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 100 0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "100 0 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-5 10 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-5 -1 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 -5 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 -1 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 10 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-0 10 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 -0 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, " -5 10 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "\t\n-5 10 2"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 -5 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 10 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, L"-5 10 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, L" 0 -5 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, L"0 10 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, " "), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 10"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 10 "), FailsLeavingUnchanged()); +} + +template <typename IntType> +class LogUniformIntDistributionSignedTypeTest : public ::testing::Test {}; + +using SignedIntTypes = ::testing::Types<int8_t, int16_t, int32_t, int64_t>; +TYPED_TEST_SUITE(LogUniformIntDistributionSignedTypeTest, SignedIntTypes); + +TYPED_TEST(LogUniformIntDistributionSignedTypeTest, + StreamDeserializationValidation) { + using absl::random_internal::ParseFromStream; + using Dist = absl::log_uniform_int_distribution<TypeParam>; + const Dist kInitial(3, 6, 17); + + EXPECT_THAT(ParseFromStream(kInitial, "-10 -2 2"), + ParsesEqualTo(Dist(-10, -2, 2))); + EXPECT_THAT(ParseFromStream(kInitial, " -10 -2 2"), + ParsesEqualTo(Dist(-10, -2, 2))); + EXPECT_THAT(ParseFromStream(kInitial, "-10 10 3"), + ParsesEqualTo(Dist(-10, 10, 3))); + EXPECT_THAT(ParseFromStream(kInitial, L"-10 -2 2"), + ParsesEqualTo(Dist(-10, -2, 2))); + + EXPECT_THAT(ParseFromStream(kInitial, "0 100 1"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 100 0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "100 0 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-2 -10 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-10 -2 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-10 -2 1"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0 10"), FailsLeavingUnchanged()); +} + } // namespace
diff --git a/absl/random/poisson_distribution.h b/absl/random/poisson_distribution.h index ae2e095..16ab7ab 100644 --- a/absl/random/poisson_distribution.h +++ b/absl/random/poisson_distribution.h
@@ -18,6 +18,7 @@ #include <cassert> #include <cmath> #include <cstdint> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -31,6 +32,12 @@ namespace absl { ABSL_NAMESPACE_BEGIN +namespace random_internal { + +// Maximum supported mean for absl::poisson_distribution::param_type. +inline constexpr double kPoissonMaxMean = 1e10; + +} // namespace random_internal // absl::poisson_distribution: // Generates discrete variates conforming to a Poisson distribution. @@ -140,7 +147,7 @@ // As a defensive measure, avoid large values of the mean. The rejection // algorithm used does not support very large values well. It my be worth // changing algorithms to better deal with these cases. - assert(mean <= 1e10); + assert(mean <= random_internal::kPoissonMaxMean); if (mean_ < 10) { // For small lambda, use the knuth method. split_ = 1; @@ -247,11 +254,19 @@ std::basic_istream<CharT, Traits>& is, // NOLINT(runtime/references) poisson_distribution<IntType>& x) { // NOLINT(runtime/references) using param_type = typename poisson_distribution<IntType>::param_type; + using result_type = typename poisson_distribution<IntType>::result_type; auto saver = random_internal::make_istream_state_saver(is); - double mean = random_internal::read_floating_point<double>(is); + const double mean = random_internal::read_floating_point<double>(is); if (!is.fail()) { - x.param(param_type(mean)); + constexpr double kMaxMean = + static_cast<double>((std::numeric_limits<result_type>::max)()); + if (mean >= 0.0 && mean <= kMaxMean && + mean <= random_internal::kPoissonMaxMean) { + x.param(param_type(mean)); + } else { + is.setstate(std::ios_base::failbit); + } } return is; }
diff --git a/absl/random/poisson_distribution_test.cc b/absl/random/poisson_distribution_test.cc index e8ee364..4bdcf72 100644 --- a/absl/random/poisson_distribution_test.cc +++ b/absl/random/poisson_distribution_test.cc
@@ -568,4 +568,59 @@ EXPECT_EQ(121, dist(urbg)); } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(PoissonDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::poisson_distribution<int32_t> kInitial(4.5); + const absl::poisson_distribution<int8_t> kI8Initial(4.5); + const absl::poisson_distribution<uint8_t> kU8Initial(4.5); + const absl::poisson_distribution<int64_t> kI64Initial(4.5); + + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "abc"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "nan"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1e20"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1e400"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0"), + ParsesEqualTo(absl::poisson_distribution<int32_t>(0.0))); + EXPECT_THAT(ParseFromStream(kInitial, "1e-320"), + ParsesEqualTo(absl::poisson_distribution<int32_t>(1e-320))); + + EXPECT_THAT(ParseFromStream(kI8Initial, "128.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "200.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "127.0"), + ParsesEqualTo(absl::poisson_distribution<int8_t>(127.0))); + + EXPECT_THAT(ParseFromStream(kU8Initial, "256.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "300.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "255.0"), + ParsesEqualTo(absl::poisson_distribution<uint8_t>(255.0))); + + constexpr double kMaxMean = absl::random_internal::kPoissonMaxMean; + EXPECT_THAT(ParseFromStream(kI64Initial, absl::StrCat(kMaxMean)), + ParsesEqualTo(absl::poisson_distribution<int64_t>(kMaxMean))); + EXPECT_THAT(ParseFromStream(kI64Initial, absl::StrCat(kMaxMean * 10.0)), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI64Initial, "1e20"), FailsLeavingUnchanged()); +} + } // namespace
diff --git a/absl/random/uniform_int_distribution.h b/absl/random/uniform_int_distribution.h index 0dc7c62..f5c884f 100644 --- a/absl/random/uniform_int_distribution.h +++ b/absl/random/uniform_int_distribution.h
@@ -29,6 +29,7 @@ #define ABSL_RANDOM_UNIFORM_INT_DISTRIBUTION_H_ #include <cassert> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -176,17 +177,18 @@ uniform_int_distribution<IntType>& x) { using param_type = typename uniform_int_distribution<IntType>::param_type; using result_type = typename uniform_int_distribution<IntType>::result_type; - using stream_type = - typename random_internal::stream_format_type<IntType>::type; - - stream_type a; - stream_type b; auto saver = random_internal::make_istream_state_saver(is); - is >> a >> b; - if (!is.fail()) { - x.param( - param_type(static_cast<result_type>(a), static_cast<result_type>(b))); + result_type a = 0; + result_type b = 0; + if (!random_internal::read_integral(is, a) || + !random_internal::read_integral(is, b)) { + return is; + } + if (a <= b) { + x.param(param_type(a, b)); + } else { + is.setstate(std::ios_base::failbit); } return is; }
diff --git a/absl/random/uniform_int_distribution_test.cc b/absl/random/uniform_int_distribution_test.cc index b055833..4150c64 100644 --- a/absl/random/uniform_int_distribution_test.cc +++ b/absl/random/uniform_int_distribution_test.cc
@@ -258,4 +258,56 @@ 3813, 9195, 6641, 2986, 7956, 3765)); } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(UniformIntDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::uniform_int_distribution<int> kIntInitial(1, 5); + const absl::uniform_int_distribution<int8_t> kI8Initial(1, 5); + const absl::uniform_int_distribution<uint8_t> kU8Initial(1, 5); + const absl::uniform_int_distribution<uint16_t> kU16Initial(1, 5); + const absl::uniform_int_distribution<uint32_t> kU32Initial(1, 5); + const absl::uniform_int_distribution<uint64_t> kU64Initial(1, 5); + + EXPECT_THAT(ParseFromStream(kIntInitial, "10 2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntInitial, "1"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntInitial, "abc 5"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntInitial, "1 abc"), FailsLeavingUnchanged()); + + EXPECT_THAT(ParseFromStream(kI8Initial, "-254 10"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "10 200"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "-129 0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "0 128"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Initial, "-128 127"), + ParsesEqualTo(absl::uniform_int_distribution<int8_t>(-128, 127))); + + EXPECT_THAT(ParseFromStream(kU8Initial, "300 310"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "10 300"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "-1 5"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "-0 5"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Initial, "0 255"), + ParsesEqualTo(absl::uniform_int_distribution<uint8_t>(0, 255))); + + EXPECT_THAT(ParseFromStream(kU16Initial, "-10 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Initial, "-10 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Initial, "-1 5"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Initial, "1 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Initial, "-0 5"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU64Initial, "-10 -2"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU64Initial, "0 99999999999999999999999"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Initial, "10 20"), + ParsesEqualTo(absl::uniform_int_distribution<uint32_t>(10, 20))); +} + } // namespace
diff --git a/absl/random/uniform_real_distribution.h b/absl/random/uniform_real_distribution.h index 79cf793..9ffb9c3 100644 --- a/absl/random/uniform_real_distribution.h +++ b/absl/random/uniform_real_distribution.h
@@ -35,6 +35,7 @@ #include <cassert> #include <cmath> #include <cstdint> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -194,7 +195,13 @@ if (is.fail()) return is; auto b = random_internal::read_floating_point<result_type>(is); if (!is.fail()) { - x.param(param_type(a, b)); + if (std::isfinite(a) && std::isfinite(b) && a <= b && + static_cast<result_type>(b - a) <= + (std::numeric_limits<result_type>::max)()) { + x.param(param_type(a, b)); + } else { + is.setstate(std::ios_base::failbit); + } } return is; }
diff --git a/absl/random/uniform_real_distribution_test.cc b/absl/random/uniform_real_distribution_test.cc index 11e1d65..f42d1a5 100644 --- a/absl/random/uniform_real_distribution_test.cc +++ b/absl/random/uniform_real_distribution_test.cc
@@ -393,4 +393,79 @@ } } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(UniformRealDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::uniform_real_distribution<double> kInitial(1.0, 2.0); + const absl::uniform_real_distribution<float> kFloatInitial(1.0f, 2.0f); + + // Valid streams including degenerate [a, a] and subnormal bounds. + EXPECT_THAT(ParseFromStream(kInitial, "0.0 1.0"), + ParsesEqualTo(absl::uniform_real_distribution<double>(0.0, 1.0))); + EXPECT_THAT(ParseFromStream(kInitial, "1.5 1.5"), + ParsesEqualTo(absl::uniform_real_distribution<double>(1.5, 1.5))); + EXPECT_THAT( + ParseFromStream(kInitial, "-1.0 1e-320"), + ParsesEqualTo(absl::uniform_real_distribution<double>(-1.0, 1e-320))); + + // Truncated, inverted, overflowing-span, and non-finite inputs. + EXPECT_THAT(ParseFromStream(kInitial, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "10.0 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "nan 1.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0 nan"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "0.0 inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf 0.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "inf inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-inf -inf"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kInitial, "-1e308 1e308"), + FailsLeavingUnchanged()); + + // Non-finite values delivered with goodbit by a custom num_get facet. + EXPECT_THAT( + ParseFromStream(kInitial, "nan 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "0.0 nan", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "0.0 inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "-inf 0.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "inf inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kInitial, "-inf -inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "nan 1.0", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT( + ParseFromStream(kFloatInitial, "0.0 inf", /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + + // A boundary interval whose IEEE-754 double difference rounds to DBL_MAX + // (b - a == DBL_MAX in double, though larger under x87 80-bit excess + // precision) round-trips cleanly without false rejection. + const double a = -std::ldexp(1.0, 969); + const double b = (std::numeric_limits<double>::max)(); + const absl::uniform_real_distribution<double> kMaxSpan(a, b); + std::ostringstream oss; + oss << kMaxSpan; + EXPECT_THAT(ParseFromStream(kInitial, oss.str()), ParsesEqualTo(kMaxSpan)); +} + } // namespace
diff --git a/absl/random/zipf_distribution.h b/absl/random/zipf_distribution.h index 21e3b70..50d9410 100644 --- a/absl/random/zipf_distribution.h +++ b/absl/random/zipf_distribution.h
@@ -17,6 +17,7 @@ #include <cassert> #include <cmath> +#include <ios> #include <istream> #include <limits> #include <ostream> @@ -253,16 +254,27 @@ zipf_distribution<IntType>& x) { // NOLINT(runtime/references) using result_type = typename zipf_distribution<IntType>::result_type; using param_type = typename zipf_distribution<IntType>::param_type; - using stream_type = - typename random_internal::stream_format_type<IntType>::type; - stream_type k; - double q; - double v; auto saver = random_internal::make_istream_state_saver(is); - is >> k >> q >> v; - if (!is.fail()) { - x.param(param_type(static_cast<result_type>(k), q, v)); + result_type k = 0; + if (!random_internal::read_integral(is, k)) { + return is; + } + const double q = random_internal::read_floating_point<double>(is); + if (is.fail()) return is; + const double v = random_internal::read_floating_point<double>(is); + if (is.fail()) return is; + + if constexpr (std::numeric_limits<result_type>::is_signed) { + if (k < result_type{0}) { + is.setstate(std::ios_base::failbit); + return is; + } + } + if (std::isfinite(q) && q > 1.0 && std::isfinite(v) && v > 0.0) { + x.param(param_type(k, q, v)); + } else { + is.setstate(std::ios_base::failbit); } return is; }
diff --git a/absl/random/zipf_distribution_test.cc b/absl/random/zipf_distribution_test.cc index f29aca5..fcdf110 100644 --- a/absl/random/zipf_distribution_test.cc +++ b/absl/random/zipf_distribution_test.cc
@@ -31,6 +31,7 @@ #include "gtest/gtest.h" #include "absl/log/log.h" #include "absl/random/internal/chi_square.h" +#include "absl/random/internal/distribution_test_util.h" #include "absl/random/internal/pcg_engine.h" #include "absl/random/internal/sequence_urbg.h" #include "absl/random/random.h" @@ -424,4 +425,108 @@ } } +MATCHER(FailsLeavingUnchanged, + "fails stream extraction and leaves target and stream flags " + "unchanged") { + return arg.failed && arg.flags_preserved && arg.value == arg.initial; +} + +MATCHER_P(ParsesEqualTo, expected, + "succeeds, updates target, and preserves stream flags") { + return !arg.failed && arg.flags_preserved && arg.value == expected; +} + +TEST(ZipfDistributionTest, StreamRejectsInvalidParameters) { + using absl::random_internal::ParseFromStream; + const absl::zipf_distribution<int> kIntSentinel(42, 3.0, 2.0); + const absl::zipf_distribution<int8_t> kI8Sentinel(42, 3.0, 2.0); + const absl::zipf_distribution<uint8_t> kU8Sentinel(42, 3.0, 2.0); + const absl::zipf_distribution<uint32_t> kU32Sentinel(42, 3.0, 2.0); + + // Valid boundary values for 8-bit integer types and subnormal v. + EXPECT_THAT(ParseFromStream(kI8Sentinel, "0 2.0 1.0"), + ParsesEqualTo(absl::zipf_distribution<int8_t>(0, 2.0, 1.0))); + EXPECT_THAT(ParseFromStream(kI8Sentinel, "127 2.0 1.0"), + ParsesEqualTo(absl::zipf_distribution<int8_t>(127, 2.0, 1.0))); + EXPECT_THAT(ParseFromStream(kU8Sentinel, "255 2.0 1.0"), + ParsesEqualTo(absl::zipf_distribution<uint8_t>(255, 2.0, 1.0))); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.5 1e-320"), + ParsesEqualTo(absl::zipf_distribution<int>(10, 2.5, 1e-320))); + + // Out-of-range, negative, or overflowing k. + EXPECT_THAT(ParseFromStream(kIntSentinel, "-5 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Sentinel, "-5 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Sentinel, "-5 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Sentinel, "-5 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Sentinel, "-0 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Sentinel, "-0 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Sentinel, "128 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kI8Sentinel, "300 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU8Sentinel, "300 2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kU32Sentinel, "5000000000 2.0 1.0"), + FailsLeavingUnchanged()); + + // Invalid q (must be finite and > 1.0). + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 1.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 0.5 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 -2.0 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 nan 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 inf 1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 -inf 1.0"), + FailsLeavingUnchanged()); + + // Invalid v (must be finite and > 0.0). + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 0.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 -1.0"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 nan"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 inf"), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 -inf"), + FailsLeavingUnchanged()); + + // Non-finite q and v delivered with goodbit by a custom num_get facet. + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 nan 1.0", + /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 inf 1.0", + /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 -inf 1.0", + /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 nan", + /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 inf", + /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0 -inf", + /*use_non_finite_facet=*/true), + FailsLeavingUnchanged()); + + // Truncated and malformed streams. + EXPECT_THAT(ParseFromStream(kIntSentinel, ""), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "10 2.0"), FailsLeavingUnchanged()); + EXPECT_THAT(ParseFromStream(kIntSentinel, "abc 2.0 1.0"), + FailsLeavingUnchanged()); +} + } // namespace