mirror of
https://github.com/fmtlib/fmt.git
synced 2024-11-27 04:20:06 +00:00
279 lines
9.3 KiB
C++
279 lines
9.3 KiB
C++
// 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.
|
|
|
|
#define FMT_NOEXCEPT
|
|
#undef FMT_SHARED
|
|
#include "test-assert.h"
|
|
|
|
// Include format.cc instead of format.h to test implementation.
|
|
#include "../src/format.cc"
|
|
#include "fmt/color.h"
|
|
#include "fmt/printf.h"
|
|
|
|
#include <algorithm>
|
|
#include <cstring>
|
|
|
|
#include "gmock.h"
|
|
#include "gtest-extra.h"
|
|
#include "util.h"
|
|
|
|
#undef min
|
|
#undef max
|
|
|
|
#if FMT_HAS_CPP_ATTRIBUTE(noreturn)
|
|
# define FMT_NORETURN [[noreturn]]
|
|
#else
|
|
# define FMT_NORETURN
|
|
#endif
|
|
|
|
using fmt::internal::fp;
|
|
|
|
template <bool is_iec559>
|
|
void test_construct_from_double() {
|
|
fmt::print("warning: double is not IEC559, skipping FP tests\n");
|
|
}
|
|
|
|
template <>
|
|
void test_construct_from_double<true>() {
|
|
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) {
|
|
auto v = fp(0xbeef, 42);
|
|
v.normalize();
|
|
EXPECT_EQ(0xbeef000000000000, v.f);
|
|
EXPECT_EQ(-6, v.e);
|
|
}
|
|
|
|
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));
|
|
EXPECT_DOUBLE_EQ(pow(10, dec_exp), ldexp(fp.f, fp.e));
|
|
}
|
|
}
|
|
|
|
TEST(FPTest, Grisu2FormatCompilesWithNonIEEEDouble) {
|
|
fmt::memory_buffer buf;
|
|
grisu2_format(4.2f, buf, fmt::core_format_specs());
|
|
}
|
|
|
|
template <typename T>
|
|
struct ValueExtractor: fmt::internal::function<T> {
|
|
T operator()(T value) {
|
|
return value;
|
|
}
|
|
|
|
template <typename U>
|
|
FMT_NORETURN T operator()(U) {
|
|
throw std::runtime_error(fmt::format("invalid type {}", typeid(U).name()));
|
|
}
|
|
};
|
|
|
|
TEST(FormatTest, ArgConverter) {
|
|
long long value = std::numeric_limits<long long>::max();
|
|
auto arg = fmt::internal::make_arg<fmt::format_context>(value);
|
|
visit(fmt::internal::arg_converter<long long, fmt::format_context>(arg, 'd'),
|
|
arg);
|
|
EXPECT_EQ(value, visit(ValueExtractor<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 = FMT_NULL;
|
|
char buffer[BUFFER_SIZE];
|
|
EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = FMT_NULL, 0),
|
|
"invalid buffer");
|
|
EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = buffer, 0),
|
|
"invalid buffer");
|
|
buffer[0] = 'x';
|
|
#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.
|
|
int error_code = -1;
|
|
#else
|
|
int error_code = EDOM;
|
|
#endif
|
|
|
|
int result = fmt::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
|
|
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.
|
|
#ifndef __MINGW32__
|
|
result = fmt::safe_strerror(error_code, message = buffer, message_size);
|
|
EXPECT_EQ(ERANGE, result);
|
|
result = fmt::safe_strerror(error_code, message = buffer, 1);
|
|
EXPECT_EQ(buffer, message); // Message should point to buffer.
|
|
EXPECT_EQ(ERANGE, result);
|
|
EXPECT_STREQ("", message);
|
|
#endif
|
|
}
|
|
|
|
TEST(FormatTest, FormatErrorCode) {
|
|
std::string msg = "error 42", sep = ": ";
|
|
{
|
|
fmt::memory_buffer buffer;
|
|
format_to(buffer, "garbage");
|
|
fmt::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::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) {
|
|
// 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::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';
|
|
fmt::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("ёжик")));
|
|
}
|
|
|
|
TEST(ColorsTest, ColorsPrint) {
|
|
EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
|
|
"\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
|
|
EXPECT_WRITE(stdout, fmt::print(fg(fmt::color::blue), "blue"),
|
|
"\x1b[38;2;000;000;255mblue\x1b[0m");
|
|
EXPECT_WRITE(
|
|
stdout,
|
|
fmt::print(fg(fmt::color::blue) | bg(fmt::color::red), "two color"),
|
|
"\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m");
|
|
EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::bold, "bold"),
|
|
"\x1b[1mbold\x1b[0m");
|
|
EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::italic, "italic"),
|
|
"\x1b[3mitalic\x1b[0m");
|
|
EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::underline, "underline"),
|
|
"\x1b[4munderline\x1b[0m");
|
|
EXPECT_WRITE(stdout,
|
|
fmt::print(fmt::emphasis::strikethrough, "strikethrough"),
|
|
"\x1b[9mstrikethrough\x1b[0m");
|
|
EXPECT_WRITE(
|
|
stdout,
|
|
fmt::print(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"),
|
|
"\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m");
|
|
EXPECT_WRITE(stderr, fmt::print(stderr, fmt::emphasis::bold, "bold error"),
|
|
"\x1b[1mbold error\x1b[0m");
|
|
EXPECT_WRITE(stderr, fmt::print(stderr, fg(fmt::color::blue), "blue log"),
|
|
"\x1b[38;2;000;000;255mblue log\x1b[0m");
|
|
EXPECT_WRITE(stdout, fmt::print(fmt::text_style(), "hi"), "hi");
|
|
EXPECT_WRITE(stdout, fmt::print(fg(fmt::terminal_color::red), "tred"),
|
|
"\x1b[31mtred\x1b[0m");
|
|
EXPECT_WRITE(stdout, fmt::print(bg(fmt::terminal_color::cyan), "tcyan"),
|
|
"\x1b[46mtcyan\x1b[0m");
|
|
EXPECT_WRITE(stdout,
|
|
fmt::print(fg(fmt::terminal_color::bright_green), "tbgreen"),
|
|
"\x1b[92mtbgreen\x1b[0m");
|
|
EXPECT_WRITE(stdout,
|
|
fmt::print(bg(fmt::terminal_color::bright_magenta), "tbmagenta"),
|
|
"\x1b[105mtbmagenta\x1b[0m");
|
|
}
|
|
|
|
TEST(ColorsTest, ColorsFormat) {
|
|
EXPECT_EQ(fmt::format(fg(fmt::rgb(255, 20, 30)), "rgb(255,20,30)"),
|
|
"\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue"),
|
|
"\x1b[38;2;000;000;255mblue\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fg(fmt::color::blue) | bg(fmt::color::red), "two color"),
|
|
"\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold"),
|
|
"\x1b[1mbold\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fmt::emphasis::italic, "italic"),
|
|
"\x1b[3mitalic\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fmt::emphasis::underline, "underline"),
|
|
"\x1b[4munderline\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fmt::emphasis::strikethrough, "strikethrough"),
|
|
"\x1b[9mstrikethrough\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold, "blue/bold"),
|
|
"\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fmt::emphasis::bold, "bold error"),
|
|
"\x1b[1mbold error\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fg(fmt::color::blue), "blue log"),
|
|
"\x1b[38;2;000;000;255mblue log\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fmt::text_style(), "hi"), "hi");
|
|
EXPECT_EQ(fmt::format(fg(fmt::terminal_color::red), "tred"),
|
|
"\x1b[31mtred\x1b[0m");
|
|
EXPECT_EQ(fmt::format(bg(fmt::terminal_color::cyan), "tcyan"),
|
|
"\x1b[46mtcyan\x1b[0m");
|
|
EXPECT_EQ(fmt::format(fg(fmt::terminal_color::bright_green), "tbgreen"),
|
|
"\x1b[92mtbgreen\x1b[0m");
|
|
EXPECT_EQ(fmt::format(bg(fmt::terminal_color::bright_magenta), "tbmagenta"),
|
|
"\x1b[105mtbmagenta\x1b[0m");
|
|
}
|