aboutsummaryrefslogtreecommitdiff
path: root/test/format-impl-test.cc
diff options
context:
space:
mode:
Diffstat (limited to 'test/format-impl-test.cc')
-rw-r--r--test/format-impl-test.cc232
1 files changed, 112 insertions, 120 deletions
diff --git a/test/format-impl-test.cc b/test/format-impl-test.cc
index 3c944382..1290c077 100644
--- a/test/format-impl-test.cc
+++ b/test/format-impl-test.cc
@@ -10,21 +10,23 @@
#include "test-assert.h"
// Include format.cc instead of format.h to test implementation.
-#include "../src/format.cc"
-#include "fmt/printf.h"
-
#include <algorithm>
#include <cstring>
+#include "../src/format.cc"
+#include "fmt/printf.h"
#include "gmock.h"
#include "gtest-extra.h"
#include "util.h"
-#undef max
+#ifdef _WIN32
+# include <windows.h>
+# undef max
+#endif
-using fmt::internal::bigint;
-using fmt::internal::fp;
-using fmt::internal::max_value;
+using fmt::detail::bigint;
+using fmt::detail::fp;
+using fmt::detail::max_value;
static_assert(!std::is_copy_constructible<bigint>::value, "");
static_assert(!std::is_copy_assignable<bigint>::value, "");
@@ -103,7 +105,7 @@ TEST(BigIntTest, Multiply) {
}
TEST(BigIntTest, Accumulator) {
- fmt::internal::accumulator acc;
+ fmt::detail::accumulator acc;
EXPECT_EQ(acc.lower, 0);
EXPECT_EQ(acc.upper, 0);
acc.upper = 12;
@@ -111,7 +113,7 @@ TEST(BigIntTest, Accumulator) {
EXPECT_EQ(static_cast<uint32_t>(acc), 34);
acc += 56;
EXPECT_EQ(acc.lower, 90);
- acc += fmt::internal::max_value<uint64_t>();
+ acc += fmt::detail::max_value<uint64_t>();
EXPECT_EQ(acc.upper, 13);
EXPECT_EQ(acc.lower, 89);
acc >>= 32;
@@ -187,29 +189,6 @@ template <bool is_iec559> void run_double_tests() {
template <> void run_double_tests<true>() {
// Construct from double.
EXPECT_EQ(fp(1.23), fp(0x13ae147ae147aeu, -52));
-
- // Compute boundaries:
- fp value;
- // Normalized & not power of 2 - equidistant boundaries:
- auto b = value.assign_with_boundaries(1.23);
- EXPECT_EQ(value, fp(0x0013ae147ae147ae, -52));
- EXPECT_EQ(b.lower, 0x9d70a3d70a3d6c00);
- EXPECT_EQ(b.upper, 0x9d70a3d70a3d7400);
- // Normalized power of 2 - lower boundary is closer:
- b = value.assign_with_boundaries(1.9807040628566084e+28); // 2**94
- EXPECT_EQ(value, fp(0x0010000000000000, 42));
- EXPECT_EQ(b.lower, 0x7ffffffffffffe00);
- EXPECT_EQ(b.upper, 0x8000000000000400);
- // Smallest normalized double - equidistant boundaries:
- b = value.assign_with_boundaries(2.2250738585072014e-308);
- EXPECT_EQ(value, fp(0x0010000000000000, -1074));
- EXPECT_EQ(b.lower, 0x7ffffffffffffc00);
- EXPECT_EQ(b.upper, 0x8000000000000400);
- // Subnormal - equidistant boundaries:
- b = value.assign_with_boundaries(4.9406564584124654e-324);
- EXPECT_EQ(value, fp(0x0000000000000001, -1074));
- EXPECT_EQ(b.lower, 0x4000000000000000);
- EXPECT_EQ(b.upper, 0xc000000000000000);
}
TEST(FPTest, DoubleTests) {
@@ -223,33 +202,6 @@ TEST(FPTest, Normalize) {
EXPECT_EQ(-6, normalized.e);
}
-TEST(FPTest, ComputeFloatBoundaries) {
- struct {
- double x, lower, upper;
- } tests[] = {
- // regular
- {1.5f, 1.4999999403953552, 1.5000000596046448},
- // boundary
- {1.0f, 0.9999999701976776, 1.0000000596046448},
- // min normal
- {1.1754944e-38f, 1.1754942807573643e-38, 1.1754944208872107e-38},
- // max subnormal
- {1.1754942e-38f, 1.1754941406275179e-38, 1.1754942807573643e-38},
- // min subnormal
- {1e-45f, 7.006492321624085e-46, 2.1019476964872256e-45},
- };
- for (auto test : tests) {
- fp vlower = normalize(fp(test.lower));
- fp vupper = normalize(fp(test.upper));
- vlower.f >>= vupper.e - vlower.e;
- vlower.e = vupper.e;
- fp value;
- auto b = value.assign_float_with_boundaries(test.x);
- EXPECT_EQ(vlower.f, b.lower);
- EXPECT_EQ(vupper.f, b.upper);
- }
-}
-
TEST(FPTest, Multiply) {
auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7);
EXPECT_EQ(v.f, 123u * 56u);
@@ -260,44 +212,83 @@ TEST(FPTest, Multiply) {
}
TEST(FPTest, GetCachedPower) {
- typedef std::numeric_limits<double> limits;
+ using limits = std::numeric_limits<double>;
for (auto exp = limits::min_exponent; exp <= limits::max_exponent; ++exp) {
int dec_exp = 0;
- auto fp = fmt::internal::get_cached_power(exp, dec_exp);
- EXPECT_LE(exp, fp.e);
- int dec_exp_step = 8;
- EXPECT_LE(fp.e, exp + dec_exp_step * log2(10));
- EXPECT_DOUBLE_EQ(pow(10, dec_exp), ldexp(static_cast<double>(fp.f), fp.e));
+ auto fp = fmt::detail::get_cached_power(exp, dec_exp);
+ bigint exact, cache(fp.f);
+ if (dec_exp >= 0) {
+ exact.assign_pow10(dec_exp);
+ if (fp.e <= 0)
+ exact <<= -fp.e;
+ else
+ cache <<= fp.e;
+ exact.align(cache);
+ cache.align(exact);
+ auto exact_str = fmt::format("{}", exact);
+ auto cache_str = fmt::format("{}", cache);
+ EXPECT_EQ(exact_str.size(), cache_str.size());
+ EXPECT_EQ(exact_str.substr(0, 15), cache_str.substr(0, 15));
+ int diff = cache_str[15] - exact_str[15];
+ if (diff == 1)
+ EXPECT_GT(exact_str[16], '8');
+ else
+ EXPECT_EQ(diff, 0);
+ } else {
+ cache.assign_pow10(-dec_exp);
+ cache *= fp.f + 1; // Inexact check.
+ exact.assign(1);
+ exact <<= -fp.e;
+ exact.align(cache);
+ auto exact_str = fmt::format("{}", exact);
+ auto cache_str = fmt::format("{}", cache);
+ EXPECT_EQ(exact_str.size(), cache_str.size());
+ EXPECT_EQ(exact_str.substr(0, 16), cache_str.substr(0, 16));
+ }
}
}
+TEST(FPTest, DragonboxMaxK) {
+ using fmt::detail::dragonbox::floor_log10_pow2;
+ using float_info = fmt::detail::dragonbox::float_info<float>;
+ EXPECT_EQ(fmt::detail::const_check(float_info::max_k),
+ float_info::kappa - floor_log10_pow2(float_info::min_exponent -
+ float_info::significand_bits));
+ using double_info = fmt::detail::dragonbox::float_info<double>;
+ EXPECT_EQ(
+ fmt::detail::const_check(double_info::max_k),
+ double_info::kappa - floor_log10_pow2(double_info::min_exponent -
+ double_info::significand_bits));
+}
+
TEST(FPTest, GetRoundDirection) {
- using fmt::internal::get_round_direction;
- EXPECT_EQ(fmt::internal::down, get_round_direction(100, 50, 0));
- EXPECT_EQ(fmt::internal::up, get_round_direction(100, 51, 0));
- EXPECT_EQ(fmt::internal::down, get_round_direction(100, 40, 10));
- EXPECT_EQ(fmt::internal::up, get_round_direction(100, 60, 10));
- for (int i = 41; i < 60; ++i)
- EXPECT_EQ(fmt::internal::unknown, get_round_direction(100, i, 10));
+ using fmt::detail::get_round_direction;
+ using fmt::detail::round_direction;
+ EXPECT_EQ(round_direction::down, get_round_direction(100, 50, 0));
+ EXPECT_EQ(round_direction::up, get_round_direction(100, 51, 0));
+ EXPECT_EQ(round_direction::down, get_round_direction(100, 40, 10));
+ EXPECT_EQ(round_direction::up, get_round_direction(100, 60, 10));
+ for (size_t i = 41; i < 60; ++i)
+ EXPECT_EQ(round_direction::unknown, get_round_direction(100, i, 10));
uint64_t max = max_value<uint64_t>();
EXPECT_THROW(get_round_direction(100, 100, 0), assertion_failure);
EXPECT_THROW(get_round_direction(100, 0, 100), assertion_failure);
EXPECT_THROW(get_round_direction(100, 0, 50), assertion_failure);
// Check that remainder + error doesn't overflow.
- EXPECT_EQ(fmt::internal::up, get_round_direction(max, max - 1, 2));
+ EXPECT_EQ(round_direction::up, get_round_direction(max, max - 1, 2));
// Check that 2 * (remainder + error) doesn't overflow.
- EXPECT_EQ(fmt::internal::unknown,
+ EXPECT_EQ(round_direction::unknown,
get_round_direction(max, max / 2 + 1, max / 2));
// Check that remainder - error doesn't overflow.
- EXPECT_EQ(fmt::internal::unknown, get_round_direction(100, 40, 41));
+ EXPECT_EQ(round_direction::unknown, get_round_direction(100, 40, 41));
// Check that 2 * (remainder - error) doesn't overflow.
- EXPECT_EQ(fmt::internal::up, get_round_direction(max, max - 1, 1));
+ EXPECT_EQ(round_direction::up, get_round_direction(max, max - 1, 1));
}
TEST(FPTest, FixedHandler) {
- struct handler : fmt::internal::fixed_handler {
+ struct handler : fmt::detail::fixed_handler {
char buffer[10];
- handler(int prec = 0) : fmt::internal::fixed_handler() {
+ handler(int prec = 0) : fmt::detail::fixed_handler() {
buf = buffer;
precision = prec;
}
@@ -306,8 +297,8 @@ TEST(FPTest, FixedHandler) {
handler().on_digit('0', 100, 99, 0, exp, false);
EXPECT_THROW(handler().on_digit('0', 100, 100, 0, exp, false),
assertion_failure);
- namespace digits = fmt::internal::digits;
- EXPECT_EQ(handler(1).on_digit('0', 100, 10, 10, exp, false), digits::done);
+ namespace digits = fmt::detail::digits;
+ EXPECT_EQ(handler(1).on_digit('0', 100, 10, 10, exp, false), digits::error);
// Check that divisor - error doesn't overflow.
EXPECT_EQ(handler(1).on_digit('0', 100, 10, 101, exp, false), digits::error);
// Check that 2 * error doesn't overflow.
@@ -318,7 +309,7 @@ TEST(FPTest, FixedHandler) {
TEST(FPTest, GrisuFormatCompilesWithNonIEEEDouble) {
fmt::memory_buffer buf;
- format_float(0.42, -1, fmt::internal::float_specs(), buf);
+ format_float(0.42, -1, fmt::detail::float_specs(), buf);
}
template <typename T> struct value_extractor {
@@ -328,41 +319,33 @@ template <typename T> struct value_extractor {
throw std::runtime_error(fmt::format("invalid type {}", typeid(U).name()));
}
-#ifdef __apple_build_version__
+#if FMT_USE_INT128
// Apple Clang does not define typeid for __int128_t and __uint128_t.
- FMT_NORETURN T operator()(__int128_t) {
- throw std::runtime_error(fmt::format("invalid type {}", "__int128_t"));
+ FMT_NORETURN T operator()(fmt::detail::int128_t) {
+ throw std::runtime_error("invalid type __int128_t");
}
- FMT_NORETURN T operator()(__uint128_t) {
- throw std::runtime_error(fmt::format("invalid type {}", "__uint128_t"));
+ FMT_NORETURN T operator()(fmt::detail::uint128_t) {
+ throw std::runtime_error("invalid type __uint128_t");
}
#endif
};
TEST(FormatTest, ArgConverter) {
long long value = max_value<long long>();
- auto arg = fmt::internal::make_arg<fmt::format_context>(value);
+ auto arg = fmt::detail::make_arg<fmt::format_context>(value);
fmt::visit_format_arg(
- fmt::internal::arg_converter<long long, fmt::format_context>(arg, 'd'),
+ fmt::detail::arg_converter<long long, fmt::format_context>(arg, 'd'),
arg);
EXPECT_EQ(value, fmt::visit_format_arg(value_extractor<long long>(), arg));
}
-TEST(FormatTest, FormatNegativeNaN) {
- double nan = std::numeric_limits<double>::quiet_NaN();
- if (std::signbit(-nan))
- EXPECT_EQ("-nan", fmt::format("{}", -nan));
- else
- fmt::print("Warning: compiler doesn't handle negative NaN correctly");
-}
-
TEST(FormatTest, StrError) {
char* message = nullptr;
char buffer[BUFFER_SIZE];
- EXPECT_ASSERT(fmt::internal::safe_strerror(EDOM, message = nullptr, 0),
+ EXPECT_ASSERT(fmt::detail::safe_strerror(EDOM, message = nullptr, 0),
"invalid buffer");
- EXPECT_ASSERT(fmt::internal::safe_strerror(EDOM, message = buffer, 0),
+ EXPECT_ASSERT(fmt::detail::safe_strerror(EDOM, message = buffer, 0),
"invalid buffer");
buffer[0] = 'x';
#if defined(_GNU_SOURCE) && !defined(__COVERITY__)
@@ -374,18 +357,18 @@ TEST(FormatTest, StrError) {
#endif
int result =
- fmt::internal::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
+ fmt::detail::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
EXPECT_EQ(result, 0);
- std::size_t message_size = std::strlen(message);
+ size_t message_size = std::strlen(message);
EXPECT_GE(BUFFER_SIZE - 1u, message_size);
EXPECT_EQ(get_system_error(error_code), message);
// safe_strerror never uses buffer on MinGW.
#if !defined(__MINGW32__) && !defined(__sun)
result =
- fmt::internal::safe_strerror(error_code, message = buffer, message_size);
+ fmt::detail::safe_strerror(error_code, message = buffer, message_size);
EXPECT_EQ(ERANGE, result);
- result = fmt::internal::safe_strerror(error_code, message = buffer, 1);
+ result = fmt::detail::safe_strerror(error_code, message = buffer, 1);
EXPECT_EQ(buffer, message); // Message should point to buffer.
EXPECT_EQ(ERANGE, result);
EXPECT_STREQ("", message);
@@ -397,45 +380,48 @@ TEST(FormatTest, FormatErrorCode) {
{
fmt::memory_buffer buffer;
format_to(buffer, "garbage");
- fmt::internal::format_error_code(buffer, 42, "test");
+ fmt::detail::format_error_code(buffer, 42, "test");
EXPECT_EQ("test: " + msg, to_string(buffer));
}
{
fmt::memory_buffer buffer;
std::string prefix(fmt::inline_buffer_size - msg.size() - sep.size() + 1,
'x');
- fmt::internal::format_error_code(buffer, 42, prefix);
+ fmt::detail::format_error_code(buffer, 42, prefix);
EXPECT_EQ(msg, to_string(buffer));
}
int codes[] = {42, -1};
- for (std::size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
+ for (size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
// Test maximum buffer size.
msg = fmt::format("error {}", codes[i]);
fmt::memory_buffer buffer;
std::string prefix(fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
- fmt::internal::format_error_code(buffer, codes[i], prefix);
+ fmt::detail::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(prefix + sep + msg, to_string(buffer));
- std::size_t size = fmt::inline_buffer_size;
+ size_t size = fmt::inline_buffer_size;
EXPECT_EQ(size, buffer.size());
buffer.resize(0);
// Test with a message that doesn't fit into the buffer.
prefix += 'x';
- fmt::internal::format_error_code(buffer, codes[i], prefix);
+ fmt::detail::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(msg, to_string(buffer));
}
}
TEST(FormatTest, CountCodePoints) {
- EXPECT_EQ(4, fmt::internal::count_code_points(fmt::u8string_view("ёжик")));
+ EXPECT_EQ(4,
+ fmt::detail::count_code_points(
+ fmt::basic_string_view<fmt::detail::char8_type>(
+ reinterpret_cast<const fmt::detail::char8_type*>("ёжик"))));
}
-// Tests fmt::internal::count_digits for integer type Int.
+// Tests fmt::detail::count_digits for integer type Int.
template <typename Int> void test_count_digits() {
- for (Int i = 0; i < 10; ++i) EXPECT_EQ(1u, fmt::internal::count_digits(i));
+ for (Int i = 0; i < 10; ++i) EXPECT_EQ(1u, fmt::detail::count_digits(i));
for (Int i = 1, n = 1, end = max_value<Int>() / 10; n <= end; ++i) {
n *= 10;
- EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
- EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
+ EXPECT_EQ(i, fmt::detail::count_digits(n - 1));
+ EXPECT_EQ(i + 1, fmt::detail::count_digits(n));
}
}
@@ -444,11 +430,17 @@ TEST(UtilTest, CountDigits) {
test_count_digits<uint64_t>();
}
-TEST(UtilTest, WriteUIntPtr) {
- fmt::memory_buffer buf;
- fmt::internal::writer writer(buf);
- writer.write_pointer(fmt::internal::fallback_uintptr(
- reinterpret_cast<void*>(0xface)),
- nullptr);
- EXPECT_EQ("0xface", to_string(buf));
+TEST(UtilTest, WriteFallbackUIntPtr) {
+ std::string s;
+ fmt::detail::write_ptr<char>(
+ std::back_inserter(s),
+ fmt::detail::fallback_uintptr(reinterpret_cast<void*>(0xface)), nullptr);
+ EXPECT_EQ(s, "0xface");
}
+
+#ifdef _WIN32
+TEST(UtilTest, WriteConsoleSignature) {
+ decltype(WriteConsoleW)* p = fmt::detail::WriteConsoleW;
+ (void)p;
+}
+#endif
generated by cgit v1.2.3 (git 2.25.1) at 2024-07-02 17:53:20 +0000