fmt/test/format-impl-test.cc

405 lines
12 KiB
C++
Raw Normal View History

2018-03-04 17:16:51 +00:00
// Formatting library for C++ - formatting library implementation tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
2014-09-05 14:35:00 +00:00
2015-06-22 16:24:54 +00:00
#define FMT_NOEXCEPT
#undef FMT_SHARED
2015-06-22 15:17:23 +00:00
#include "test-assert.h"
2018-03-04 17:16:51 +00:00
// Include format.cc instead of format.h to test implementation.
2018-03-21 14:50:59 +00:00
#include "../src/format.cc"
2017-12-17 16:36:19 +00:00
#include "fmt/printf.h"
2016-03-04 17:04:28 +00:00
#include <algorithm>
#include <cstring>
#include "gmock.h"
2014-09-05 14:35:00 +00:00
#include "gtest-extra.h"
#include "util.h"
2014-09-05 14:35:00 +00:00
2014-09-05 15:06:07 +00:00
#undef max
2019-09-07 19:54:16 +00:00
using fmt::internal::bigint;
2018-08-29 16:34:57 +00:00
using fmt::internal::fp;
2019-09-08 16:04:09 +00:00
using fmt::internal::max_value;
2018-08-29 16:34:57 +00:00
2019-09-07 19:54:16 +00:00
static_assert(!std::is_copy_constructible<bigint>::value, "");
static_assert(!std::is_copy_assignable<bigint>::value, "");
TEST(BigIntTest, Construct) {
EXPECT_EQ("", fmt::format("{}", bigint()));
2019-09-07 19:54:16 +00:00
EXPECT_EQ("42", fmt::format("{}", bigint(0x42)));
EXPECT_EQ("123456789abcedf0", fmt::format("{}", bigint(0x123456789abcedf0)));
}
2019-10-09 17:31:17 +00:00
TEST(BigIntTest, GreaterEqual) {
2019-10-06 19:34:02 +00:00
bigint n1(42);
bigint n2(42);
2019-10-09 17:31:17 +00:00
EXPECT_TRUE(n1 >= n2);
2019-10-06 19:34:02 +00:00
n2 <<= 32;
2019-10-09 17:31:17 +00:00
EXPECT_FALSE(n1 >= n2);
EXPECT_TRUE(n2 >= n1);
2019-10-06 19:34:02 +00:00
bigint n3(43);
2019-10-09 17:31:17 +00:00
EXPECT_FALSE(n1 >= n3);
EXPECT_TRUE(n3 >= n1);
2019-10-06 19:34:02 +00:00
bigint n4(42 * 0x100000001);
2019-10-09 17:31:17 +00:00
EXPECT_FALSE(n2 >= n4);
EXPECT_TRUE(n4 >= n2);
2019-10-06 19:34:02 +00:00
}
2019-09-08 00:38:27 +00:00
TEST(BigIntTest, ShiftLeft) {
bigint n(0x42);
n <<= 0;
EXPECT_EQ("42", fmt::format("{}", n));
n <<= 1;
EXPECT_EQ("84", fmt::format("{}", n));
n <<= 25;
EXPECT_EQ("108000000", fmt::format("{}", n));
}
TEST(BigIntTest, Multiply) {
bigint n(0x42);
n *= 1;
EXPECT_EQ("42", fmt::format("{}", n));
n *= 2;
EXPECT_EQ("84", fmt::format("{}", n));
n *= 0x12345678;
EXPECT_EQ("962fc95e0", fmt::format("{}", n));
2019-09-08 16:04:09 +00:00
auto max = max_value<uint32_t>();
bigint bigmax(max);
bigmax *= max;
EXPECT_EQ("fffffffe00000001", fmt::format("{}", bigmax));
}
2019-10-05 18:45:33 +00:00
TEST(BigIntTest, Accumulator) {
fmt::internal::accumulator acc;
EXPECT_EQ(acc.lower, 0);
EXPECT_EQ(acc.upper, 0);
acc.upper = 12;
acc.lower = 34;
EXPECT_EQ(static_cast<uint32_t>(acc), 34);
acc += 56;
EXPECT_EQ(acc.lower, 90);
acc += fmt::internal::max_value<uint64_t>();
EXPECT_EQ(acc.upper, 13);
EXPECT_EQ(acc.lower, 89);
acc >>= 32;
EXPECT_EQ(acc.upper, 0);
EXPECT_EQ(acc.lower, 13 * 0x100000000);
}
TEST(BigIntTest, Square) {
bigint n0(0);
n0.square();
EXPECT_EQ("0", fmt::format("{}", n0));
bigint n1(0x100);
n1.square();
EXPECT_EQ("10000", fmt::format("{}", n1));
bigint n2(0xfffffffff);
n2.square();
EXPECT_EQ("ffffffffe000000001", fmt::format("{}", n2));
bigint n3(max_value<uint64_t>());
n3.square();
EXPECT_EQ("fffffffffffffffe0000000000000001", fmt::format("{}", n3));
2019-10-06 19:34:02 +00:00
bigint n4;
n4.assign_pow10(10);
EXPECT_EQ("2540be400", fmt::format("{}", n4));
2019-10-05 18:45:33 +00:00
}
2019-10-09 17:31:17 +00:00
TEST(BigIntTest, DivModAssignZeroDivisor) {
bigint zero(0);
EXPECT_THROW(bigint(0).divmod_assign(zero), assertion_failure);
EXPECT_THROW(bigint(42).divmod_assign(zero), assertion_failure);
}
TEST(BigIntTest, DivModAssignSelf) {
bigint n(100);
EXPECT_THROW(n.divmod_assign(n), assertion_failure);
}
TEST(BigIntTest, DivModAssignUnaligned) {
// (42 << 340) / pow(10, 100):
bigint n1(42);
n1 <<= 340;
bigint n2;
n2.assign_pow10(100);
int result = n1.divmod_assign(n2);
EXPECT_EQ(result, 9406);
EXPECT_EQ("10f8353019583bfc29ffc8f564e1b9f9d819dbb4cf783e4507eca1539220p96",
fmt::format("{}", n1));
}
TEST(BigIntTest, DivModAssign) {
// 100 / 10:
bigint n1(100);
int result = n1.divmod_assign(bigint(10));
EXPECT_EQ(result, 10);
EXPECT_EQ("0", fmt::format("{}", n1));
// pow(10, 100) / (42 << 320):
n1.assign_pow10(100);
result = n1.divmod_assign(bigint(42) <<= 320);
EXPECT_EQ(result, 111);
EXPECT_EQ("13ad2594c37ceb0b2784c4ce0bf38ace408e211a7caab24308a82e8f10p96",
fmt::format("{}", n1));
// 42 / 100:
bigint n2(42);
n1.assign_pow10(2);
result = n2.divmod_assign(n1);
EXPECT_EQ(result, 0);
EXPECT_EQ("2a", fmt::format("{}", n2));
}
2019-01-13 02:27:38 +00:00
template <bool is_iec559> void test_construct_from_double() {
2018-08-29 16:34:57 +00:00
fmt::print("warning: double is not IEC559, skipping FP tests\n");
}
2019-01-13 02:27:38 +00:00
template <> void test_construct_from_double<true>() {
2018-08-29 16:34:57 +00:00
auto v = fp(1.23);
EXPECT_EQ(v.f, 0x13ae147ae147aeu);
EXPECT_EQ(v.e, -52);
}
TEST(FPTest, ConstructFromDouble) {
test_construct_from_double<std::numeric_limits<double>::is_iec559>();
}
TEST(FPTest, Normalize) {
2019-09-08 00:07:53 +00:00
const auto v = fp(0xbeef, 42);
auto normalized = normalize(v);
EXPECT_EQ(0xbeef000000000000, normalized.f);
EXPECT_EQ(-6, normalized.e);
2018-08-29 16:34:57 +00:00
}
TEST(FPTest, ComputeBoundariesSubnormal) {
auto v = fp(0xbeef, 42);
fp lower, upper;
v.compute_boundaries(lower, upper);
EXPECT_EQ(0xbeee800000000000, lower.f);
EXPECT_EQ(-6, lower.e);
EXPECT_EQ(0xbeef800000000000, upper.f);
EXPECT_EQ(-6, upper.e);
}
TEST(FPTest, ComputeBoundaries) {
auto v = fp(0x10000000000000, 42);
fp lower, upper;
v.compute_boundaries(lower, upper);
EXPECT_EQ(0x7ffffffffffffe00, lower.f);
EXPECT_EQ(31, lower.e);
EXPECT_EQ(0x8000000000000400, upper.f);
EXPECT_EQ(31, upper.e);
}
TEST(FPTest, Subtract) {
auto v = fp(123, 1) - fp(102, 1);
EXPECT_EQ(v.f, 21u);
EXPECT_EQ(v.e, 1);
}
TEST(FPTest, Multiply) {
auto v = fp(123ULL << 32, 4) * fp(56ULL << 32, 7);
EXPECT_EQ(v.f, 123u * 56u);
EXPECT_EQ(v.e, 4 + 7 + 64);
v = fp(123ULL << 32, 4) * fp(567ULL << 31, 8);
EXPECT_EQ(v.f, (123 * 567 + 1u) / 2);
EXPECT_EQ(v.e, 4 + 8 + 64);
}
TEST(FPTest, GetCachedPower) {
typedef std::numeric_limits<double> limits;
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));
2019-04-07 05:10:10 +00:00
EXPECT_DOUBLE_EQ(pow(10, dec_exp), ldexp(static_cast<double>(fp.f), fp.e));
2018-08-29 16:34:57 +00:00
}
}
2019-03-10 18:14:50 +00:00
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));
2019-09-08 16:04:09 +00:00
uint64_t max = max_value<uint64_t>();
2019-03-10 18:14:50 +00:00
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));
// Check that 2 * (remainder + error) doesn't overflow.
EXPECT_EQ(fmt::internal::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));
// Check that 2 * (remainder - error) doesn't overflow.
EXPECT_EQ(fmt::internal::up, get_round_direction(max, max - 1, 1));
}
2019-03-13 20:10:18 +00:00
TEST(FPTest, FixedHandler) {
struct handler : fmt::internal::fixed_handler {
char buffer[10];
handler(int prec = 0) : fmt::internal::fixed_handler() {
buf = buffer;
precision = prec;
}
};
int exp = 0;
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);
// 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.
2019-09-08 16:04:09 +00:00
uint64_t max = max_value<uint64_t>();
2019-03-13 20:10:18 +00:00
EXPECT_EQ(handler(1).on_digit('0', max, 10, max - 1, exp, false),
digits::error);
}
2019-04-27 13:52:46 +00:00
TEST(FPTest, GrisuFormatCompilesWithNonIEEEDouble) {
2018-10-17 15:19:46 +00:00
fmt::memory_buffer buf;
int exp = 0;
2019-04-27 13:52:46 +00:00
grisu_format(4.2f, buf, -1, false, exp);
}
template <typename T> struct value_extractor {
2019-01-13 02:27:38 +00:00
T operator()(T value) { return value; }
2019-01-13 02:27:38 +00:00
template <typename U> FMT_NORETURN T operator()(U) {
throw std::runtime_error(fmt::format("invalid type {}", typeid(U).name()));
}
#ifdef __apple_build_version__
// 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()(__uint128_t) {
throw std::runtime_error(fmt::format("invalid type {}", "__uint128_t"));
}
#endif
};
2014-09-05 14:35:00 +00:00
TEST(FormatTest, ArgConverter) {
2019-09-08 16:04:09 +00:00
long long value = max_value<long long>();
2018-04-08 14:03:44 +00:00
auto arg = fmt::internal::make_arg<fmt::format_context>(value);
fmt::visit_format_arg(
fmt::internal::arg_converter<long long, fmt::format_context>(arg, 'd'),
arg);
EXPECT_EQ(value, fmt::visit_format_arg(value_extractor<long long>(), arg));
2014-09-05 14:35:00 +00:00
}
2014-09-05 15:04:26 +00:00
TEST(FormatTest, FormatNegativeNaN) {
2014-09-05 14:35:00 +00:00
double nan = std::numeric_limits<double>::quiet_NaN();
2018-10-10 16:41:01 +00:00
if (std::signbit(-nan))
2014-09-05 14:35:00 +00:00
EXPECT_EQ("-nan", fmt::format("{}", -nan));
else
fmt::print("Warning: compiler doesn't handle negative NaN correctly");
}
2014-09-05 15:04:26 +00:00
TEST(FormatTest, StrError) {
char* message = nullptr;
char buffer[BUFFER_SIZE];
2019-06-14 20:18:00 +00:00
EXPECT_ASSERT(fmt::internal::safe_strerror(EDOM, message = nullptr, 0),
2018-10-10 16:41:01 +00:00
"invalid buffer");
2019-06-14 20:18:00 +00:00
EXPECT_ASSERT(fmt::internal::safe_strerror(EDOM, message = buffer, 0),
2016-03-08 14:55:41 +00:00
"invalid buffer");
buffer[0] = 'x';
2015-10-21 15:30:10 +00:00
#if defined(_GNU_SOURCE) && !defined(__COVERITY__)
// Use invalid error code to make sure that safe_strerror returns an error
// message in the buffer rather than a pointer to a static string.
2015-10-21 15:30:10 +00:00
int error_code = -1;
#else
int error_code = EDOM;
#endif
2019-06-14 20:18:00 +00:00
int result =
fmt::internal::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
2018-10-10 16:41:01 +00:00
EXPECT_EQ(result, 0);
std::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.
2019-07-02 21:38:33 +00:00
#if !defined(__MINGW32__) && !defined(__sun)
2019-06-14 20:18:00 +00:00
result =
fmt::internal::safe_strerror(error_code, message = buffer, message_size);
EXPECT_EQ(ERANGE, result);
2019-06-14 20:18:00 +00:00
result = fmt::internal::safe_strerror(error_code, message = buffer, 1);
EXPECT_EQ(buffer, message); // Message should point to buffer.
EXPECT_EQ(ERANGE, result);
EXPECT_STREQ("", message);
#endif
}
2014-09-05 15:04:26 +00:00
TEST(FormatTest, FormatErrorCode) {
std::string msg = "error 42", sep = ": ";
{
fmt::memory_buffer buffer;
format_to(buffer, "garbage");
2019-06-14 20:18:00 +00:00
fmt::internal::format_error_code(buffer, 42, "test");
EXPECT_EQ("test: " + msg, to_string(buffer));
2014-09-05 15:04:26 +00:00
}
{
fmt::memory_buffer buffer;
2019-01-13 02:27:38 +00:00
std::string prefix(fmt::inline_buffer_size - msg.size() - sep.size() + 1,
'x');
2019-06-14 20:18:00 +00:00
fmt::internal::format_error_code(buffer, 42, prefix);
EXPECT_EQ(msg, to_string(buffer));
2014-09-05 15:04:26 +00:00
}
int codes[] = {42, -1};
for (std::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;
2019-01-13 02:27:38 +00:00
std::string prefix(fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
2019-06-14 20:18:00 +00:00
fmt::internal::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(prefix + sep + msg, to_string(buffer));
std::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';
2019-06-14 20:18:00 +00:00
fmt::internal::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(msg, to_string(buffer));
2014-09-05 15:04:26 +00:00
}
}
2018-07-21 16:13:21 +00:00
TEST(FormatTest, CountCodePoints) {
EXPECT_EQ(4, fmt::internal::count_code_points(fmt::u8string_view("ёжик")));
}
// Tests fmt::internal::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));
2019-10-06 19:34:02 +00:00
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));
}
}
TEST(UtilTest, CountDigits) {
test_count_digits<uint32_t>();
test_count_digits<uint64_t>();
}
TEST(UtilTest, WriteUIntPtr) {
fmt::memory_buffer buf;
2019-07-03 21:31:01 +00:00
fmt::internal::writer writer(buf);
writer.write_pointer(fmt::internal::bit_cast<fmt::internal::fallback_uintptr>(
reinterpret_cast<void*>(0xface)),
nullptr);
EXPECT_EQ("0xface", to_string(buf));
}