| // Copyright 2017 The Abseil Authors. |
| // |
| // Licensed under the Apache License, Version 2.0 (the "License"); |
| // you may not use this file except in compliance with the License. |
| // You may obtain a copy of the License at |
| // |
| // https://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "absl/random/internal/iostream_state_saver.h" |
| |
| #include <sstream> |
| #include <string> |
| |
| #include "gtest/gtest.h" |
| |
| namespace { |
| |
| using absl::random_internal::make_istream_state_saver; |
| using absl::random_internal::make_ostream_state_saver; |
| using absl::random_internal::stream_precision_helper; |
| |
| template <typename T> |
| typename absl::enable_if_t<std::is_integral<T>::value, T> // |
| StreamRoundTrip(T t) { |
| std::stringstream ss; |
| { |
| auto saver = make_ostream_state_saver(ss); |
| ss.precision(stream_precision_helper<T>::kPrecision); |
| ss << t; |
| } |
| T result = 0; |
| { |
| auto saver = make_istream_state_saver(ss); |
| ss >> result; |
| } |
| EXPECT_FALSE(ss.fail()) // |
| << ss.str() << " " // |
| << (ss.good() ? "good " : "") // |
| << (ss.bad() ? "bad " : "") // |
| << (ss.eof() ? "eof " : "") // |
| << (ss.fail() ? "fail " : ""); |
| |
| return result; |
| } |
| |
| template <typename T> |
| typename absl::enable_if_t<std::is_floating_point<T>::value, T> // |
| StreamRoundTrip(T t) { |
| std::stringstream ss; |
| { |
| auto saver = make_ostream_state_saver(ss); |
| ss.precision(stream_precision_helper<T>::kPrecision); |
| ss << t; |
| } |
| T result = 0; |
| { |
| auto saver = make_istream_state_saver(ss); |
| result = absl::random_internal::read_floating_point<T>(ss); |
| } |
| EXPECT_FALSE(ss.fail()) // |
| << ss.str() << " " // |
| << (ss.good() ? "good " : "") // |
| << (ss.bad() ? "bad " : "") // |
| << (ss.eof() ? "eof " : "") // |
| << (ss.fail() ? "fail " : ""); |
| |
| return result; |
| } |
| |
| TEST(IOStreamStateSaver, BasicSaverState) { |
| std::stringstream ss; |
| ss.precision(2); |
| ss.fill('x'); |
| ss.flags(std::ios_base::dec | std::ios_base::right); |
| |
| { |
| auto saver = make_ostream_state_saver(ss); |
| ss.precision(10); |
| EXPECT_NE('x', ss.fill()); |
| EXPECT_EQ(10, ss.precision()); |
| EXPECT_NE(std::ios_base::dec | std::ios_base::right, ss.flags()); |
| |
| ss << 1.23; |
| } |
| |
| EXPECT_EQ('x', ss.fill()); |
| EXPECT_EQ(2, ss.precision()); |
| EXPECT_EQ(std::ios_base::dec | std::ios_base::right, ss.flags()); |
| } |
| |
| TEST(IOStreamStateSaver, RoundTripInts) { |
| const uint64_t kUintValues[] = { |
| 0, |
| 1, |
| static_cast<uint64_t>(-1), |
| 2, |
| static_cast<uint64_t>(-2), |
| |
| 1 << 7, |
| 1 << 8, |
| 1 << 16, |
| 1ull << 32, |
| 1ull << 50, |
| 1ull << 62, |
| 1ull << 63, |
| |
| (1 << 7) - 1, |
| (1 << 8) - 1, |
| (1 << 16) - 1, |
| (1ull << 32) - 1, |
| (1ull << 50) - 1, |
| (1ull << 62) - 1, |
| (1ull << 63) - 1, |
| |
| static_cast<uint64_t>(-(1 << 8)), |
| static_cast<uint64_t>(-(1 << 16)), |
| static_cast<uint64_t>(-(1ll << 32)), |
| static_cast<uint64_t>(-(1ll << 50)), |
| static_cast<uint64_t>(-(1ll << 62)), |
| |
| static_cast<uint64_t>(-(1 << 8) - 1), |
| static_cast<uint64_t>(-(1 << 16) - 1), |
| static_cast<uint64_t>(-(1ll << 32) - 1), |
| static_cast<uint64_t>(-(1ll << 50) - 1), |
| static_cast<uint64_t>(-(1ll << 62) - 1), |
| }; |
| |
| for (const uint64_t u : kUintValues) { |
| EXPECT_EQ(u, StreamRoundTrip<uint64_t>(u)); |
| |
| int64_t x = static_cast<int64_t>(u); |
| EXPECT_EQ(x, StreamRoundTrip<int64_t>(x)); |
| |
| double d = static_cast<double>(x); |
| EXPECT_EQ(d, StreamRoundTrip<double>(d)); |
| |
| float f = d; |
| EXPECT_EQ(f, StreamRoundTrip<float>(f)); |
| } |
| } |
| |
| TEST(IOStreamStateSaver, RoundTripFloats) { |
| static_assert( |
| stream_precision_helper<float>::kPrecision >= 9, |
| "stream_precision_helper<float>::kPrecision should be at least 9"); |
| |
| const float kValues[] = { |
| 1, |
| std::nextafter(1.0f, 0.0f), // 1 - epsilon |
| std::nextafter(1.0f, 2.0f), // 1 + epsilon |
| |
| 1.0e+1f, |
| 1.0e-1f, |
| 1.0e+2f, |
| 1.0e-2f, |
| 1.0e+10f, |
| 1.0e-10f, |
| |
| 0.00000051110000111311111111f, |
| -0.00000051110000111211111111f, |
| |
| 1.234678912345678912345e+6f, |
| 1.234678912345678912345e-6f, |
| 1.234678912345678912345e+30f, |
| 1.234678912345678912345e-30f, |
| 1.234678912345678912345e+38f, |
| 1.0234678912345678912345e-38f, |
| |
| // Boundary cases. |
| std::numeric_limits<float>::max(), |
| std::numeric_limits<float>::lowest(), |
| std::numeric_limits<float>::epsilon(), |
| std::nextafter(std::numeric_limits<float>::min(), |
| 1.0f), // min + epsilon |
| std::numeric_limits<float>::min(), // smallest normal |
| // There are some errors dealing with denorms on apple platforms. |
| std::numeric_limits<float>::denorm_min(), // smallest denorm |
| std::numeric_limits<float>::min() / 2, |
| std::nextafter(std::numeric_limits<float>::min(), |
| 0.0f), // denorm_max |
| std::nextafter(std::numeric_limits<float>::denorm_min(), 1.0f), |
| }; |
| |
| for (const float f : kValues) { |
| EXPECT_EQ(f, StreamRoundTrip<float>(f)); |
| EXPECT_EQ(-f, StreamRoundTrip<float>(-f)); |
| |
| double d = f; |
| EXPECT_EQ(d, StreamRoundTrip<double>(d)); |
| EXPECT_EQ(-d, StreamRoundTrip<double>(-d)); |
| |
| // Avoid undefined behavior (overflow/underflow). |
| if (d <= std::numeric_limits<int64_t>::max() && |
| d >= std::numeric_limits<int64_t>::lowest()) { |
| int64_t x = static_cast<int64_t>(f); |
| EXPECT_EQ(x, StreamRoundTrip<int64_t>(x)); |
| } |
| } |
| } |
| |
| TEST(IOStreamStateSaver, RoundTripDoubles) { |
| static_assert( |
| stream_precision_helper<double>::kPrecision >= 17, |
| "stream_precision_helper<double>::kPrecision should be at least 17"); |
| |
| const double kValues[] = { |
| 1, |
| std::nextafter(1.0, 0.0), // 1 - epsilon |
| std::nextafter(1.0, 2.0), // 1 + epsilon |
| |
| 1.0e+1, |
| 1.0e-1, |
| 1.0e+2, |
| 1.0e-2, |
| 1.0e+10, |
| 1.0e-10, |
| |
| 0.00000051110000111311111111, |
| -0.00000051110000111211111111, |
| |
| 1.234678912345678912345e+6, |
| 1.234678912345678912345e-6, |
| 1.234678912345678912345e+30, |
| 1.234678912345678912345e-30, |
| 1.234678912345678912345e+38, |
| 1.0234678912345678912345e-38, |
| |
| 1.0e+100, |
| 1.0e-100, |
| 1.234678912345678912345e+308, |
| 1.0234678912345678912345e-308, |
| 2.22507385850720138e-308, |
| |
| // Boundary cases. |
| std::numeric_limits<double>::max(), |
| std::numeric_limits<double>::lowest(), |
| std::numeric_limits<double>::epsilon(), |
| std::nextafter(std::numeric_limits<double>::min(), |
| 1.0), // min + epsilon |
| std::numeric_limits<double>::min(), // smallest normal |
| // There are some errors dealing with denorms on apple platforms. |
| std::numeric_limits<double>::denorm_min(), // smallest denorm |
| std::numeric_limits<double>::min() / 2, |
| std::nextafter(std::numeric_limits<double>::min(), |
| 0.0), // denorm_max |
| std::nextafter(std::numeric_limits<double>::denorm_min(), 1.0f), |
| }; |
| |
| for (const double d : kValues) { |
| EXPECT_EQ(d, StreamRoundTrip<double>(d)); |
| EXPECT_EQ(-d, StreamRoundTrip<double>(-d)); |
| |
| // Avoid undefined behavior (overflow/underflow). |
| if (d <= std::numeric_limits<float>::max() && |
| d >= std::numeric_limits<float>::lowest()) { |
| float f = static_cast<float>(d); |
| EXPECT_EQ(f, StreamRoundTrip<float>(f)); |
| } |
| |
| // Avoid undefined behavior (overflow/underflow). |
| if (d <= std::numeric_limits<int64_t>::max() && |
| d >= std::numeric_limits<int64_t>::lowest()) { |
| int64_t x = static_cast<int64_t>(d); |
| EXPECT_EQ(x, StreamRoundTrip<int64_t>(x)); |
| } |
| } |
| } |
| |
| TEST(IOStreamStateSaver, RoundTripLongDoubles) { |
| // Technically, C++ only guarantees that long double is at least as large as a |
| // double. Practically it varies from 64-bits to 128-bits. |
| // |
| // So it is best to consider long double a best-effort extended precision |
| // type. |
| |
| static_assert( |
| stream_precision_helper<long double>::kPrecision >= 36, |
| "stream_precision_helper<long double>::kPrecision should be at least 36"); |
| |
| using real_type = long double; |
| const real_type kValues[] = { |
| 1, |
| std::nextafter(1.0, 0.0), // 1 - epsilon |
| std::nextafter(1.0, 2.0), // 1 + epsilon |
| |
| 1.0e+1, |
| 1.0e-1, |
| 1.0e+2, |
| 1.0e-2, |
| 1.0e+10, |
| 1.0e-10, |
| |
| 0.00000051110000111311111111, |
| -0.00000051110000111211111111, |
| |
| 1.2346789123456789123456789123456789e+6, |
| 1.2346789123456789123456789123456789e-6, |
| 1.2346789123456789123456789123456789e+30, |
| 1.2346789123456789123456789123456789e-30, |
| 1.2346789123456789123456789123456789e+38, |
| 1.2346789123456789123456789123456789e-38, |
| 1.2346789123456789123456789123456789e+308, |
| 1.2346789123456789123456789123456789e-308, |
| |
| 1.0e+100, |
| 1.0e-100, |
| 1.234678912345678912345e+308, |
| 1.0234678912345678912345e-308, |
| |
| // Boundary cases. |
| std::numeric_limits<real_type>::max(), |
| std::numeric_limits<real_type>::lowest(), |
| std::numeric_limits<real_type>::epsilon(), |
| std::nextafter(std::numeric_limits<real_type>::min(), |
| real_type(1)), // min + epsilon |
| std::numeric_limits<real_type>::min(), // smallest normal |
| // There are some errors dealing with denorms on apple platforms. |
| std::numeric_limits<real_type>::denorm_min(), // smallest denorm |
| std::numeric_limits<real_type>::min() / 2, |
| std::nextafter(std::numeric_limits<real_type>::min(), |
| 0.0), // denorm_max |
| std::nextafter(std::numeric_limits<real_type>::denorm_min(), 1.0f), |
| }; |
| |
| int index = -1; |
| for (const long double dd : kValues) { |
| index++; |
| EXPECT_EQ(dd, StreamRoundTrip<real_type>(dd)) << index; |
| EXPECT_EQ(-dd, StreamRoundTrip<real_type>(-dd)) << index; |
| |
| // Avoid undefined behavior (overflow/underflow). |
| if (dd <= std::numeric_limits<double>::max() && |
| dd >= std::numeric_limits<double>::lowest()) { |
| double d = static_cast<double>(dd); |
| EXPECT_EQ(d, StreamRoundTrip<double>(d)); |
| } |
| |
| // Avoid undefined behavior (overflow/underflow). |
| if (dd <= std::numeric_limits<int64_t>::max() && |
| dd >= std::numeric_limits<int64_t>::lowest()) { |
| int64_t x = static_cast<int64_t>(dd); |
| EXPECT_EQ(x, StreamRoundTrip<int64_t>(x)); |
| } |
| } |
| } |
| |
| TEST(StrToDTest, DoubleMin) { |
| const char kV[] = "2.22507385850720138e-308"; |
| char* end; |
| double x = std::strtod(kV, &end); |
| EXPECT_EQ(std::numeric_limits<double>::min(), x); |
| // errno may equal ERANGE. |
| } |
| |
| TEST(StrToDTest, DoubleDenormMin) { |
| const char kV[] = "4.94065645841246544e-324"; |
| char* end; |
| double x = std::strtod(kV, &end); |
| EXPECT_EQ(std::numeric_limits<double>::denorm_min(), x); |
| // errno may equal ERANGE. |
| } |
| |
| } // namespace |
