fmt/test/printf-test.cc

565 lines
19 KiB
C++
Raw Permalink Normal View History

2018-03-04 20:16:51 +03:00
// Formatting library for C++ - printf tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
#include "fmt/printf.h"
2014-08-21 18:29:23 +04:00
#include <cctype>
#include <climits>
#include <cstring>
#include "fmt/xchar.h"
#include "gtest-extra.h"
#include "util.h"
2014-06-29 02:58:02 +04:00
using fmt::format;
2016-08-25 18:38:07 +03:00
using fmt::format_error;
2020-05-10 17:25:42 +03:00
using fmt::detail::max_value;
2021-05-05 02:54:20 +03:00
const unsigned big_num = INT_MAX + 1u;
2014-06-06 19:01:25 +04:00
// Makes format string argument positional.
static std::string make_positional(fmt::string_view format) {
std::string s(format.data(), format.size());
2014-06-06 19:01:25 +04:00
s.replace(s.find('%'), 1, "%1$");
return s;
}
2021-05-22 03:37:07 +03:00
static std::wstring make_positional(fmt::basic_string_view<wchar_t> format) {
std::wstring s(format.data(), format.size());
s.replace(s.find(L'%'), 1, L"%1$");
return s;
}
2018-12-06 17:04:45 +03:00
// A wrapper around fmt::sprintf to workaround bogus warnings about invalid
// format strings in MSVC.
2018-12-06 21:12:42 +03:00
template <typename... Args>
2019-01-13 05:27:38 +03:00
std::string test_sprintf(fmt::string_view format, const Args&... args) {
2018-12-06 17:04:45 +03:00
return fmt::sprintf(format, args...);
}
2018-12-06 21:12:42 +03:00
template <typename... Args>
2021-05-22 03:37:07 +03:00
std::wstring test_sprintf(fmt::basic_string_view<wchar_t> format,
const Args&... args) {
2018-12-06 21:12:42 +03:00
return fmt::sprintf(format, args...);
}
2019-01-13 05:27:38 +03:00
#define EXPECT_PRINTF(expected_output, format, arg) \
2018-12-06 21:12:42 +03:00
EXPECT_EQ(expected_output, test_sprintf(format, arg)) \
2019-01-13 05:27:38 +03:00
<< "format: " << format; \
2018-12-06 21:12:42 +03:00
EXPECT_EQ(expected_output, fmt::sprintf(make_positional(format), arg))
2018-12-06 17:04:45 +03:00
2021-05-05 02:54:20 +03:00
TEST(printf_test, no_args) {
2018-12-06 17:04:45 +03:00
EXPECT_EQ("test", test_sprintf("test"));
EXPECT_EQ(L"test", fmt::sprintf(L"test"));
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, escape) {
2018-12-06 17:04:45 +03:00
EXPECT_EQ("%", test_sprintf("%%"));
EXPECT_EQ("before %", test_sprintf("before %%"));
EXPECT_EQ("% after", test_sprintf("%% after"));
EXPECT_EQ("before % after", test_sprintf("before %% after"));
EXPECT_EQ("%s", test_sprintf("%%s"));
EXPECT_EQ(L"%", fmt::sprintf(L"%%"));
EXPECT_EQ(L"before %", fmt::sprintf(L"before %%"));
EXPECT_EQ(L"% after", fmt::sprintf(L"%% after"));
EXPECT_EQ(L"before % after", fmt::sprintf(L"before %% after"));
EXPECT_EQ(L"%s", fmt::sprintf(L"%%s"));
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, positional_args) {
2018-12-06 17:04:45 +03:00
EXPECT_EQ("42", test_sprintf("%1$d", 42));
EXPECT_EQ("before 42", test_sprintf("before %1$d", 42));
2019-01-13 05:27:38 +03:00
EXPECT_EQ("42 after", test_sprintf("%1$d after", 42));
2018-12-06 17:04:45 +03:00
EXPECT_EQ("before 42 after", test_sprintf("before %1$d after", 42));
EXPECT_EQ("answer = 42", test_sprintf("%1$s = %2$d", "answer", 42));
2019-01-13 05:27:38 +03:00
EXPECT_EQ("42 is the answer", test_sprintf("%2$d is the %1$s", "answer", 42));
2018-12-06 17:04:45 +03:00
EXPECT_EQ("abracadabra", test_sprintf("%1$s%2$s%1$s", "abra", "cad"));
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, automatic_arg_indexing) {
2018-12-06 17:04:45 +03:00
EXPECT_EQ("abc", test_sprintf("%c%c%c", 'a', 'b', 'c'));
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, number_is_too_big_in_arg_index) {
EXPECT_THROW_MSG(test_sprintf(format("%{}$", big_num)), format_error,
"argument not found");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num)), format_error,
"argument not found");
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, switch_arg_indexing) {
2019-01-13 05:27:38 +03:00
EXPECT_THROW_MSG(test_sprintf("%1$d%", 1, 2), format_error,
"cannot switch from manual to automatic argument indexing");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
2019-01-13 05:27:38 +03:00
format_error, "number is too big");
EXPECT_THROW_MSG(test_sprintf("%1$d%d", 1, 2), format_error,
"cannot switch from manual to automatic argument indexing");
2019-01-13 05:27:38 +03:00
EXPECT_THROW_MSG(test_sprintf("%d%1$", 1, 2), format_error,
"cannot switch from automatic to manual argument indexing");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%d%{}$d", big_num), 1, 2), format_error,
"cannot switch from automatic to manual argument indexing");
2019-01-13 05:27:38 +03:00
EXPECT_THROW_MSG(test_sprintf("%d%1$d", 1, 2), format_error,
"cannot switch from automatic to manual argument indexing");
// Indexing errors override width errors.
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%d%1${}d", big_num), 1, 2),
2019-01-13 05:27:38 +03:00
format_error, "number is too big");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%1$d%{}d", big_num), 1, 2),
2019-01-13 05:27:38 +03:00
format_error, "number is too big");
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, invalid_arg_index) {
2018-12-06 17:04:45 +03:00
EXPECT_THROW_MSG(test_sprintf("%0$d", 42), format_error,
2020-04-14 16:48:55 +03:00
"argument not found");
2018-12-06 17:04:45 +03:00
EXPECT_THROW_MSG(test_sprintf("%2$d", 42), format_error,
2020-04-14 16:48:55 +03:00
"argument not found");
2019-01-13 05:27:38 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%{}$d", INT_MAX), 42), format_error,
2020-04-14 16:48:55 +03:00
"argument not found");
2020-05-08 01:59:46 +03:00
EXPECT_THROW_MSG(test_sprintf("%2$", 42), format_error, "argument not found");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%{}$d", big_num), 42), format_error,
"argument not found");
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, default_align_right) {
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF(" 42", "%5d", 42);
EXPECT_PRINTF(" abc", "%5s", "abc");
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, zero_flag) {
2014-06-06 19:01:25 +04:00
EXPECT_PRINTF("00042", "%05d", 42);
EXPECT_PRINTF("-0042", "%05d", -42);
EXPECT_PRINTF("00042", "%05d", 42);
EXPECT_PRINTF("-0042", "%05d", -42);
EXPECT_PRINTF("-004.2", "%06g", -4.2);
EXPECT_PRINTF("+00042", "%00+6d", 42);
2014-06-06 18:07:57 +04:00
EXPECT_PRINTF(" 42", "%05.d", 42);
EXPECT_PRINTF(" 0042", "%05.4d", 42);
2014-06-09 18:40:51 +04:00
// '0' flag is ignored for non-numeric types.
EXPECT_PRINTF(" x", "%05c", 'x');
2014-06-06 18:07:57 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, plus_flag) {
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF("+42", "%+d", 42);
EXPECT_PRINTF("-42", "%+d", -42);
EXPECT_PRINTF("+0042", "%+05d", 42);
EXPECT_PRINTF("+0042", "%0++5d", 42);
2014-06-10 17:21:41 +04:00
// '+' flag is ignored for non-numeric types.
EXPECT_PRINTF("x", "%+c", 'x');
// '+' flag wins over space flag
EXPECT_PRINTF("+42", "%+ d", 42);
EXPECT_PRINTF("-42", "%+ d", -42);
EXPECT_PRINTF("+42", "% +d", 42);
EXPECT_PRINTF("-42", "% +d", -42);
EXPECT_PRINTF("+0042", "% +05d", 42);
EXPECT_PRINTF("+0042", "%0+ 5d", 42);
// '+' flag and space flag are both ignored for non-numeric types.
EXPECT_PRINTF("x", "%+ c", 'x');
EXPECT_PRINTF("x", "% +c", 'x');
2014-06-09 18:40:51 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, minus_flag) {
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF("abc ", "%-5s", "abc");
EXPECT_PRINTF("abc ", "%0--5s", "abc");
EXPECT_PRINTF("7 ", "%-5d", 7);
EXPECT_PRINTF("97 ", "%-5hhi", 'a');
EXPECT_PRINTF("a ", "%-5c", 'a');
// '0' flag is ignored if '-' flag is given
EXPECT_PRINTF("7 ", "%-05d", 7);
EXPECT_PRINTF("7 ", "%0-5d", 7);
EXPECT_PRINTF("a ", "%-05c", 'a');
EXPECT_PRINTF("a ", "%0-5c", 'a');
EXPECT_PRINTF("97 ", "%-05hhi", 'a');
EXPECT_PRINTF("97 ", "%0-5hhi", 'a');
// '-' and space flag don't interfere
EXPECT_PRINTF(" 42", "%- d", 42);
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, space_flag) {
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF(" 42", "% d", 42);
EXPECT_PRINTF("-42", "% d", -42);
EXPECT_PRINTF(" 0042", "% 05d", 42);
EXPECT_PRINTF(" 0042", "%0 5d", 42);
2014-06-10 17:21:41 +04:00
// ' ' flag is ignored for non-numeric types.
EXPECT_PRINTF("x", "% c", 'x');
2014-06-09 18:40:51 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, hash_flag) {
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF("042", "%#o", 042);
EXPECT_PRINTF(fmt::format("0{:o}", static_cast<unsigned>(-042)), "%#o", -042);
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF("0", "%#o", 0);
EXPECT_PRINTF("0x42", "%#x", 0x42);
EXPECT_PRINTF("0X42", "%#X", 0x42);
2019-01-13 05:27:38 +03:00
EXPECT_PRINTF(fmt::format("0x{:x}", static_cast<unsigned>(-0x42)), "%#x",
-0x42);
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF("0", "%#x", 0);
2014-06-10 17:21:41 +04:00
EXPECT_PRINTF("0x0042", "%#06x", 0x42);
2014-06-09 18:40:51 +04:00
EXPECT_PRINTF("0x0042", "%0##6x", 0x42);
2014-06-10 17:21:41 +04:00
EXPECT_PRINTF("-42.000000", "%#f", -42.0);
EXPECT_PRINTF("-42.000000", "%#F", -42.0);
2021-05-06 03:43:06 +03:00
char buffer[256];
safe_sprintf(buffer, "%#e", -42.0);
2014-06-10 17:21:41 +04:00
EXPECT_PRINTF(buffer, "%#e", -42.0);
safe_sprintf(buffer, "%#E", -42.0);
2014-06-10 17:21:41 +04:00
EXPECT_PRINTF(buffer, "%#E", -42.0);
2018-10-14 08:14:36 +03:00
EXPECT_PRINTF("-42.0000", "%#g", -42.0);
EXPECT_PRINTF("-42.0000", "%#G", -42.0);
2014-06-10 17:21:41 +04:00
EXPECT_PRINTF("0x1.p+4", "%#a", 16.0);
EXPECT_PRINTF("0X1.P+4", "%#A", 16.0);
2014-06-09 18:40:51 +04:00
2014-06-10 17:21:41 +04:00
// '#' flag is ignored for non-numeric types.
EXPECT_PRINTF("x", "%#c", 'x');
2014-06-09 18:40:51 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, width) {
2014-06-20 18:34:02 +04:00
EXPECT_PRINTF(" abc", "%5s", "abc");
// Width cannot be specified twice.
2018-12-06 17:04:45 +03:00
EXPECT_THROW_MSG(test_sprintf("%5-5d", 42), format_error,
2022-12-30 21:20:07 +03:00
"invalid format specifier");
2014-06-20 18:34:02 +04:00
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%{}d", big_num), 42), format_error,
2019-01-13 05:27:38 +03:00
"number is too big");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf(format("%1${}d", big_num), 42), format_error,
2019-01-13 05:27:38 +03:00
"number is too big");
2014-06-20 18:34:02 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, dynamic_width) {
2018-12-06 17:04:45 +03:00
EXPECT_EQ(" 42", test_sprintf("%*d", 5, 42));
EXPECT_EQ("42 ", test_sprintf("%*d", -5, 42));
EXPECT_THROW_MSG(test_sprintf("%*d", 5.0, 42), format_error,
2019-01-13 05:27:38 +03:00
"width is not integer");
2020-05-08 01:59:46 +03:00
EXPECT_THROW_MSG(test_sprintf("%*d"), format_error, "argument not found");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf("%*d", big_num, 42), format_error,
2019-01-13 05:27:38 +03:00
"number is too big");
2014-06-20 18:34:02 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, int_precision) {
2014-06-20 18:34:02 +04:00
EXPECT_PRINTF("00042", "%.5d", 42);
2014-06-20 19:04:44 +04:00
EXPECT_PRINTF("-00042", "%.5d", -42);
2014-06-20 18:59:23 +04:00
EXPECT_PRINTF("00042", "%.5x", 0x42);
EXPECT_PRINTF("0x00042", "%#.5x", 0x42);
EXPECT_PRINTF("00042", "%.5o", 042);
EXPECT_PRINTF("00042", "%#.5o", 042);
EXPECT_PRINTF(" 00042", "%7.5d", 42);
EXPECT_PRINTF(" 00042", "%7.5x", 0x42);
EXPECT_PRINTF(" 0x00042", "%#10.5x", 0x42);
EXPECT_PRINTF(" 00042", "%7.5o", 042);
EXPECT_PRINTF(" 00042", "%#10.5o", 042);
EXPECT_PRINTF("00042 ", "%-7.5d", 42);
EXPECT_PRINTF("00042 ", "%-7.5x", 0x42);
EXPECT_PRINTF("0x00042 ", "%-#10.5x", 0x42);
EXPECT_PRINTF("00042 ", "%-7.5o", 042);
EXPECT_PRINTF("00042 ", "%-#10.5o", 042);
2014-06-20 18:34:02 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, float_precision) {
2021-05-06 03:43:06 +03:00
char buffer[256];
safe_sprintf(buffer, "%.3e", 1234.5678);
2014-06-23 18:07:10 +04:00
EXPECT_PRINTF(buffer, "%.3e", 1234.5678);
EXPECT_PRINTF("1234.568", "%.3f", 1234.5678);
2019-03-16 22:17:35 +03:00
EXPECT_PRINTF("1.23e+03", "%.3g", 1234.5678);
safe_sprintf(buffer, "%.3a", 1234.5678);
2014-06-23 18:07:10 +04:00
EXPECT_PRINTF(buffer, "%.3a", 1234.5678);
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, string_precision) {
char test[] = {'H', 'e', 'l', 'l', 'o'};
EXPECT_EQ(fmt::sprintf("%.4s", test), "Hell");
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, ignore_precision_for_non_numeric_arg) {
2014-06-23 18:07:10 +04:00
EXPECT_PRINTF("abc", "%.5s", "abc");
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, dynamic_precision) {
2018-12-06 17:04:45 +03:00
EXPECT_EQ("00042", test_sprintf("%.*d", 5, 42));
EXPECT_EQ("42", test_sprintf("%.*d", -5, 42));
EXPECT_THROW_MSG(test_sprintf("%.*d", 5.0, 42), format_error,
2019-01-13 05:27:38 +03:00
"precision is not integer");
2020-05-08 01:59:46 +03:00
EXPECT_THROW_MSG(test_sprintf("%.*d"), format_error, "argument not found");
2021-05-05 02:54:20 +03:00
EXPECT_THROW_MSG(test_sprintf("%.*d", big_num, 42), format_error,
2019-01-13 05:27:38 +03:00
"number is too big");
2017-08-26 19:09:43 +03:00
if (sizeof(long long) != sizeof(int)) {
long long prec = static_cast<long long>(INT_MIN) - 1;
2018-12-06 17:04:45 +03:00
EXPECT_THROW_MSG(test_sprintf("%.*d", prec, 42), format_error,
2019-01-13 05:27:38 +03:00
"number is too big");
}
2014-06-23 18:16:46 +04:00
}
2024-01-14 17:34:25 +03:00
template <typename T> struct make_signed {
using type = T;
};
2014-08-06 19:21:12 +04:00
2024-01-14 17:34:25 +03:00
#define SPECIALIZE_MAKE_SIGNED(T, S) \
template <> struct make_signed<T> { \
using type = S; \
}
2014-08-06 19:21:12 +04:00
SPECIALIZE_MAKE_SIGNED(char, signed char);
SPECIALIZE_MAKE_SIGNED(unsigned char, signed char);
SPECIALIZE_MAKE_SIGNED(unsigned short, short);
SPECIALIZE_MAKE_SIGNED(unsigned, int);
SPECIALIZE_MAKE_SIGNED(unsigned long, long);
2017-08-26 19:09:43 +03:00
SPECIALIZE_MAKE_SIGNED(unsigned long long, long long);
2014-08-06 19:21:12 +04:00
// Test length format specifier ``length_spec``.
2014-08-05 18:52:59 +04:00
template <typename T, typename U>
2021-05-05 02:54:20 +03:00
void test_length(const char* length_spec, U value) {
2017-08-26 19:09:43 +03:00
long long signed_value = 0;
unsigned long long unsigned_value = 0;
2014-08-12 19:15:39 +04:00
// Apply integer promotion to the argument.
2019-09-08 19:04:09 +03:00
unsigned long long max = max_value<U>();
2020-05-10 17:25:42 +03:00
using fmt::detail::const_check;
2019-09-08 19:04:09 +03:00
if (const_check(max <= static_cast<unsigned>(max_value<int>()))) {
2014-08-12 19:15:39 +04:00
signed_value = static_cast<int>(value);
unsigned_value = static_cast<unsigned long long>(value);
2019-09-08 19:04:09 +03:00
} else if (const_check(max <= max_value<unsigned>())) {
2014-08-12 19:15:39 +04:00
signed_value = static_cast<unsigned>(value);
unsigned_value = static_cast<unsigned long long>(value);
2014-08-12 19:15:39 +04:00
}
if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
2017-08-26 19:09:43 +03:00
signed_value = static_cast<long long>(value);
unsigned_value = static_cast<unsigned long long>(
static_cast<typename std::make_unsigned<unsigned>::type>(value));
2014-08-12 19:15:39 +04:00
} else {
2017-02-19 17:46:51 +03:00
signed_value = static_cast<typename make_signed<T>::type>(value);
unsigned_value = static_cast<typename std::make_unsigned<T>::type>(value);
2014-08-12 19:15:39 +04:00
}
std::ostringstream os;
2014-08-12 19:15:39 +04:00
os << signed_value;
EXPECT_PRINTF(os.str(), fmt::format("%{}d", length_spec), value);
EXPECT_PRINTF(os.str(), fmt::format("%{}i", length_spec), value);
os.str("");
os << unsigned_value;
EXPECT_PRINTF(os.str(), fmt::format("%{}u", length_spec), value);
os.str("");
os << std::oct << unsigned_value;
EXPECT_PRINTF(os.str(), fmt::format("%{}o", length_spec), value);
os.str("");
os << std::hex << unsigned_value;
EXPECT_PRINTF(os.str(), fmt::format("%{}x", length_spec), value);
os.str("");
os << std::hex << std::uppercase << unsigned_value;
EXPECT_PRINTF(os.str(), fmt::format("%{}X", length_spec), value);
}
2021-05-05 02:54:20 +03:00
template <typename T> void test_length(const char* length_spec) {
2019-09-08 19:04:09 +03:00
T min = std::numeric_limits<T>::min(), max = max_value<T>();
2021-05-05 02:54:20 +03:00
test_length<T>(length_spec, 42);
test_length<T>(length_spec, -42);
test_length<T>(length_spec, min);
test_length<T>(length_spec, max);
long long long_long_min = std::numeric_limits<long long>::min();
if (static_cast<long long>(min) > long_long_min)
2021-05-05 02:54:20 +03:00
test_length<T>(length_spec, static_cast<long long>(min) - 1);
2019-09-08 19:04:09 +03:00
unsigned long long long_long_max = max_value<long long>();
2017-08-26 19:09:43 +03:00
if (static_cast<unsigned long long>(max) < long_long_max)
2021-05-05 02:54:20 +03:00
test_length<T>(length_spec, static_cast<long long>(max) + 1);
test_length<T>(length_spec, std::numeric_limits<short>::min());
test_length<T>(length_spec, max_value<unsigned short>());
test_length<T>(length_spec, std::numeric_limits<int>::min());
test_length<T>(length_spec, max_value<int>());
test_length<T>(length_spec, std::numeric_limits<unsigned>::min());
test_length<T>(length_spec, max_value<unsigned>());
test_length<T>(length_spec, std::numeric_limits<long long>::min());
test_length<T>(length_spec, max_value<long long>());
test_length<T>(length_spec, std::numeric_limits<unsigned long long>::min());
test_length<T>(length_spec, max_value<unsigned long long>());
}
TEST(printf_test, length) {
test_length<char>("hh");
test_length<signed char>("hh");
test_length<unsigned char>("hh");
test_length<short>("h");
test_length<unsigned short>("h");
test_length<long>("l");
test_length<unsigned long>("l");
test_length<long long>("ll");
test_length<unsigned long long>("ll");
test_length<intmax_t>("j");
test_length<size_t>("z");
test_length<std::ptrdiff_t>("t");
2019-09-08 19:04:09 +03:00
long double max = max_value<long double>();
EXPECT_PRINTF(fmt::format("{:.6}", max), "%g", max);
EXPECT_PRINTF(fmt::format("{:.6}", max), "%Lg", max);
2014-08-19 19:14:21 +04:00
}
2023-01-02 19:20:49 +03:00
TEST(printf_test, bool) { EXPECT_PRINTF("1", "%d", true); }
2021-05-05 02:54:20 +03:00
TEST(printf_test, int) {
EXPECT_PRINTF("-42", "%d", -42);
EXPECT_PRINTF("-42", "%i", -42);
2016-03-19 16:39:33 +03:00
unsigned u = 0 - 42u;
EXPECT_PRINTF(fmt::format("{}", u), "%u", -42);
EXPECT_PRINTF(fmt::format("{:o}", u), "%o", -42);
EXPECT_PRINTF(fmt::format("{:x}", u), "%x", -42);
EXPECT_PRINTF(fmt::format("{:X}", u), "%X", -42);
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, long_long) {
// fmt::printf allows passing long long arguments to %d without length
// specifiers.
2019-09-08 19:04:09 +03:00
long long max = max_value<long long>();
EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, float) {
2014-08-20 19:21:06 +04:00
EXPECT_PRINTF("392.650000", "%f", 392.65);
EXPECT_PRINTF("392.65", "%.2f", 392.65);
EXPECT_PRINTF("392.6", "%.1f", 392.65);
EXPECT_PRINTF("393", "%.f", 392.65);
2014-08-20 19:21:06 +04:00
EXPECT_PRINTF("392.650000", "%F", 392.65);
2021-05-06 03:43:06 +03:00
char buffer[256];
2014-08-20 19:21:06 +04:00
safe_sprintf(buffer, "%e", 392.65);
EXPECT_PRINTF(buffer, "%e", 392.65);
safe_sprintf(buffer, "%E", 392.65);
EXPECT_PRINTF(buffer, "%E", 392.65);
EXPECT_PRINTF("392.65", "%g", 392.65);
EXPECT_PRINTF("392.65", "%G", 392.65);
EXPECT_PRINTF("392", "%g", 392.0);
EXPECT_PRINTF("392", "%G", 392.0);
EXPECT_PRINTF("4.56e-07", "%g", 0.000000456);
2014-08-21 18:14:02 +04:00
safe_sprintf(buffer, "%a", -392.65);
EXPECT_EQ(buffer, format("{:a}", -392.65));
safe_sprintf(buffer, "%A", -392.65);
EXPECT_EQ(buffer, format("{:A}", -392.65));
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, inf) {
2014-08-21 18:14:02 +04:00
double inf = std::numeric_limits<double>::infinity();
for (const char* type = "fega"; *type; ++type) {
EXPECT_PRINTF("inf", fmt::format("%{}", *type), inf);
char upper = static_cast<char>(std::toupper(*type));
2014-08-21 18:14:02 +04:00
EXPECT_PRINTF("INF", fmt::format("%{}", upper), inf);
}
2014-08-20 19:21:06 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, char) {
2014-08-19 19:14:21 +04:00
EXPECT_PRINTF("x", "%c", 'x');
2019-09-08 19:04:09 +03:00
int max = max_value<int>();
2014-08-19 19:14:21 +04:00
EXPECT_PRINTF(fmt::format("{}", static_cast<char>(max)), "%c", max);
2019-01-13 05:27:38 +03:00
// EXPECT_PRINTF("x", "%lc", L'x');
EXPECT_PRINTF(L"x", L"%c", L'x');
EXPECT_PRINTF(fmt::format(L"{}", static_cast<wchar_t>(max)), L"%c", max);
2014-06-29 02:58:02 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, string) {
2014-08-21 18:14:02 +04:00
EXPECT_PRINTF("abc", "%s", "abc");
const char* null_str = nullptr;
EXPECT_PRINTF("(null)", "%s", null_str);
EXPECT_PRINTF(" (null)", "%10s", null_str);
EXPECT_PRINTF(L"abc", L"%s", L"abc");
const wchar_t* null_wstr = nullptr;
EXPECT_PRINTF(L"(null)", L"%s", null_wstr);
EXPECT_PRINTF(L" (null)", L"%10s", null_wstr);
2014-08-20 19:21:06 +04:00
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, pointer) {
2014-08-21 18:14:02 +04:00
int n;
2019-01-13 05:27:38 +03:00
void* p = &n;
2014-08-21 18:14:02 +04:00
EXPECT_PRINTF(fmt::format("{}", p), "%p", p);
p = nullptr;
EXPECT_PRINTF("(nil)", "%p", p);
EXPECT_PRINTF(" (nil)", "%10p", p);
2019-01-13 05:27:38 +03:00
const char* s = "test";
EXPECT_PRINTF(fmt::format("{:p}", s), "%p", s);
const char* null_str = nullptr;
EXPECT_PRINTF("(nil)", "%p", null_str);
p = &n;
EXPECT_PRINTF(fmt::format(L"{}", p), L"%p", p);
p = nullptr;
EXPECT_PRINTF(L"(nil)", L"%p", p);
EXPECT_PRINTF(L" (nil)", L"%10p", p);
2019-01-13 05:27:38 +03:00
const wchar_t* w = L"test";
EXPECT_PRINTF(fmt::format(L"{:p}", w), L"%p", w);
const wchar_t* null_wstr = nullptr;
EXPECT_PRINTF(L"(nil)", L"%p", null_wstr);
2014-08-20 19:21:06 +04:00
}
2020-03-11 18:40:57 +03:00
enum test_enum { answer = 42 };
auto format_as(test_enum e) -> int { return e; }
2021-05-05 02:54:20 +03:00
TEST(printf_test, enum) {
2020-03-11 18:40:57 +03:00
EXPECT_PRINTF("42", "%d", answer);
volatile test_enum volatile_enum = answer;
EXPECT_PRINTF("42", "%d", volatile_enum);
}
2019-11-15 16:41:14 +03:00
#if FMT_USE_FCNTL
2021-05-05 02:54:20 +03:00
TEST(printf_test, examples) {
2019-01-13 05:27:38 +03:00
const char* weekday = "Thursday";
const char* month = "August";
int day = 21;
EXPECT_WRITE(stdout, fmt::printf("%1$s, %3$d %2$s", weekday, month, day),
"Thursday, 21 August");
}
2014-11-14 20:40:01 +03:00
2021-05-05 02:54:20 +03:00
TEST(printf_test, printf_error) {
2024-01-02 00:25:07 +03:00
auto pipe = fmt::pipe();
int result = fmt::fprintf(pipe.read_end.fdopen("r").get(), "test");
2014-11-14 20:40:01 +03:00
EXPECT_LT(result, 0);
}
#endif
2021-05-05 02:54:20 +03:00
TEST(printf_test, wide_string) {
EXPECT_EQ(L"abc", fmt::sprintf(L"%s", L"abc"));
}
2016-08-03 18:52:05 +03:00
2021-05-05 02:54:20 +03:00
TEST(printf_test, vprintf) {
2023-05-11 20:19:56 +03:00
int n = 42;
2024-01-09 07:40:03 +03:00
auto store = fmt::make_format_args<fmt::printf_context>(n);
2023-05-11 20:19:56 +03:00
auto args = fmt::basic_format_args<fmt::printf_context>(store);
2023-05-17 22:34:12 +03:00
EXPECT_EQ(fmt::vsprintf(fmt::string_view("%d"), args), "42");
EXPECT_WRITE(stdout, fmt::vfprintf(stdout, fmt::string_view("%d"), args),
"42");
}
2018-11-04 02:20:45 +03:00
2019-01-13 05:27:38 +03:00
template <typename... Args>
2018-11-04 02:20:45 +03:00
void check_format_string_regression(fmt::string_view s, const Args&... args) {
fmt::sprintf(s, args...);
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, check_format_string_regression) {
2018-11-04 02:20:45 +03:00
check_format_string_regression("%c%s", 'x', "");
}
2021-05-05 02:54:20 +03:00
TEST(printf_test, fixed_large_exponent) {
EXPECT_EQ("1000000000000000000000", fmt::sprintf("%.*f", -13, 1e21));
}
2023-05-11 20:19:56 +03:00
TEST(printf_test, make_printf_args) {
2024-01-11 03:43:00 +03:00
int n = 42;
2019-01-13 05:27:38 +03:00
EXPECT_EQ("[42] something happened",
2023-05-17 22:34:12 +03:00
fmt::vsprintf(fmt::string_view("[%d] %s happened"),
2024-01-11 03:43:00 +03:00
{fmt::make_printf_args(n, "something")}));
2019-01-13 05:27:38 +03:00
EXPECT_EQ(L"[42] something happened",
2023-05-17 22:34:12 +03:00
fmt::vsprintf(fmt::basic_string_view<wchar_t>(L"[%d] %s happened"),
2024-01-11 03:43:00 +03:00
{fmt::make_printf_args<wchar_t>(n, L"something")}));
}