2018-03-04 17:16:51 +00:00
|
|
|
// Formatting library for C++ - formatting library tests
|
|
|
|
//
|
|
|
|
// Copyright (c) 2012 - present, Victor Zverovich
|
|
|
|
// All rights reserved.
|
|
|
|
//
|
|
|
|
// For the license information refer to format.h.
|
2012-12-07 17:02:15 +00:00
|
|
|
|
2012-12-12 17:29:32 +00:00
|
|
|
#include <cctype>
|
2012-12-07 17:02:15 +00:00
|
|
|
#include <cfloat>
|
|
|
|
#include <climits>
|
2014-06-06 18:14:53 +00:00
|
|
|
#include <cmath>
|
2012-12-07 17:02:15 +00:00
|
|
|
#include <cstring>
|
2018-01-15 19:30:53 +00:00
|
|
|
#include <list>
|
2012-12-12 04:48:49 +00:00
|
|
|
#include <memory>
|
2014-09-18 16:07:40 +00:00
|
|
|
#include <stdint.h>
|
|
|
|
|
|
|
|
#include "gmock/gmock.h"
|
2013-04-22 14:28:16 +00:00
|
|
|
|
2015-07-07 14:05:17 +00:00
|
|
|
// Test that the library compiles if None is defined to 0 as done by xlib.h.
|
|
|
|
#define None 0
|
|
|
|
|
2018-01-28 00:04:45 +00:00
|
|
|
#include "fmt/format.h"
|
2016-04-25 15:07:27 +00:00
|
|
|
|
2014-08-15 15:40:03 +00:00
|
|
|
#include "util.h"
|
2014-09-29 15:48:16 +00:00
|
|
|
#include "mock-allocator.h"
|
2014-08-15 15:40:03 +00:00
|
|
|
#include "gtest-extra.h"
|
|
|
|
|
2013-09-09 22:17:38 +00:00
|
|
|
#undef min
|
|
|
|
#undef max
|
|
|
|
|
2012-12-07 17:02:15 +00:00
|
|
|
using std::size_t;
|
|
|
|
|
2016-12-30 20:11:27 +00:00
|
|
|
using fmt::basic_writer;
|
2014-06-28 22:58:02 +00:00
|
|
|
using fmt::format;
|
2016-08-25 15:38:07 +00:00
|
|
|
using fmt::format_error;
|
2017-02-18 14:52:52 +00:00
|
|
|
using fmt::string_view;
|
2017-02-18 17:13:12 +00:00
|
|
|
using fmt::memory_buffer;
|
|
|
|
using fmt::wmemory_buffer;
|
2012-12-08 01:48:10 +00:00
|
|
|
|
2014-04-29 15:39:37 +00:00
|
|
|
namespace {
|
|
|
|
|
2015-05-07 14:18:46 +00:00
|
|
|
// Format value using the standard library.
|
|
|
|
template <typename Char, typename T>
|
2015-05-07 14:25:39 +00:00
|
|
|
void std_format(const T &value, std::basic_string<Char> &result) {
|
2015-05-07 14:18:46 +00:00
|
|
|
std::basic_ostringstream<Char> os;
|
|
|
|
os << value;
|
2015-05-07 14:25:39 +00:00
|
|
|
result = os.str();
|
2015-05-07 14:18:46 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#ifdef __MINGW32__
|
|
|
|
// Workaround a bug in formatting long double in MinGW.
|
2015-05-07 14:25:39 +00:00
|
|
|
void std_format(long double value, std::string &result) {
|
2015-05-07 14:18:46 +00:00
|
|
|
char buffer[100];
|
2015-05-07 15:17:30 +00:00
|
|
|
safe_sprintf(buffer, "%Lg", value);
|
2015-05-07 14:25:39 +00:00
|
|
|
result = buffer;
|
2015-05-07 14:18:46 +00:00
|
|
|
}
|
2015-05-08 14:57:43 +00:00
|
|
|
void std_format(long double value, std::wstring &result) {
|
|
|
|
wchar_t buffer[100];
|
|
|
|
swprintf(buffer, L"%Lg", value);
|
|
|
|
result = buffer;
|
|
|
|
}
|
2015-05-07 14:18:46 +00:00
|
|
|
#endif
|
|
|
|
|
2013-09-10 05:21:40 +00:00
|
|
|
// Checks if writing value to BasicWriter<Char> produces the same result
|
|
|
|
// as writing it to std::basic_ostringstream<Char>.
|
|
|
|
template <typename Char, typename T>
|
2014-07-29 14:50:05 +00:00
|
|
|
::testing::AssertionResult check_write(const T &value, const char *type) {
|
2017-02-18 17:13:12 +00:00
|
|
|
fmt::basic_memory_buffer<Char> buffer;
|
2018-02-11 17:23:47 +00:00
|
|
|
typedef fmt::back_insert_range<fmt::internal::basic_buffer<Char>> range;
|
2018-01-14 15:19:23 +00:00
|
|
|
fmt::basic_writer<range> writer(buffer);
|
2017-01-22 15:40:21 +00:00
|
|
|
writer.write(value);
|
2018-01-06 17:09:50 +00:00
|
|
|
std::basic_string<Char> actual = to_string(buffer);
|
2015-05-07 14:25:39 +00:00
|
|
|
std::basic_string<Char> expected;
|
2015-05-07 15:17:30 +00:00
|
|
|
std_format(value, expected);
|
2013-09-10 05:21:40 +00:00
|
|
|
if (expected == actual)
|
|
|
|
return ::testing::AssertionSuccess();
|
|
|
|
return ::testing::AssertionFailure()
|
2014-06-30 13:43:53 +00:00
|
|
|
<< "Value of: (Writer<" << type << ">() << value).str()\n"
|
2013-09-10 05:21:40 +00:00
|
|
|
<< " Actual: " << actual << "\n"
|
|
|
|
<< "Expected: " << expected << "\n";
|
|
|
|
}
|
|
|
|
|
|
|
|
struct AnyWriteChecker {
|
2013-09-09 22:12:51 +00:00
|
|
|
template <typename T>
|
|
|
|
::testing::AssertionResult operator()(const char *, const T &value) const {
|
2014-07-29 14:50:05 +00:00
|
|
|
::testing::AssertionResult result = check_write<char>(value, "char");
|
|
|
|
return result ? check_write<wchar_t>(value, "wchar_t") : result;
|
2013-09-09 22:12:51 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2013-11-08 16:48:45 +00:00
|
|
|
template <typename Char>
|
|
|
|
struct WriteChecker {
|
2013-09-10 05:21:40 +00:00
|
|
|
template <typename T>
|
|
|
|
::testing::AssertionResult operator()(const char *, const T &value) const {
|
2014-07-29 14:50:05 +00:00
|
|
|
return check_write<Char>(value, "char");
|
2013-09-10 05:21:40 +00:00
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
// Checks if writing value to BasicWriter produces the same result
|
|
|
|
// as writing it to std::ostringstream both for char and wchar_t.
|
2013-11-08 16:48:45 +00:00
|
|
|
#define CHECK_WRITE(value) EXPECT_PRED_FORMAT1(AnyWriteChecker(), value)
|
2013-09-10 05:21:40 +00:00
|
|
|
|
2014-01-01 18:02:15 +00:00
|
|
|
#define CHECK_WRITE_CHAR(value) \
|
|
|
|
EXPECT_PRED_FORMAT1(WriteChecker<char>(), value)
|
|
|
|
#define CHECK_WRITE_WCHAR(value) \
|
|
|
|
EXPECT_PRED_FORMAT1(WriteChecker<wchar_t>(), value)
|
2014-07-29 14:50:05 +00:00
|
|
|
} // namespace
|
2014-05-01 15:43:36 +00:00
|
|
|
|
2017-02-18 14:52:52 +00:00
|
|
|
TEST(StringViewTest, Ctor) {
|
|
|
|
EXPECT_STREQ("abc", string_view("abc").data());
|
|
|
|
EXPECT_EQ(3u, string_view("abc").size());
|
2015-06-26 14:43:54 +00:00
|
|
|
|
2017-02-18 14:52:52 +00:00
|
|
|
EXPECT_STREQ("defg", string_view(std::string("defg")).data());
|
|
|
|
EXPECT_EQ(4u, string_view(std::string("defg")).size());
|
2015-06-26 14:43:54 +00:00
|
|
|
}
|
|
|
|
|
2018-02-28 13:09:24 +00:00
|
|
|
// GCC 4.6 doesn't have std::is_copy_*.
|
|
|
|
#if FMT_GCC_VERSION && FMT_GCC_VERSION >= 407
|
2014-09-30 14:30:05 +00:00
|
|
|
TEST(WriterTest, NotCopyConstructible) {
|
2018-01-14 15:19:23 +00:00
|
|
|
EXPECT_FALSE(std::is_copy_constructible<fmt::writer>::value);
|
2014-09-30 14:30:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(WriterTest, NotCopyAssignable) {
|
2018-01-14 15:19:23 +00:00
|
|
|
EXPECT_FALSE(std::is_copy_assignable<fmt::writer>::value);
|
2014-09-30 14:30:05 +00:00
|
|
|
}
|
2018-02-28 13:09:24 +00:00
|
|
|
#endif
|
2014-09-30 14:30:05 +00:00
|
|
|
|
2013-09-08 23:27:12 +00:00
|
|
|
TEST(WriterTest, Data) {
|
2017-02-18 17:13:12 +00:00
|
|
|
memory_buffer buf;
|
2018-01-14 15:19:23 +00:00
|
|
|
fmt::writer w(buf);
|
2017-01-22 15:40:21 +00:00
|
|
|
w.write(42);
|
2018-01-06 17:09:50 +00:00
|
|
|
EXPECT_EQ("42", to_string(buf));
|
2013-09-08 21:18:08 +00:00
|
|
|
}
|
|
|
|
|
2013-02-27 21:17:09 +00:00
|
|
|
TEST(WriterTest, WriteInt) {
|
2013-09-09 22:12:51 +00:00
|
|
|
CHECK_WRITE(42);
|
|
|
|
CHECK_WRITE(-42);
|
|
|
|
CHECK_WRITE(static_cast<short>(12));
|
|
|
|
CHECK_WRITE(34u);
|
|
|
|
CHECK_WRITE(std::numeric_limits<int>::min());
|
|
|
|
CHECK_WRITE(std::numeric_limits<int>::max());
|
|
|
|
CHECK_WRITE(std::numeric_limits<unsigned>::max());
|
|
|
|
}
|
2013-09-08 21:18:08 +00:00
|
|
|
|
2013-09-09 22:12:51 +00:00
|
|
|
TEST(WriterTest, WriteLong) {
|
|
|
|
CHECK_WRITE(56l);
|
|
|
|
CHECK_WRITE(78ul);
|
|
|
|
CHECK_WRITE(std::numeric_limits<long>::min());
|
|
|
|
CHECK_WRITE(std::numeric_limits<long>::max());
|
|
|
|
CHECK_WRITE(std::numeric_limits<unsigned long>::max());
|
2013-02-27 21:17:09 +00:00
|
|
|
}
|
|
|
|
|
2013-09-09 22:12:51 +00:00
|
|
|
TEST(WriterTest, WriteLongLong) {
|
|
|
|
CHECK_WRITE(56ll);
|
|
|
|
CHECK_WRITE(78ull);
|
|
|
|
CHECK_WRITE(std::numeric_limits<long long>::min());
|
|
|
|
CHECK_WRITE(std::numeric_limits<long long>::max());
|
|
|
|
CHECK_WRITE(std::numeric_limits<unsigned long long>::max());
|
|
|
|
}
|
2013-09-08 23:27:12 +00:00
|
|
|
|
|
|
|
TEST(WriterTest, WriteDouble) {
|
2013-09-09 22:12:51 +00:00
|
|
|
CHECK_WRITE(4.2);
|
|
|
|
CHECK_WRITE(-4.2);
|
2014-08-15 13:58:24 +00:00
|
|
|
CHECK_WRITE(std::numeric_limits<double>::min());
|
|
|
|
CHECK_WRITE(std::numeric_limits<double>::max());
|
2014-08-13 14:51:02 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(WriterTest, WriteLongDouble) {
|
2013-09-09 22:12:51 +00:00
|
|
|
CHECK_WRITE(4.2l);
|
2015-05-08 14:57:43 +00:00
|
|
|
CHECK_WRITE_CHAR(-4.2l);
|
|
|
|
std::wstring str;
|
|
|
|
std_format(4.2l, str);
|
|
|
|
if (str[0] != '-')
|
|
|
|
CHECK_WRITE_WCHAR(-4.2l);
|
|
|
|
else
|
|
|
|
fmt::print("warning: long double formatting with std::swprintf is broken");
|
2014-08-15 13:58:24 +00:00
|
|
|
CHECK_WRITE(std::numeric_limits<long double>::min());
|
2014-08-13 14:51:02 +00:00
|
|
|
CHECK_WRITE(std::numeric_limits<long double>::max());
|
2013-09-08 23:27:12 +00:00
|
|
|
}
|
|
|
|
|
2013-12-27 15:26:55 +00:00
|
|
|
TEST(WriterTest, WriteDoubleAtBufferBoundary) {
|
2017-02-18 17:13:12 +00:00
|
|
|
memory_buffer buf;
|
2018-01-14 15:19:23 +00:00
|
|
|
fmt::writer writer(buf);
|
2013-12-27 15:46:02 +00:00
|
|
|
for (int i = 0; i < 100; ++i)
|
2017-01-22 15:40:21 +00:00
|
|
|
writer.write(1.23456789);
|
2013-12-27 15:26:55 +00:00
|
|
|
}
|
|
|
|
|
2014-04-09 15:05:23 +00:00
|
|
|
TEST(WriterTest, WriteDoubleWithFilledBuffer) {
|
2017-02-18 17:13:12 +00:00
|
|
|
memory_buffer buf;
|
2018-01-14 15:19:23 +00:00
|
|
|
fmt::writer writer(buf);
|
2014-04-09 15:05:23 +00:00
|
|
|
// Fill the buffer.
|
2018-03-04 18:33:42 +00:00
|
|
|
for (int i = 0; i < fmt::inline_buffer_size; ++i)
|
2017-01-22 15:40:21 +00:00
|
|
|
writer.write(' ');
|
|
|
|
writer.write(1.2);
|
2018-01-06 17:09:50 +00:00
|
|
|
fmt::string_view sv(buf.data(), buf.size());
|
2018-03-04 18:33:42 +00:00
|
|
|
sv.remove_prefix(fmt::inline_buffer_size);
|
2018-01-06 17:09:50 +00:00
|
|
|
EXPECT_EQ("1.2", sv);
|
2014-04-09 15:05:23 +00:00
|
|
|
}
|
|
|
|
|
2013-09-10 05:21:40 +00:00
|
|
|
TEST(WriterTest, WriteChar) {
|
|
|
|
CHECK_WRITE('a');
|
|
|
|
}
|
|
|
|
|
2013-12-07 16:12:03 +00:00
|
|
|
TEST(WriterTest, WriteWideChar) {
|
2014-01-02 19:30:28 +00:00
|
|
|
CHECK_WRITE_WCHAR(L'a');
|
2013-12-07 16:12:03 +00:00
|
|
|
}
|
|
|
|
|
2013-09-08 23:27:12 +00:00
|
|
|
TEST(WriterTest, WriteString) {
|
2013-09-10 05:21:40 +00:00
|
|
|
CHECK_WRITE_CHAR("abc");
|
2015-06-09 15:20:44 +00:00
|
|
|
CHECK_WRITE_WCHAR("abc");
|
2013-09-10 05:21:40 +00:00
|
|
|
// The following line shouldn't compile:
|
2018-01-06 17:09:50 +00:00
|
|
|
//std::declval<fmt::basic_writer<fmt::buffer>>().write(L"abc");
|
2013-09-10 05:21:40 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(WriterTest, WriteWideString) {
|
|
|
|
CHECK_WRITE_WCHAR(L"abc");
|
|
|
|
// The following line shouldn't compile:
|
2018-01-06 17:09:50 +00:00
|
|
|
//std::declval<fmt::basic_writer<fmt::wbuffer>>().write("abc");
|
2013-09-08 23:27:12 +00:00
|
|
|
}
|
|
|
|
|
2017-02-14 21:29:47 +00:00
|
|
|
TEST(FormatToTest, FormatWithoutArgs) {
|
2018-01-14 22:15:59 +00:00
|
|
|
std::string s;
|
|
|
|
fmt::format_to(std::back_inserter(s), "test");
|
|
|
|
EXPECT_EQ("test", s);
|
2017-02-14 21:29:47 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatToTest, Format) {
|
2018-01-14 22:15:59 +00:00
|
|
|
std::string s;
|
|
|
|
fmt::format_to(std::back_inserter(s), "part{0}", 1);
|
|
|
|
EXPECT_EQ("part1", s);
|
|
|
|
fmt::format_to(std::back_inserter(s), "part{0}", 2);
|
|
|
|
EXPECT_EQ("part1part2", s);
|
2017-02-14 21:29:47 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 23:04:55 +00:00
|
|
|
TEST(FormatterTest, Escape) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("{", format("{{"));
|
|
|
|
EXPECT_EQ("before {", format("before {{"));
|
|
|
|
EXPECT_EQ("{ after", format("{{ after"));
|
|
|
|
EXPECT_EQ("before { after", format("before {{ after"));
|
2012-12-10 23:04:55 +00:00
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("}", format("}}"));
|
|
|
|
EXPECT_EQ("before }", format("before }}"));
|
|
|
|
EXPECT_EQ("} after", format("}} after"));
|
|
|
|
EXPECT_EQ("before } after", format("before }} after"));
|
2012-12-10 23:04:55 +00:00
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("{}", format("{{}}"));
|
|
|
|
EXPECT_EQ("{42}", format("{{{0}}}", 42));
|
2012-12-10 23:04:55 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatterTest, UnmatchedBraces) {
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format("{"), format_error, "invalid format string");
|
|
|
|
EXPECT_THROW_MSG(format("}"), format_error, "unmatched '}' in format string");
|
|
|
|
EXPECT_THROW_MSG(format("{0{}"), format_error, "invalid format string");
|
2012-12-10 23:04:55 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 19:32:39 +00:00
|
|
|
TEST(FormatterTest, NoArgs) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("test", format("test"));
|
2012-12-08 01:48:10 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 19:08:16 +00:00
|
|
|
TEST(FormatterTest, ArgsInDifferentPositions) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0}", 42));
|
|
|
|
EXPECT_EQ("before 42", format("before {0}", 42));
|
|
|
|
EXPECT_EQ("42 after", format("{0} after", 42));
|
|
|
|
EXPECT_EQ("before 42 after", format("before {0} after", 42));
|
|
|
|
EXPECT_EQ("answer = 42", format("{0} = {1}", "answer", 42));
|
|
|
|
EXPECT_EQ("42 is the answer", format("{1} is the {0}", "answer", 42));
|
|
|
|
EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));
|
2012-12-08 01:48:10 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 19:32:39 +00:00
|
|
|
TEST(FormatterTest, ArgErrors) {
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format("{"), format_error, "invalid format string");
|
|
|
|
EXPECT_THROW_MSG(format("{?}"), format_error, "invalid format string");
|
|
|
|
EXPECT_THROW_MSG(format("{0"), format_error, "invalid format string");
|
|
|
|
EXPECT_THROW_MSG(format("{0}"), format_error, "argument index out of range");
|
2012-12-13 23:10:02 +00:00
|
|
|
|
2014-06-29 00:35:57 +00:00
|
|
|
char format_str[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{%u", INT_MAX);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str), format_error, "invalid format string");
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{%u}", INT_MAX);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str), format_error,
|
2014-08-29 14:45:55 +00:00
|
|
|
"argument index out of range");
|
2012-12-13 23:10:02 +00:00
|
|
|
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{%u", INT_MAX + 1u);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str), format_error, "number is too big");
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{%u}", INT_MAX + 1u);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str), format_error, "number is too big");
|
2012-12-09 02:45:35 +00:00
|
|
|
}
|
|
|
|
|
2015-03-24 15:55:40 +00:00
|
|
|
template <int N>
|
|
|
|
struct TestFormat {
|
|
|
|
template <typename... Args>
|
2017-07-19 02:40:48 +00:00
|
|
|
static std::string format(fmt::string_view format_str, const Args & ... args) {
|
2015-03-24 15:55:40 +00:00
|
|
|
return TestFormat<N - 1>::format(format_str, N - 1, args...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
template <>
|
|
|
|
struct TestFormat<0> {
|
|
|
|
template <typename... Args>
|
2017-07-19 02:40:48 +00:00
|
|
|
static std::string format(fmt::string_view format_str, const Args & ... args) {
|
2015-03-24 15:55:40 +00:00
|
|
|
return fmt::format(format_str, args...);
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
|
|
|
TEST(FormatterTest, ManyArgs) {
|
|
|
|
EXPECT_EQ("19", TestFormat<20>::format("{19}"));
|
|
|
|
EXPECT_THROW_MSG(TestFormat<20>::format("{20}"),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "argument index out of range");
|
2015-03-24 15:55:40 +00:00
|
|
|
EXPECT_THROW_MSG(TestFormat<21>::format("{21}"),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "argument index out of range");
|
2018-03-07 15:36:13 +00:00
|
|
|
enum { max_packed_args = fmt::internal::max_packed_args };
|
|
|
|
std::string format_str = fmt::format("{{{}}}", max_packed_args + 1);
|
|
|
|
EXPECT_THROW_MSG(TestFormat<max_packed_args>::format(format_str),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "argument index out of range");
|
2015-03-24 15:55:40 +00:00
|
|
|
}
|
|
|
|
|
2015-06-10 01:32:59 +00:00
|
|
|
TEST(FormatterTest, NamedArg) {
|
2015-06-11 13:14:42 +00:00
|
|
|
EXPECT_EQ("1/a/A", format("{_1}/{a_}/{A_}", fmt::arg("a_", 'a'),
|
|
|
|
fmt::arg("A_", "A"), fmt::arg("_1", 1)));
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format("{a}"), format_error, "argument not found");
|
2015-06-10 01:32:59 +00:00
|
|
|
EXPECT_EQ(" -42", format("{0:{width}}", -42, fmt::arg("width", 4)));
|
|
|
|
EXPECT_EQ("st", format("{0:.{precision}}", "str", fmt::arg("precision", 2)));
|
2017-12-09 16:15:13 +00:00
|
|
|
EXPECT_EQ("1 2", format("{} {two}", 1, fmt::arg("two", 2)));
|
2015-06-10 01:32:59 +00:00
|
|
|
}
|
|
|
|
|
2012-12-27 14:56:55 +00:00
|
|
|
TEST(FormatterTest, AutoArgIndex) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("abc", format("{}{}{}", 'a', 'b', 'c'));
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0}{}", 'a', 'b'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "cannot switch from manual to automatic argument indexing");
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{}{0}", 'a', 'b'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "cannot switch from automatic to manual argument indexing");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("1.2", format("{:.{}}", 1.2345, 2));
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0}:.{}", 1.2345, 2),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "cannot switch from manual to automatic argument indexing");
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{:.{0}}", 1.2345, 2),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "cannot switch from automatic to manual argument indexing");
|
|
|
|
EXPECT_THROW_MSG(format("{}"), format_error, "argument index out of range");
|
2012-12-27 14:56:55 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 19:32:39 +00:00
|
|
|
TEST(FormatterTest, EmptySpecs) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:}", 42));
|
2012-12-09 19:32:39 +00:00
|
|
|
}
|
|
|
|
|
2012-12-22 22:05:56 +00:00
|
|
|
TEST(FormatterTest, LeftAlign) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42 ", format("{0:<4}", 42));
|
|
|
|
EXPECT_EQ("42 ", format("{0:<4o}", 042));
|
|
|
|
EXPECT_EQ("42 ", format("{0:<4x}", 0x42));
|
|
|
|
EXPECT_EQ("-42 ", format("{0:<5}", -42));
|
|
|
|
EXPECT_EQ("42 ", format("{0:<5}", 42u));
|
|
|
|
EXPECT_EQ("-42 ", format("{0:<5}", -42l));
|
|
|
|
EXPECT_EQ("42 ", format("{0:<5}", 42ul));
|
|
|
|
EXPECT_EQ("-42 ", format("{0:<5}", -42ll));
|
|
|
|
EXPECT_EQ("42 ", format("{0:<5}", 42ull));
|
|
|
|
EXPECT_EQ("-42 ", format("{0:<5}", -42.0));
|
|
|
|
EXPECT_EQ("-42 ", format("{0:<5}", -42.0l));
|
|
|
|
EXPECT_EQ("c ", format("{0:<5}", 'c'));
|
|
|
|
EXPECT_EQ("abc ", format("{0:<5}", "abc"));
|
|
|
|
EXPECT_EQ("0xface ", format("{0:<8}", reinterpret_cast<void*>(0xface)));
|
2012-12-21 17:12:04 +00:00
|
|
|
}
|
|
|
|
|
2012-12-23 01:53:13 +00:00
|
|
|
TEST(FormatterTest, RightAlign) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" 42", format("{0:>4}", 42));
|
|
|
|
EXPECT_EQ(" 42", format("{0:>4o}", 042));
|
|
|
|
EXPECT_EQ(" 42", format("{0:>4x}", 0x42));
|
|
|
|
EXPECT_EQ(" -42", format("{0:>5}", -42));
|
|
|
|
EXPECT_EQ(" 42", format("{0:>5}", 42u));
|
|
|
|
EXPECT_EQ(" -42", format("{0:>5}", -42l));
|
|
|
|
EXPECT_EQ(" 42", format("{0:>5}", 42ul));
|
|
|
|
EXPECT_EQ(" -42", format("{0:>5}", -42ll));
|
|
|
|
EXPECT_EQ(" 42", format("{0:>5}", 42ull));
|
|
|
|
EXPECT_EQ(" -42", format("{0:>5}", -42.0));
|
|
|
|
EXPECT_EQ(" -42", format("{0:>5}", -42.0l));
|
|
|
|
EXPECT_EQ(" c", format("{0:>5}", 'c'));
|
|
|
|
EXPECT_EQ(" abc", format("{0:>5}", "abc"));
|
|
|
|
EXPECT_EQ(" 0xface", format("{0:>8}", reinterpret_cast<void*>(0xface)));
|
2012-12-23 01:53:13 +00:00
|
|
|
}
|
|
|
|
|
2012-12-24 16:34:44 +00:00
|
|
|
TEST(FormatterTest, NumericAlign) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" 42", format("{0:=4}", 42));
|
|
|
|
EXPECT_EQ("+ 42", format("{0:=+4}", 42));
|
|
|
|
EXPECT_EQ(" 42", format("{0:=4o}", 042));
|
|
|
|
EXPECT_EQ("+ 42", format("{0:=+4o}", 042));
|
|
|
|
EXPECT_EQ(" 42", format("{0:=4x}", 0x42));
|
|
|
|
EXPECT_EQ("+ 42", format("{0:=+4x}", 0x42));
|
|
|
|
EXPECT_EQ("- 42", format("{0:=5}", -42));
|
|
|
|
EXPECT_EQ(" 42", format("{0:=5}", 42u));
|
|
|
|
EXPECT_EQ("- 42", format("{0:=5}", -42l));
|
|
|
|
EXPECT_EQ(" 42", format("{0:=5}", 42ul));
|
|
|
|
EXPECT_EQ("- 42", format("{0:=5}", -42ll));
|
|
|
|
EXPECT_EQ(" 42", format("{0:=5}", 42ull));
|
|
|
|
EXPECT_EQ("- 42", format("{0:=5}", -42.0));
|
|
|
|
EXPECT_EQ("- 42", format("{0:=5}", -42.0l));
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:=5", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing '}' in format string");
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:=5}", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format specifier for char");
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:=5}", "abc"),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2014-06-28 23:05:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2018-03-12 01:04:42 +00:00
|
|
|
EXPECT_EQ(" 1", fmt::format("{:= }", 1.0));
|
2012-12-24 16:34:44 +00:00
|
|
|
}
|
|
|
|
|
2012-12-25 03:37:50 +00:00
|
|
|
TEST(FormatterTest, CenterAlign) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" 42 ", format("{0:^5}", 42));
|
|
|
|
EXPECT_EQ(" 42 ", format("{0:^5o}", 042));
|
|
|
|
EXPECT_EQ(" 42 ", format("{0:^5x}", 0x42));
|
|
|
|
EXPECT_EQ(" -42 ", format("{0:^5}", -42));
|
|
|
|
EXPECT_EQ(" 42 ", format("{0:^5}", 42u));
|
|
|
|
EXPECT_EQ(" -42 ", format("{0:^5}", -42l));
|
|
|
|
EXPECT_EQ(" 42 ", format("{0:^5}", 42ul));
|
|
|
|
EXPECT_EQ(" -42 ", format("{0:^5}", -42ll));
|
|
|
|
EXPECT_EQ(" 42 ", format("{0:^5}", 42ull));
|
|
|
|
EXPECT_EQ(" -42 ", format("{0:^6}", -42.0));
|
|
|
|
EXPECT_EQ(" -42 ", format("{0:^5}", -42.0l));
|
|
|
|
EXPECT_EQ(" c ", format("{0:^5}", 'c'));
|
|
|
|
EXPECT_EQ(" abc ", format("{0:^6}", "abc"));
|
|
|
|
EXPECT_EQ(" 0xface ", format("{0:^8}", reinterpret_cast<void*>(0xface)));
|
2012-12-25 03:37:50 +00:00
|
|
|
}
|
|
|
|
|
2012-12-21 04:10:55 +00:00
|
|
|
TEST(FormatterTest, Fill) {
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{<5}", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid fill character '{'");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{<5}}", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid fill character '{'");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("**42", format("{0:*>4}", 42));
|
|
|
|
EXPECT_EQ("**-42", format("{0:*>5}", -42));
|
|
|
|
EXPECT_EQ("***42", format("{0:*>5}", 42u));
|
|
|
|
EXPECT_EQ("**-42", format("{0:*>5}", -42l));
|
|
|
|
EXPECT_EQ("***42", format("{0:*>5}", 42ul));
|
|
|
|
EXPECT_EQ("**-42", format("{0:*>5}", -42ll));
|
|
|
|
EXPECT_EQ("***42", format("{0:*>5}", 42ull));
|
|
|
|
EXPECT_EQ("**-42", format("{0:*>5}", -42.0));
|
|
|
|
EXPECT_EQ("**-42", format("{0:*>5}", -42.0l));
|
|
|
|
EXPECT_EQ("c****", format("{0:*<5}", 'c'));
|
|
|
|
EXPECT_EQ("abc**", format("{0:*<5}", "abc"));
|
|
|
|
EXPECT_EQ("**0xface", format("{0:*>8}", reinterpret_cast<void*>(0xface)));
|
2012-12-21 04:10:55 +00:00
|
|
|
}
|
|
|
|
|
2012-12-25 21:25:14 +00:00
|
|
|
TEST(FormatterTest, PlusSign) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("+42", format("{0:+}", 42));
|
|
|
|
EXPECT_EQ("-42", format("{0:+}", -42));
|
|
|
|
EXPECT_EQ("+42", format("{0:+}", 42));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:+}", 42u),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("+42", format("{0:+}", 42l));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:+}", 42ul),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("+42", format("{0:+}", 42ll));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:+}", 42ull),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("+42", format("{0:+}", 42.0));
|
|
|
|
EXPECT_EQ("+42", format("{0:+}", 42.0l));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:+", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing '}' in format string");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:+}", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format specifier for char");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:+}", "abc"),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2012-12-09 02:45:35 +00:00
|
|
|
}
|
|
|
|
|
2012-12-25 21:25:14 +00:00
|
|
|
TEST(FormatterTest, MinusSign) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:-}", 42));
|
|
|
|
EXPECT_EQ("-42", format("{0:-}", -42));
|
|
|
|
EXPECT_EQ("42", format("{0:-}", 42));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:-}", 42u),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:-}", 42l));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:-}", 42ul),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:-}", 42ll));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:-}", 42ull),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:-}", 42.0));
|
|
|
|
EXPECT_EQ("42", format("{0:-}", 42.0l));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:-", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing '}' in format string");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:-}", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format specifier for char");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:-}", "abc"),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2012-12-25 21:25:14 +00:00
|
|
|
}
|
|
|
|
|
2012-12-25 21:45:12 +00:00
|
|
|
TEST(FormatterTest, SpaceSign) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" 42", format("{0: }", 42));
|
|
|
|
EXPECT_EQ("-42", format("{0: }", -42));
|
|
|
|
EXPECT_EQ(" 42", format("{0: }", 42));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0: }", 42u),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" 42", format("{0: }", 42l));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0: }", 42ul),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" 42", format("{0: }", 42ll));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0: }", 42ull),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires signed argument");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" 42", format("{0: }", 42.0));
|
|
|
|
EXPECT_EQ(" 42", format("{0: }", 42.0l));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0: ", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing '}' in format string");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0: }", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format specifier for char");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0: }", "abc"),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2012-12-25 21:45:12 +00:00
|
|
|
}
|
|
|
|
|
2012-12-26 02:19:51 +00:00
|
|
|
TEST(FormatterTest, HashFlag) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:#}", 42));
|
|
|
|
EXPECT_EQ("-42", format("{0:#}", -42));
|
|
|
|
EXPECT_EQ("0b101010", format("{0:#b}", 42));
|
|
|
|
EXPECT_EQ("0B101010", format("{0:#B}", 42));
|
|
|
|
EXPECT_EQ("-0b101010", format("{0:#b}", -42));
|
|
|
|
EXPECT_EQ("0x42", format("{0:#x}", 0x42));
|
|
|
|
EXPECT_EQ("0X42", format("{0:#X}", 0x42));
|
|
|
|
EXPECT_EQ("-0x42", format("{0:#x}", -0x42));
|
|
|
|
EXPECT_EQ("042", format("{0:#o}", 042));
|
|
|
|
EXPECT_EQ("-042", format("{0:#o}", -042));
|
|
|
|
EXPECT_EQ("42", format("{0:#}", 42u));
|
|
|
|
EXPECT_EQ("0x42", format("{0:#x}", 0x42u));
|
|
|
|
EXPECT_EQ("042", format("{0:#o}", 042u));
|
|
|
|
|
|
|
|
EXPECT_EQ("-42", format("{0:#}", -42l));
|
|
|
|
EXPECT_EQ("0x42", format("{0:#x}", 0x42l));
|
|
|
|
EXPECT_EQ("-0x42", format("{0:#x}", -0x42l));
|
|
|
|
EXPECT_EQ("042", format("{0:#o}", 042l));
|
|
|
|
EXPECT_EQ("-042", format("{0:#o}", -042l));
|
|
|
|
EXPECT_EQ("42", format("{0:#}", 42ul));
|
|
|
|
EXPECT_EQ("0x42", format("{0:#x}", 0x42ul));
|
|
|
|
EXPECT_EQ("042", format("{0:#o}", 042ul));
|
|
|
|
|
|
|
|
EXPECT_EQ("-42", format("{0:#}", -42ll));
|
|
|
|
EXPECT_EQ("0x42", format("{0:#x}", 0x42ll));
|
|
|
|
EXPECT_EQ("-0x42", format("{0:#x}", -0x42ll));
|
|
|
|
EXPECT_EQ("042", format("{0:#o}", 042ll));
|
|
|
|
EXPECT_EQ("-042", format("{0:#o}", -042ll));
|
|
|
|
EXPECT_EQ("42", format("{0:#}", 42ull));
|
|
|
|
EXPECT_EQ("0x42", format("{0:#x}", 0x42ull));
|
|
|
|
EXPECT_EQ("042", format("{0:#o}", 042ull));
|
|
|
|
|
|
|
|
EXPECT_EQ("-42.0000", format("{0:#}", -42.0));
|
|
|
|
EXPECT_EQ("-42.0000", format("{0:#}", -42.0l));
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:#", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing '}' in format string");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:#}", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format specifier for char");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:#}", "abc"),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2012-12-26 02:19:51 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 19:32:39 +00:00
|
|
|
TEST(FormatterTest, ZeroFlag) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:0}", 42));
|
|
|
|
EXPECT_EQ("-0042", format("{0:05}", -42));
|
|
|
|
EXPECT_EQ("00042", format("{0:05}", 42u));
|
|
|
|
EXPECT_EQ("-0042", format("{0:05}", -42l));
|
|
|
|
EXPECT_EQ("00042", format("{0:05}", 42ul));
|
|
|
|
EXPECT_EQ("-0042", format("{0:05}", -42ll));
|
|
|
|
EXPECT_EQ("00042", format("{0:05}", 42ull));
|
|
|
|
EXPECT_EQ("-0042", format("{0:05}", -42.0));
|
|
|
|
EXPECT_EQ("-0042", format("{0:05}", -42.0l));
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:0", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing '}' in format string");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:05}", 'c'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format specifier for char");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:05}", "abc"),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2012-12-07 17:02:15 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 19:32:39 +00:00
|
|
|
TEST(FormatterTest, Width) {
|
2014-06-28 22:58:02 +00:00
|
|
|
char format_str[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:%u", UINT_MAX);
|
|
|
|
increment(format_str + 3);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2014-06-28 22:58:02 +00:00
|
|
|
std::size_t size = std::strlen(format_str);
|
|
|
|
format_str[size] = '}';
|
|
|
|
format_str[size + 1] = 0;
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2012-12-13 23:10:02 +00:00
|
|
|
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:%u", INT_MAX + 1u);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:%u}", INT_MAX + 1u);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(" -42", format("{0:4}", -42));
|
|
|
|
EXPECT_EQ(" 42", format("{0:5}", 42u));
|
|
|
|
EXPECT_EQ(" -42", format("{0:6}", -42l));
|
|
|
|
EXPECT_EQ(" 42", format("{0:7}", 42ul));
|
|
|
|
EXPECT_EQ(" -42", format("{0:6}", -42ll));
|
|
|
|
EXPECT_EQ(" 42", format("{0:7}", 42ull));
|
|
|
|
EXPECT_EQ(" -1.23", format("{0:8}", -1.23));
|
|
|
|
EXPECT_EQ(" -1.23", format("{0:9}", -1.23l));
|
|
|
|
EXPECT_EQ(" 0xcafe", format("{0:10}", reinterpret_cast<void*>(0xcafe)));
|
|
|
|
EXPECT_EQ("x ", format("{0:11}", 'x'));
|
|
|
|
EXPECT_EQ("str ", format("{0:12}", "str"));
|
2012-12-07 17:02:15 +00:00
|
|
|
}
|
|
|
|
|
2015-06-04 05:59:37 +00:00
|
|
|
TEST(FormatterTest, RuntimeWidth) {
|
2015-06-08 13:53:18 +00:00
|
|
|
char format_str[BUFFER_SIZE];
|
|
|
|
safe_sprintf(format_str, "{0:{%u", UINT_MAX);
|
|
|
|
increment(format_str + 4);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2015-06-08 13:53:18 +00:00
|
|
|
std::size_t size = std::strlen(format_str);
|
|
|
|
format_str[size] = '}';
|
|
|
|
format_str[size + 1] = 0;
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2015-06-08 13:53:18 +00:00
|
|
|
format_str[size + 1] = '}';
|
|
|
|
format_str[size + 2] = 0;
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2015-06-04 05:59:37 +00:00
|
|
|
|
2015-06-08 13:53:18 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format string");
|
2015-06-08 13:53:18 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "cannot switch from manual to automatic argument indexing");
|
2015-06-10 01:32:59 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{?}}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format string");
|
2015-06-08 13:53:18 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "argument index out of range");
|
2015-06-08 13:53:18 +00:00
|
|
|
|
|
|
|
EXPECT_THROW_MSG(format("{0:{0:}}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format string");
|
2015-06-08 13:53:18 +00:00
|
|
|
|
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0, -1),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "negative width");
|
2015-06-08 13:53:18 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1u)),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "number is too big");
|
2015-06-08 13:53:18 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0, -1l),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "negative width");
|
2016-07-12 13:40:23 +00:00
|
|
|
if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
|
2015-06-08 13:53:18 +00:00
|
|
|
long value = INT_MAX;
|
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0, (value + 1)),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "number is too big");
|
2015-06-08 13:53:18 +00:00
|
|
|
}
|
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0, (INT_MAX + 1ul)),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "number is too big");
|
2015-06-08 13:53:18 +00:00
|
|
|
|
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0, '0'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "width is not integer");
|
2015-06-08 13:53:18 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{1}}", 0, 0.0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "width is not integer");
|
2015-06-08 13:53:18 +00:00
|
|
|
|
|
|
|
EXPECT_EQ(" -42", format("{0:{1}}", -42, 4));
|
|
|
|
EXPECT_EQ(" 42", format("{0:{1}}", 42u, 5));
|
|
|
|
EXPECT_EQ(" -42", format("{0:{1}}", -42l, 6));
|
|
|
|
EXPECT_EQ(" 42", format("{0:{1}}", 42ul, 7));
|
|
|
|
EXPECT_EQ(" -42", format("{0:{1}}", -42ll, 6));
|
|
|
|
EXPECT_EQ(" 42", format("{0:{1}}", 42ull, 7));
|
|
|
|
EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23, 8));
|
|
|
|
EXPECT_EQ(" -1.23", format("{0:{1}}", -1.23l, 9));
|
2015-06-11 13:14:42 +00:00
|
|
|
EXPECT_EQ(" 0xcafe",
|
|
|
|
format("{0:{1}}", reinterpret_cast<void*>(0xcafe), 10));
|
2015-06-08 13:53:18 +00:00
|
|
|
EXPECT_EQ("x ", format("{0:{1}}", 'x', 11));
|
|
|
|
EXPECT_EQ("str ", format("{0:{1}}", "str", 12));
|
2015-06-04 05:59:37 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 22:13:23 +00:00
|
|
|
TEST(FormatterTest, Precision) {
|
2014-06-28 22:58:02 +00:00
|
|
|
char format_str[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:.%u", UINT_MAX);
|
|
|
|
increment(format_str + 4);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2014-06-28 22:58:02 +00:00
|
|
|
std::size_t size = std::strlen(format_str);
|
|
|
|
format_str[size] = '}';
|
|
|
|
format_str[size + 1] = 0;
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2012-12-09 22:13:23 +00:00
|
|
|
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:.%u", INT_MAX + 1u);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:.%u}", INT_MAX + 1u);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2012-12-09 22:13:23 +00:00
|
|
|
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing precision specifier");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing precision specifier");
|
2012-12-09 22:13:23 +00:00
|
|
|
|
2014-08-27 15:24:31 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2", 0),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2}", 42),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2f}", 42),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2}", 42u),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2f}", 42u),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2}", 42l),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2f}", 42l),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2}", 42ul),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2f}", 42ul),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2}", 42ll),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2f}", 42ll),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2}", 42ull),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2f}", 42ull),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2015-06-11 15:58:31 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:3.0}", 'x'),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("1.2", format("{0:.2}", 1.2345));
|
|
|
|
EXPECT_EQ("1.2", format("{0:.2}", 1.2345l));
|
2012-12-09 22:13:23 +00:00
|
|
|
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2}", reinterpret_cast<void*>(0xcafe)),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.2f}", reinterpret_cast<void*>(0xcafe)),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2012-12-09 22:13:23 +00:00
|
|
|
|
2015-01-08 15:56:08 +00:00
|
|
|
EXPECT_EQ("st", format("{0:.2}", "str"));
|
2012-12-10 19:08:16 +00:00
|
|
|
}
|
|
|
|
|
2012-12-12 23:21:11 +00:00
|
|
|
TEST(FormatterTest, RuntimePrecision) {
|
2014-06-28 22:58:02 +00:00
|
|
|
char format_str[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:.{%u", UINT_MAX);
|
2014-08-27 15:24:31 +00:00
|
|
|
increment(format_str + 5);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2014-06-28 22:58:02 +00:00
|
|
|
std::size_t size = std::strlen(format_str);
|
|
|
|
format_str[size] = '}';
|
|
|
|
format_str[size + 1] = 0;
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2014-06-28 22:58:02 +00:00
|
|
|
format_str[size + 1] = '}';
|
|
|
|
format_str[size + 2] = 0;
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, 0), format_error, "number is too big");
|
2012-12-12 23:21:11 +00:00
|
|
|
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format string");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "cannot switch from manual to automatic argument indexing");
|
2015-06-10 01:32:59 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{?}}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format string");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}", 0, 0),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "argument index out of range");
|
2014-08-29 14:45:55 +00:00
|
|
|
|
|
|
|
EXPECT_THROW_MSG(format("{0:.{0:}}", 0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "invalid format string");
|
2012-12-12 23:21:11 +00:00
|
|
|
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "negative precision");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1u)),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "number is too big");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0, -1l),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "negative precision");
|
2016-07-12 13:40:23 +00:00
|
|
|
if (fmt::internal::const_check(sizeof(long) > sizeof(int))) {
|
2012-12-21 23:02:25 +00:00
|
|
|
long value = INT_MAX;
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0, (value + 1)),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "number is too big");
|
2012-12-12 23:21:11 +00:00
|
|
|
}
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0, (INT_MAX + 1ul)),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "number is too big");
|
2012-12-12 23:21:11 +00:00
|
|
|
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0, '0'),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "precision is not integer");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 0, 0.0),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "precision is not integer");
|
2012-12-12 23:21:11 +00:00
|
|
|
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 42, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}f}", 42, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 42u, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}f}", 42u, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 42l, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}f}", 42l, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 42ul, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}f}", 42ul, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 42ll, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}f}", 42ll, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", 42ull, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-28 22:58:02 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}f}", 42ull, 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2015-06-11 15:58:31 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:3.{1}}", 'x', 0),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("1.2", format("{0:.{1}}", 1.2345, 2));
|
|
|
|
EXPECT_EQ("1.2", format("{1:.{0}}", 2, 1.2345l));
|
2012-12-12 23:21:11 +00:00
|
|
|
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}}", reinterpret_cast<void*>(0xcafe), 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:.{1}f}", reinterpret_cast<void*>(0xcafe), 2),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2015-01-08 15:56:08 +00:00
|
|
|
|
|
|
|
EXPECT_EQ("st", format("{0:.{1}}", "str", 2));
|
2012-12-12 23:21:11 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 21:30:06 +00:00
|
|
|
template <typename T>
|
2017-11-24 15:54:22 +00:00
|
|
|
void check_unknown_types(const T &value, const char *types, const char *) {
|
2017-11-23 18:12:23 +00:00
|
|
|
char format_str[BUFFER_SIZE];
|
2012-12-10 21:30:06 +00:00
|
|
|
const char *special = ".0123456789}";
|
2012-12-16 23:46:06 +00:00
|
|
|
for (int i = CHAR_MIN; i <= CHAR_MAX; ++i) {
|
2015-05-12 15:57:21 +00:00
|
|
|
char c = static_cast<char>(i);
|
2012-12-10 21:30:06 +00:00
|
|
|
if (std::strchr(types, c) || std::strchr(special, c) || !c) continue;
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(format_str, "{0:10%c}", c);
|
2017-11-23 18:12:23 +00:00
|
|
|
const char *message = "invalid type specifier";
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(format(format_str, value), format_error, message)
|
2014-06-29 00:35:57 +00:00
|
|
|
<< format_str << " " << message;
|
2012-12-10 21:30:06 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-11 16:00:06 +00:00
|
|
|
TEST(BoolTest, FormatBool) {
|
|
|
|
EXPECT_EQ("true", format("{}", true));
|
|
|
|
EXPECT_EQ("false", format("{}", false));
|
|
|
|
EXPECT_EQ("1", format("{:d}", true));
|
|
|
|
EXPECT_EQ("true ", format("{:5}", true));
|
|
|
|
EXPECT_EQ(L"true", format(L"{}", true));
|
2014-01-28 20:49:36 +00:00
|
|
|
}
|
|
|
|
|
2013-03-31 14:01:09 +00:00
|
|
|
TEST(FormatterTest, FormatShort) {
|
|
|
|
short s = 42;
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:d}", s));
|
2013-03-31 14:01:09 +00:00
|
|
|
unsigned short us = 42;
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0:d}", us));
|
2013-03-31 14:01:09 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 20:16:02 +00:00
|
|
|
TEST(FormatterTest, FormatInt) {
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:v", 42),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "missing '}' in format string");
|
2016-04-18 02:06:03 +00:00
|
|
|
check_unknown_types(42, "bBdoxXn", "integer");
|
2013-11-14 16:45:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatterTest, FormatBin) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("0", format("{0:b}", 0));
|
|
|
|
EXPECT_EQ("101010", format("{0:b}", 42));
|
|
|
|
EXPECT_EQ("101010", format("{0:b}", 42u));
|
|
|
|
EXPECT_EQ("-101010", format("{0:b}", -42));
|
|
|
|
EXPECT_EQ("11000000111001", format("{0:b}", 12345));
|
|
|
|
EXPECT_EQ("10010001101000101011001111000", format("{0:b}", 0x12345678));
|
|
|
|
EXPECT_EQ("10010000101010111100110111101111", format("{0:b}", 0x90ABCDEF));
|
2013-11-14 16:45:50 +00:00
|
|
|
EXPECT_EQ("11111111111111111111111111111111",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{0:b}", std::numeric_limits<uint32_t>::max()));
|
2012-12-09 22:13:23 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 19:08:16 +00:00
|
|
|
TEST(FormatterTest, FormatDec) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("0", format("{0}", 0));
|
|
|
|
EXPECT_EQ("42", format("{0}", 42));
|
|
|
|
EXPECT_EQ("42", format("{0:d}", 42));
|
|
|
|
EXPECT_EQ("42", format("{0}", 42u));
|
|
|
|
EXPECT_EQ("-42", format("{0}", -42));
|
|
|
|
EXPECT_EQ("12345", format("{0}", 12345));
|
|
|
|
EXPECT_EQ("67890", format("{0}", 67890));
|
2013-02-27 22:45:04 +00:00
|
|
|
char buffer[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%d", INT_MIN);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0}", INT_MIN));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%d", INT_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0}", INT_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%u", UINT_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0}", UINT_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%ld", 0 - static_cast<unsigned long>(LONG_MIN));
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0}", LONG_MIN));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%ld", LONG_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0}", LONG_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%lu", ULONG_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0}", ULONG_MAX));
|
2012-12-10 19:08:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatterTest, FormatHex) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("0", format("{0:x}", 0));
|
|
|
|
EXPECT_EQ("42", format("{0:x}", 0x42));
|
|
|
|
EXPECT_EQ("42", format("{0:x}", 0x42u));
|
|
|
|
EXPECT_EQ("-42", format("{0:x}", -0x42));
|
|
|
|
EXPECT_EQ("12345678", format("{0:x}", 0x12345678));
|
|
|
|
EXPECT_EQ("90abcdef", format("{0:x}", 0x90abcdef));
|
|
|
|
EXPECT_EQ("12345678", format("{0:X}", 0x12345678));
|
|
|
|
EXPECT_EQ("90ABCDEF", format("{0:X}", 0x90ABCDEF));
|
2013-10-24 03:04:32 +00:00
|
|
|
|
2013-02-27 22:45:04 +00:00
|
|
|
char buffer[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "-%x", 0 - static_cast<unsigned>(INT_MIN));
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:x}", INT_MIN));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%x", INT_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:x}", INT_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%x", UINT_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:x}", UINT_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "-%lx", 0 - static_cast<unsigned long>(LONG_MIN));
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:x}", LONG_MIN));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%lx", LONG_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:x}", LONG_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%lx", ULONG_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:x}", ULONG_MAX));
|
2012-12-09 17:03:47 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 19:51:45 +00:00
|
|
|
TEST(FormatterTest, FormatOct) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("0", format("{0:o}", 0));
|
|
|
|
EXPECT_EQ("42", format("{0:o}", 042));
|
|
|
|
EXPECT_EQ("42", format("{0:o}", 042u));
|
|
|
|
EXPECT_EQ("-42", format("{0:o}", -042));
|
|
|
|
EXPECT_EQ("12345670", format("{0:o}", 012345670));
|
2013-02-27 22:45:04 +00:00
|
|
|
char buffer[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "-%o", 0 - static_cast<unsigned>(INT_MIN));
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:o}", INT_MIN));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%o", INT_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:o}", INT_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%o", UINT_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:o}", UINT_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "-%lo", 0 - static_cast<unsigned long>(LONG_MIN));
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:o}", LONG_MIN));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%lo", LONG_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:o}", LONG_MAX));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%lo", ULONG_MAX);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:o}", ULONG_MAX));
|
2012-12-10 19:51:45 +00:00
|
|
|
}
|
|
|
|
|
2016-04-18 02:06:03 +00:00
|
|
|
TEST(FormatterTest, FormatIntLocale) {
|
2016-07-11 13:23:17 +00:00
|
|
|
EXPECT_EQ("123", format("{:n}", 123));
|
2017-03-25 15:20:06 +00:00
|
|
|
EXPECT_EQ("1,234", format("{:n}", 1234));
|
|
|
|
EXPECT_EQ("1,234,567", format("{:n}", 1234567));
|
2016-04-18 02:06:03 +00:00
|
|
|
}
|
|
|
|
|
2018-02-01 23:21:57 +00:00
|
|
|
struct ConvertibleToLongLong {
|
|
|
|
operator long long() const { return 1LL << 32; }
|
|
|
|
};
|
|
|
|
|
|
|
|
TEST(FormatterTest, FormatConvertibleToLongLong) {
|
|
|
|
EXPECT_EQ("100000000", format("{:x}", ConvertibleToLongLong()));
|
|
|
|
}
|
|
|
|
|
2013-03-31 14:01:09 +00:00
|
|
|
TEST(FormatterTest, FormatFloat) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("392.500000", format("{0:f}", 392.5f));
|
2013-03-31 14:01:09 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 20:16:02 +00:00
|
|
|
TEST(FormatterTest, FormatDouble) {
|
2014-07-29 14:50:05 +00:00
|
|
|
check_unknown_types(1.2, "eEfFgGaA", "double");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("0", format("{0:}", 0.0));
|
|
|
|
EXPECT_EQ("0.000000", format("{0:f}", 0.0));
|
|
|
|
EXPECT_EQ("392.65", format("{0:}", 392.65));
|
|
|
|
EXPECT_EQ("392.65", format("{0:g}", 392.65));
|
|
|
|
EXPECT_EQ("392.65", format("{0:G}", 392.65));
|
|
|
|
EXPECT_EQ("392.650000", format("{0:f}", 392.65));
|
|
|
|
EXPECT_EQ("392.650000", format("{0:F}", 392.65));
|
2013-02-27 22:45:04 +00:00
|
|
|
char buffer[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%e", 392.65);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:e}", 392.65));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%E", 392.65);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:E}", 392.65));
|
|
|
|
EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.65));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%a", -42.0);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{:a}", -42.0));
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%A", -42.0);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{:A}", -42.0));
|
2012-12-10 20:16:02 +00:00
|
|
|
}
|
|
|
|
|
2012-12-28 16:27:54 +00:00
|
|
|
TEST(FormatterTest, FormatNaN) {
|
|
|
|
double nan = std::numeric_limits<double>::quiet_NaN();
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("nan", format("{}", nan));
|
|
|
|
EXPECT_EQ("+nan", format("{:+}", nan));
|
|
|
|
EXPECT_EQ(" nan", format("{: }", nan));
|
|
|
|
EXPECT_EQ("NAN", format("{:F}", nan));
|
|
|
|
EXPECT_EQ("nan ", format("{:<7}", nan));
|
|
|
|
EXPECT_EQ(" nan ", format("{:^7}", nan));
|
|
|
|
EXPECT_EQ(" nan", format("{:>7}", nan));
|
2012-12-28 16:27:54 +00:00
|
|
|
}
|
|
|
|
|
2012-12-29 14:44:14 +00:00
|
|
|
TEST(FormatterTest, FormatInfinity) {
|
|
|
|
double inf = std::numeric_limits<double>::infinity();
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("inf", format("{}", inf));
|
|
|
|
EXPECT_EQ("+inf", format("{:+}", inf));
|
|
|
|
EXPECT_EQ("-inf", format("{}", -inf));
|
|
|
|
EXPECT_EQ(" inf", format("{: }", inf));
|
|
|
|
EXPECT_EQ("INF", format("{:F}", inf));
|
|
|
|
EXPECT_EQ("inf ", format("{:<7}", inf));
|
|
|
|
EXPECT_EQ(" inf ", format("{:^7}", inf));
|
|
|
|
EXPECT_EQ(" inf", format("{:>7}", inf));
|
2012-12-29 14:44:14 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 20:16:02 +00:00
|
|
|
TEST(FormatterTest, FormatLongDouble) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("0", format("{0:}", 0.0l));
|
|
|
|
EXPECT_EQ("0.000000", format("{0:f}", 0.0l));
|
|
|
|
EXPECT_EQ("392.65", format("{0:}", 392.65l));
|
|
|
|
EXPECT_EQ("392.65", format("{0:g}", 392.65l));
|
|
|
|
EXPECT_EQ("392.65", format("{0:G}", 392.65l));
|
|
|
|
EXPECT_EQ("392.650000", format("{0:f}", 392.65l));
|
|
|
|
EXPECT_EQ("392.650000", format("{0:F}", 392.65l));
|
2013-02-27 22:45:04 +00:00
|
|
|
char buffer[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%Le", 392.65l);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{0:e}", 392.65l));
|
2015-06-23 14:39:49 +00:00
|
|
|
EXPECT_EQ("+0000392.6", format("{0:+010.4g}", 392.64l));
|
2012-12-10 20:16:02 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 19:32:39 +00:00
|
|
|
TEST(FormatterTest, FormatChar) {
|
2016-04-18 02:06:03 +00:00
|
|
|
const char types[] = "cbBdoxXn";
|
2014-07-29 14:50:05 +00:00
|
|
|
check_unknown_types('a', types, "char");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("a", format("{0}", 'a'));
|
|
|
|
EXPECT_EQ("z", format("{0:c}", 'z'));
|
|
|
|
EXPECT_EQ(L"a", format(L"{0}", 'a'));
|
2014-07-25 14:10:33 +00:00
|
|
|
int n = 'x';
|
|
|
|
for (const char *type = types + 1; *type; ++type) {
|
|
|
|
std::string format_str = fmt::format("{{:{}}}", *type);
|
|
|
|
EXPECT_EQ(fmt::format(format_str, n), fmt::format(format_str, 'x'));
|
|
|
|
}
|
|
|
|
EXPECT_EQ(fmt::format("{:02X}", n), fmt::format("{:02X}", 'x'));
|
2013-12-07 16:12:03 +00:00
|
|
|
}
|
|
|
|
|
2015-11-06 01:46:22 +00:00
|
|
|
TEST(FormatterTest, FormatUnsignedChar) {
|
|
|
|
EXPECT_EQ("42", format("{}", static_cast<unsigned char>(42)));
|
|
|
|
EXPECT_EQ("42", format("{}", static_cast<uint8_t>(42)));
|
|
|
|
}
|
|
|
|
|
2013-12-07 16:12:03 +00:00
|
|
|
TEST(FormatterTest, FormatWChar) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(L"a", format(L"{0}", L'a'));
|
2013-12-07 16:12:03 +00:00
|
|
|
// This shouldn't compile:
|
2014-06-29 00:35:57 +00:00
|
|
|
//format("{}", L'a');
|
2012-12-09 19:32:39 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 21:30:06 +00:00
|
|
|
TEST(FormatterTest, FormatCString) {
|
2015-11-09 15:17:36 +00:00
|
|
|
check_unknown_types("test", "sp", "string");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("test", format("{0}", "test"));
|
|
|
|
EXPECT_EQ("test", format("{0:s}", "test"));
|
2012-12-18 00:39:49 +00:00
|
|
|
char nonconst[] = "nonconst";
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("nonconst", format("{0}", nonconst));
|
2014-06-29 00:35:57 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0}", reinterpret_cast<const char*>(0)),
|
2016-08-25 15:38:07 +00:00
|
|
|
format_error, "string pointer is null");
|
2012-12-09 17:03:47 +00:00
|
|
|
}
|
|
|
|
|
2014-09-30 15:15:56 +00:00
|
|
|
TEST(FormatterTest, FormatSCharString) {
|
|
|
|
signed char str[] = "test";
|
|
|
|
EXPECT_EQ("test", format("{0:s}", str));
|
|
|
|
const signed char *const_str = str;
|
|
|
|
EXPECT_EQ("test", format("{0:s}", const_str));
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatterTest, FormatUCharString) {
|
|
|
|
unsigned char str[] = "test";
|
|
|
|
EXPECT_EQ("test", format("{0:s}", str));
|
|
|
|
const unsigned char *const_str = str;
|
|
|
|
EXPECT_EQ("test", format("{0:s}", const_str));
|
2016-08-23 15:42:25 +00:00
|
|
|
unsigned char *ptr = str;
|
|
|
|
EXPECT_EQ("test", format("{0:s}", ptr));
|
2014-09-30 15:15:56 +00:00
|
|
|
}
|
|
|
|
|
2012-12-10 19:08:16 +00:00
|
|
|
TEST(FormatterTest, FormatPointer) {
|
2014-07-29 14:50:05 +00:00
|
|
|
check_unknown_types(reinterpret_cast<void*>(0x1234), "p", "pointer");
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("0x0", format("{0}", reinterpret_cast<void*>(0)));
|
|
|
|
EXPECT_EQ("0x1234", format("{0}", reinterpret_cast<void*>(0x1234)));
|
|
|
|
EXPECT_EQ("0x1234", format("{0:p}", reinterpret_cast<void*>(0x1234)));
|
2012-12-24 20:28:54 +00:00
|
|
|
EXPECT_EQ("0x" + std::string(sizeof(void*) * CHAR_BIT / 4, 'f'),
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{0}", reinterpret_cast<void*>(~uintptr_t())));
|
2017-08-27 15:41:28 +00:00
|
|
|
EXPECT_EQ("0x1234", format("{}", fmt::ptr(reinterpret_cast<int*>(0x1234))));
|
2018-03-03 22:04:59 +00:00
|
|
|
#if FMT_USE_NULLPTR
|
|
|
|
EXPECT_EQ("0x0", format("{}", FMT_NULL));
|
|
|
|
#endif
|
2012-12-10 21:30:06 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatterTest, FormatString) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("test", format("{0}", std::string("test")));
|
2012-12-10 19:08:16 +00:00
|
|
|
}
|
|
|
|
|
2017-03-26 22:13:10 +00:00
|
|
|
TEST(FormatterTest, FormatStringView) {
|
2018-03-21 16:01:51 +00:00
|
|
|
EXPECT_EQ("test", format("{}", string_view("test")));
|
|
|
|
EXPECT_EQ("", format("{}", string_view()));
|
2013-11-08 16:53:50 +00:00
|
|
|
}
|
|
|
|
|
2018-02-24 18:19:30 +00:00
|
|
|
#ifdef FMT_USE_STD_STRING_VIEW
|
2018-03-26 16:50:22 +00:00
|
|
|
TEST(FormatterTest, FormatStdStringView) {
|
2018-02-24 18:19:30 +00:00
|
|
|
EXPECT_EQ("test", format("{0}", std::string_view("test")));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-02-19 20:25:56 +00:00
|
|
|
struct ConvertibleToStringView {
|
|
|
|
operator fmt::string_view() const { return "foo"; }
|
|
|
|
};
|
|
|
|
|
|
|
|
TEST(FormatterTest, FormatConvertibleToStringView) {
|
|
|
|
EXPECT_EQ("foo", format("{}", ConvertibleToStringView()));
|
|
|
|
}
|
|
|
|
|
2018-05-12 15:33:51 +00:00
|
|
|
FMT_BEGIN_NAMESPACE
|
2017-08-13 20:09:02 +00:00
|
|
|
template <>
|
|
|
|
struct formatter<Date> {
|
2017-09-16 23:50:40 +00:00
|
|
|
template <typename ParseContext>
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
|
2017-11-05 21:18:42 +00:00
|
|
|
auto it = ctx.begin();
|
|
|
|
if (*it == 'd')
|
|
|
|
++it;
|
|
|
|
return it;
|
2017-08-13 20:09:02 +00:00
|
|
|
}
|
|
|
|
|
2018-04-22 16:16:32 +00:00
|
|
|
auto format(const Date &d, format_context &ctx) -> decltype(ctx.out()) {
|
|
|
|
format_to(ctx.out(), "{}-{}-{}", d.year(), d.month(), d.day());
|
|
|
|
return ctx.out();
|
2017-08-13 20:09:02 +00:00
|
|
|
}
|
|
|
|
};
|
2018-05-12 15:33:51 +00:00
|
|
|
FMT_END_NAMESPACE
|
2016-05-06 14:37:20 +00:00
|
|
|
|
|
|
|
TEST(FormatterTest, FormatCustom) {
|
2012-12-10 21:30:06 +00:00
|
|
|
Date date(2012, 12, 9);
|
2016-08-25 15:38:07 +00:00
|
|
|
EXPECT_THROW_MSG(fmt::format("{:s}", date), format_error,
|
2016-11-07 16:55:40 +00:00
|
|
|
"unknown format specifier");
|
2012-12-09 17:03:47 +00:00
|
|
|
}
|
|
|
|
|
2012-12-17 22:56:44 +00:00
|
|
|
class Answer {};
|
|
|
|
|
2018-05-12 15:33:51 +00:00
|
|
|
FMT_BEGIN_NAMESPACE
|
2017-08-13 20:09:02 +00:00
|
|
|
template <>
|
|
|
|
struct formatter<Answer> : formatter<int> {
|
2018-04-22 16:16:32 +00:00
|
|
|
auto format(Answer, fmt::format_context &ctx) -> decltype(ctx.out()) {
|
2018-01-14 19:00:27 +00:00
|
|
|
return formatter<int>::format(42, ctx);
|
2017-08-13 20:09:02 +00:00
|
|
|
}
|
|
|
|
};
|
2018-05-12 15:33:51 +00:00
|
|
|
FMT_END_NAMESPACE
|
2012-12-17 22:56:44 +00:00
|
|
|
|
|
|
|
TEST(FormatterTest, CustomFormat) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{0}", Answer()));
|
2017-07-29 14:50:16 +00:00
|
|
|
EXPECT_EQ("0042", format("{:04}", Answer()));
|
2012-12-17 22:56:44 +00:00
|
|
|
}
|
|
|
|
|
2013-09-05 05:03:37 +00:00
|
|
|
TEST(FormatterTest, WideFormatString) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(L"42", format(L"{}", 42));
|
|
|
|
EXPECT_EQ(L"4.2", format(L"{}", 4.2));
|
|
|
|
EXPECT_EQ(L"abc", format(L"{}", L"abc"));
|
|
|
|
EXPECT_EQ(L"z", format(L"{}", L'z'));
|
2013-09-05 05:03:37 +00:00
|
|
|
}
|
|
|
|
|
2012-12-09 17:03:47 +00:00
|
|
|
TEST(FormatterTest, FormatStringFromSpeedTest) {
|
|
|
|
EXPECT_EQ("1.2340000000:0042:+3.13:str:0x3e8:X:%",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{0:0.10f}:{1:04}:{2:+g}:{3}:{4}:{5}:%",
|
|
|
|
1.234, 42, 3.13, "str", reinterpret_cast<void*>(1000), 'X'));
|
2012-12-07 17:02:15 +00:00
|
|
|
}
|
2012-12-11 04:37:35 +00:00
|
|
|
|
2013-09-05 02:23:55 +00:00
|
|
|
TEST(FormatterTest, FormatExamples) {
|
2014-06-29 18:51:10 +00:00
|
|
|
std::string message = format("The answer is {}", 42);
|
2013-01-12 18:08:51 +00:00
|
|
|
EXPECT_EQ("The answer is 42", message);
|
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("42", format("{}", 42));
|
|
|
|
EXPECT_EQ("42", format(std::string("{}"), 42));
|
2013-01-04 17:14:34 +00:00
|
|
|
|
2017-02-18 17:13:12 +00:00
|
|
|
memory_buffer out;
|
|
|
|
format_to(out, "The answer is {}.", 42);
|
|
|
|
EXPECT_EQ("The answer is 42.", to_string(out));
|
2014-04-30 19:38:17 +00:00
|
|
|
|
2014-05-06 13:58:32 +00:00
|
|
|
const char *filename = "nonexistent";
|
2015-07-08 15:04:32 +00:00
|
|
|
FILE *ftest = safe_fopen(filename, "r");
|
2015-08-04 14:22:03 +00:00
|
|
|
if (ftest) fclose(ftest);
|
2014-05-06 13:58:32 +00:00
|
|
|
int error_code = errno;
|
|
|
|
EXPECT_TRUE(ftest == 0);
|
|
|
|
EXPECT_SYSTEM_ERROR({
|
2015-07-08 15:04:32 +00:00
|
|
|
FILE *f = safe_fopen(filename, "r");
|
2014-04-30 19:39:31 +00:00
|
|
|
if (!f)
|
2017-02-19 16:41:38 +00:00
|
|
|
throw fmt::system_error(errno, "Cannot open file '{}'", filename);
|
2015-08-04 14:22:03 +00:00
|
|
|
fclose(f);
|
2014-05-06 13:58:32 +00:00
|
|
|
}, error_code, "Cannot open file 'nonexistent'");
|
2012-12-11 21:54:53 +00:00
|
|
|
}
|
|
|
|
|
2013-09-07 02:32:19 +00:00
|
|
|
TEST(FormatterTest, Examples) {
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ("First, thou shalt count to three",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("First, thou shalt count to {0}", "three"));
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ("Bring me a shrubbery",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("Bring me a {}", "shrubbery"));
|
|
|
|
EXPECT_EQ("From 1 to 3", format("From {} to {}", 1, 3));
|
2012-12-28 15:18:30 +00:00
|
|
|
|
2013-02-27 22:45:04 +00:00
|
|
|
char buffer[BUFFER_SIZE];
|
2014-07-29 14:50:05 +00:00
|
|
|
safe_sprintf(buffer, "%03.2f", -1.2);
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ(buffer, format("{:03.2f}", -1.2));
|
2012-12-28 15:18:30 +00:00
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("a, b, c", format("{0}, {1}, {2}", 'a', 'b', 'c'));
|
|
|
|
EXPECT_EQ("a, b, c", format("{}, {}, {}", 'a', 'b', 'c'));
|
|
|
|
EXPECT_EQ("c, b, a", format("{2}, {1}, {0}", 'a', 'b', 'c'));
|
|
|
|
EXPECT_EQ("abracadabra", format("{0}{1}{0}", "abra", "cad"));
|
2012-12-28 15:18:30 +00:00
|
|
|
|
|
|
|
EXPECT_EQ("left aligned ",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{:<30}", "left aligned"));
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ(" right aligned",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{:>30}", "right aligned"));
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ(" centered ",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{:^30}", "centered"));
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ("***********centered***********",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{:*^30}", "centered"));
|
2012-12-28 15:18:30 +00:00
|
|
|
|
|
|
|
EXPECT_EQ("+3.140000; -3.140000",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{:+f}; {:+f}", 3.14, -3.14));
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ(" 3.140000; -3.140000",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{: f}; {: f}", 3.14, -3.14));
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ("3.140000; -3.140000",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("{:-f}; {:-f}", 3.14, -3.14));
|
2012-12-28 15:18:30 +00:00
|
|
|
|
|
|
|
EXPECT_EQ("int: 42; hex: 2a; oct: 52",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("int: {0:d}; hex: {0:x}; oct: {0:o}", 42));
|
2012-12-28 15:18:30 +00:00
|
|
|
EXPECT_EQ("int: 42; hex: 0x2a; oct: 052",
|
2014-06-29 18:51:10 +00:00
|
|
|
format("int: {0:d}; hex: {0:#x}; oct: {0:#o}", 42));
|
2012-12-28 15:18:30 +00:00
|
|
|
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("The answer is 42", format("The answer is {}", 42));
|
2014-04-18 01:28:45 +00:00
|
|
|
EXPECT_THROW_MSG(
|
2016-08-25 15:38:07 +00:00
|
|
|
format("The answer is {:d}", "forty-two"), format_error,
|
2017-11-23 18:12:23 +00:00
|
|
|
"invalid type specifier");
|
2014-06-28 21:53:16 +00:00
|
|
|
|
2014-04-29 02:27:41 +00:00
|
|
|
EXPECT_EQ(L"Cyrillic letter \x42e",
|
2014-06-29 18:51:10 +00:00
|
|
|
format(L"Cyrillic letter {}", L'\x42e'));
|
2014-05-14 13:45:39 +00:00
|
|
|
|
|
|
|
EXPECT_WRITE(stdout,
|
2014-06-29 02:59:44 +00:00
|
|
|
fmt::print("{}", std::numeric_limits<double>::infinity()), "inf");
|
2012-12-11 21:54:53 +00:00
|
|
|
}
|
2012-12-16 23:20:01 +00:00
|
|
|
|
2014-02-15 17:39:06 +00:00
|
|
|
TEST(FormatIntTest, Data) {
|
2018-05-19 15:57:31 +00:00
|
|
|
fmt::format_int format_int(42);
|
2014-02-15 17:39:06 +00:00
|
|
|
EXPECT_EQ("42", std::string(format_int.data(), format_int.size()));
|
|
|
|
}
|
|
|
|
|
2013-09-09 22:12:51 +00:00
|
|
|
TEST(FormatIntTest, FormatInt) {
|
2018-05-19 15:57:31 +00:00
|
|
|
EXPECT_EQ("42", fmt::format_int(42).str());
|
|
|
|
EXPECT_EQ(2u, fmt::format_int(42).size());
|
|
|
|
EXPECT_EQ("-42", fmt::format_int(-42).str());
|
|
|
|
EXPECT_EQ(3u, fmt::format_int(-42).size());
|
|
|
|
EXPECT_EQ("42", fmt::format_int(42ul).str());
|
|
|
|
EXPECT_EQ("-42", fmt::format_int(-42l).str());
|
|
|
|
EXPECT_EQ("42", fmt::format_int(42ull).str());
|
|
|
|
EXPECT_EQ("-42", fmt::format_int(-42ll).str());
|
2014-01-30 16:02:06 +00:00
|
|
|
std::ostringstream os;
|
|
|
|
os << std::numeric_limits<int64_t>::max();
|
2015-06-11 13:14:42 +00:00
|
|
|
EXPECT_EQ(os.str(),
|
2018-05-19 15:57:31 +00:00
|
|
|
fmt::format_int(std::numeric_limits<int64_t>::max()).str());
|
2013-09-09 22:12:51 +00:00
|
|
|
}
|
|
|
|
|
2014-02-19 20:43:55 +00:00
|
|
|
template <typename T>
|
2014-07-29 15:45:29 +00:00
|
|
|
std::string format_decimal(T value) {
|
2014-02-14 18:36:17 +00:00
|
|
|
char buffer[10];
|
|
|
|
char *ptr = buffer;
|
2014-07-29 15:45:29 +00:00
|
|
|
fmt::format_decimal(ptr, value);
|
2014-02-19 20:43:55 +00:00
|
|
|
return std::string(buffer, ptr);
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatIntTest, FormatDec) {
|
2015-06-22 14:03:26 +00:00
|
|
|
EXPECT_EQ("-42", format_decimal(static_cast<signed char>(-42)));
|
2014-07-29 15:45:29 +00:00
|
|
|
EXPECT_EQ("-42", format_decimal(static_cast<short>(-42)));
|
2014-02-20 15:04:54 +00:00
|
|
|
std::ostringstream os;
|
|
|
|
os << std::numeric_limits<unsigned short>::max();
|
2014-07-29 15:45:29 +00:00
|
|
|
EXPECT_EQ(os.str(),
|
|
|
|
format_decimal(std::numeric_limits<unsigned short>::max()));
|
|
|
|
EXPECT_EQ("1", format_decimal(1));
|
|
|
|
EXPECT_EQ("-1", format_decimal(-1));
|
|
|
|
EXPECT_EQ("42", format_decimal(42));
|
|
|
|
EXPECT_EQ("-42", format_decimal(-42));
|
|
|
|
EXPECT_EQ("42", format_decimal(42l));
|
|
|
|
EXPECT_EQ("42", format_decimal(42ul));
|
|
|
|
EXPECT_EQ("42", format_decimal(42ll));
|
|
|
|
EXPECT_EQ("42", format_decimal(42ull));
|
2014-02-14 18:36:17 +00:00
|
|
|
}
|
|
|
|
|
2014-05-06 15:05:51 +00:00
|
|
|
TEST(FormatTest, Print) {
|
2014-07-09 13:56:36 +00:00
|
|
|
#if FMT_USE_FILE_DESCRIPTORS
|
2014-06-29 02:59:44 +00:00
|
|
|
EXPECT_WRITE(stdout, fmt::print("Don't {}!", "panic"), "Don't panic!");
|
2014-05-06 15:05:51 +00:00
|
|
|
EXPECT_WRITE(stderr,
|
2014-06-29 04:56:40 +00:00
|
|
|
fmt::print(stderr, "Don't {}!", "panic"), "Don't panic!");
|
2014-07-09 13:56:36 +00:00
|
|
|
#endif
|
2014-05-06 15:05:51 +00:00
|
|
|
}
|
|
|
|
|
2014-07-09 13:56:36 +00:00
|
|
|
#if FMT_USE_FILE_DESCRIPTORS
|
2014-04-28 15:59:29 +00:00
|
|
|
TEST(FormatTest, PrintColored) {
|
2018-03-07 15:36:13 +00:00
|
|
|
EXPECT_WRITE(stdout, fmt::print_colored(fmt::red, "Hello, {}!\n", "world"),
|
2015-02-08 16:08:29 +00:00
|
|
|
"\x1b[31mHello, world!\n\x1b[0m");
|
2014-02-19 21:51:23 +00:00
|
|
|
}
|
2014-04-27 13:56:12 +00:00
|
|
|
#endif
|
|
|
|
|
2014-04-28 15:59:29 +00:00
|
|
|
TEST(FormatTest, Variadic) {
|
2014-06-29 18:51:10 +00:00
|
|
|
EXPECT_EQ("abc1", format("{}c{}", "ab", 1));
|
|
|
|
EXPECT_EQ(L"abc1", format(L"{}c{}", L"ab", 1));
|
2014-04-28 15:59:29 +00:00
|
|
|
}
|
|
|
|
|
2018-01-28 00:04:45 +00:00
|
|
|
TEST(FormatTest, JoinArg) {
|
|
|
|
using fmt::join;
|
|
|
|
int v1[3] = { 1, 2, 3 };
|
|
|
|
std::vector<float> v2;
|
|
|
|
v2.push_back(1.2f);
|
|
|
|
v2.push_back(3.4f);
|
2018-04-30 18:09:40 +00:00
|
|
|
void *v3[2] = { &v1[0], &v1[1] };
|
2018-01-28 00:04:45 +00:00
|
|
|
|
|
|
|
EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, v1 + 3, ", ")));
|
|
|
|
EXPECT_EQ("(1)", format("({})", join(v1, v1 + 1, ", ")));
|
|
|
|
EXPECT_EQ("()", format("({})", join(v1, v1, ", ")));
|
|
|
|
EXPECT_EQ("(001, 002, 003)", format("({:03})", join(v1, v1 + 3, ", ")));
|
|
|
|
EXPECT_EQ("(+01.20, +03.40)",
|
|
|
|
format("({:+06.2f})", join(v2.begin(), v2.end(), ", ")));
|
|
|
|
|
|
|
|
EXPECT_EQ(L"(1, 2, 3)", format(L"({})", join(v1, v1 + 3, L", ")));
|
|
|
|
EXPECT_EQ("1, 2, 3", format("{0:{1}}", join(v1, v1 + 3, ", "), 1));
|
|
|
|
|
2018-04-30 18:09:40 +00:00
|
|
|
EXPECT_EQ(format("{}, {}", v3[0], v3[1]),
|
|
|
|
format("{}", join(v3, v3 + 2, ", ")));
|
|
|
|
|
2018-03-03 22:04:59 +00:00
|
|
|
#if FMT_USE_TRAILING_RETURN && (!FMT_GCC_VERSION || FMT_GCC_VERSION >= 405)
|
2018-01-28 00:04:45 +00:00
|
|
|
EXPECT_EQ("(1, 2, 3)", format("({})", join(v1, ", ")));
|
|
|
|
EXPECT_EQ("(+01.20, +03.40)", format("({:+06.2f})", join(v2, ", ")));
|
|
|
|
#endif
|
|
|
|
}
|
|
|
|
|
2012-12-18 05:13:54 +00:00
|
|
|
template <typename T>
|
|
|
|
std::string str(const T &value) {
|
2014-06-30 13:43:53 +00:00
|
|
|
return fmt::format("{}", value);
|
2012-12-18 05:13:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
TEST(StrTest, Convert) {
|
|
|
|
EXPECT_EQ("42", str(42));
|
|
|
|
std::string s = str(Date(2012, 12, 9));
|
|
|
|
EXPECT_EQ("2012-12-9", s);
|
|
|
|
}
|
2014-06-24 17:14:50 +00:00
|
|
|
|
2017-12-03 15:32:04 +00:00
|
|
|
std::string vformat_message(int id, const char *format, fmt::format_args args) {
|
2017-02-18 17:13:12 +00:00
|
|
|
fmt::memory_buffer buffer;
|
2017-02-14 21:29:47 +00:00
|
|
|
format_to(buffer, "[{}] ", id);
|
|
|
|
vformat_to(buffer, format, args);
|
|
|
|
return to_string(buffer);
|
2014-06-28 18:07:43 +00:00
|
|
|
}
|
|
|
|
|
2016-08-27 00:23:13 +00:00
|
|
|
template <typename... Args>
|
|
|
|
std::string format_message(int id, const char *format, const Args & ... args) {
|
2018-04-08 14:21:26 +00:00
|
|
|
auto va = fmt::make_format_args(args...);
|
2016-08-27 00:23:13 +00:00
|
|
|
return vformat_message(id, format, va);
|
|
|
|
}
|
2014-06-28 18:07:43 +00:00
|
|
|
|
2014-06-28 19:49:51 +00:00
|
|
|
TEST(FormatTest, FormatMessageExample) {
|
|
|
|
EXPECT_EQ("[42] something happened",
|
2014-07-29 14:50:05 +00:00
|
|
|
format_message(42, "{} happened", "something"));
|
2014-06-28 19:49:51 +00:00
|
|
|
}
|
2014-08-15 15:40:13 +00:00
|
|
|
|
2014-08-21 14:30:00 +00:00
|
|
|
template<typename... Args>
|
|
|
|
void print_error(const char *file, int line, const char *format,
|
|
|
|
const Args & ... args) {
|
|
|
|
fmt::print("{}: {}: ", file, line);
|
|
|
|
fmt::print(format, args...);
|
|
|
|
}
|
2014-09-12 04:18:36 +00:00
|
|
|
|
2016-12-23 16:24:48 +00:00
|
|
|
TEST(FormatTest, UnpackedArgs) {
|
|
|
|
EXPECT_EQ("0123456789abcdefg",
|
|
|
|
fmt::format("{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}{}",
|
|
|
|
0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 'a', 'b', 'c', 'd', 'e',
|
|
|
|
'f', 'g'));
|
2014-09-12 04:18:36 +00:00
|
|
|
}
|
2015-09-27 00:26:26 +00:00
|
|
|
|
|
|
|
#if FMT_USE_USER_DEFINED_LITERALS
|
2015-10-09 09:55:36 +00:00
|
|
|
// Passing user-defined literals directly to EXPECT_EQ causes problems
|
|
|
|
// with macro argument stringification (#) on some versions of GCC.
|
|
|
|
// Workaround: Assing the UDL result to a variable before the macro.
|
|
|
|
|
2015-09-27 00:26:26 +00:00
|
|
|
using namespace fmt::literals;
|
|
|
|
|
|
|
|
TEST(LiteralsTest, Format) {
|
2015-10-09 09:55:36 +00:00
|
|
|
auto udl_format = "{}c{}"_format("ab", 1);
|
|
|
|
EXPECT_EQ(format("{}c{}", "ab", 1), udl_format);
|
|
|
|
auto udl_format_w = L"{}c{}"_format(L"ab", 1);
|
|
|
|
EXPECT_EQ(format(L"{}c{}", L"ab", 1), udl_format_w);
|
2015-09-27 00:26:26 +00:00
|
|
|
}
|
2015-09-27 02:09:37 +00:00
|
|
|
|
|
|
|
TEST(LiteralsTest, NamedArg) {
|
2015-10-09 09:55:36 +00:00
|
|
|
auto udl_a = format("{first}{second}{first}{third}",
|
|
|
|
"first"_a="abra", "second"_a="cad", "third"_a=99);
|
2015-09-27 02:09:37 +00:00
|
|
|
EXPECT_EQ(format("{first}{second}{first}{third}",
|
|
|
|
fmt::arg("first", "abra"), fmt::arg("second", "cad"),
|
|
|
|
fmt::arg("third", 99)),
|
2015-10-09 09:55:36 +00:00
|
|
|
udl_a);
|
|
|
|
auto udl_a_w = format(L"{first}{second}{first}{third}",
|
|
|
|
L"first"_a=L"abra", L"second"_a=L"cad", L"third"_a=99);
|
2015-09-27 02:09:37 +00:00
|
|
|
EXPECT_EQ(format(L"{first}{second}{first}{third}",
|
|
|
|
fmt::arg(L"first", L"abra"), fmt::arg(L"second", L"cad"),
|
|
|
|
fmt::arg(L"third", 99)),
|
2015-10-09 09:55:36 +00:00
|
|
|
udl_a_w);
|
2015-09-27 02:09:37 +00:00
|
|
|
}
|
2018-02-28 13:23:25 +00:00
|
|
|
|
|
|
|
TEST(FormatTest, UdlTemplate) {
|
|
|
|
EXPECT_EQ("foo", "foo"_format());
|
|
|
|
EXPECT_EQ(" 42", "{0:10}"_format(42));
|
|
|
|
EXPECT_EQ("42", fmt::format(FMT_STRING("{}"), 42));
|
|
|
|
}
|
2015-09-27 00:26:26 +00:00
|
|
|
#endif // FMT_USE_USER_DEFINED_LITERALS
|
2015-11-24 16:18:19 +00:00
|
|
|
|
2016-05-06 14:37:20 +00:00
|
|
|
enum TestEnum { A };
|
2015-11-24 16:18:19 +00:00
|
|
|
|
|
|
|
TEST(FormatTest, Enum) {
|
|
|
|
EXPECT_EQ("0", fmt::format("{}", A));
|
|
|
|
}
|
2015-11-25 17:49:01 +00:00
|
|
|
|
2018-02-11 14:23:43 +00:00
|
|
|
#if FMT_HAS_FEATURE(cxx_strong_enums)
|
2018-02-10 14:17:42 +00:00
|
|
|
enum TestFixedEnum : short { B };
|
|
|
|
|
|
|
|
TEST(FormatTest, FixedEnum) {
|
|
|
|
EXPECT_EQ("0", fmt::format("{}", B));
|
|
|
|
}
|
|
|
|
#endif
|
|
|
|
|
2018-02-11 17:23:47 +00:00
|
|
|
typedef fmt::back_insert_range<fmt::internal::buffer> buffer_range;
|
2018-01-14 15:19:23 +00:00
|
|
|
|
2018-03-03 22:04:59 +00:00
|
|
|
class mock_arg_formatter:
|
|
|
|
public fmt::internal::function<void>,
|
2018-01-14 15:19:23 +00:00
|
|
|
public fmt::internal::arg_formatter_base<buffer_range> {
|
2016-11-20 16:47:24 +00:00
|
|
|
private:
|
|
|
|
MOCK_METHOD1(call, void (int value));
|
|
|
|
|
2016-03-19 14:20:31 +00:00
|
|
|
public:
|
2018-02-11 17:23:47 +00:00
|
|
|
typedef fmt::internal::arg_formatter_base<buffer_range> base;
|
|
|
|
typedef buffer_range range;
|
2016-03-19 14:20:31 +00:00
|
|
|
|
2018-04-08 14:03:44 +00:00
|
|
|
mock_arg_formatter(fmt::format_context &ctx, fmt::format_specs &s)
|
2018-04-22 16:16:32 +00:00
|
|
|
: base(fmt::internal::get_container(ctx.out()), s) {
|
2016-11-20 16:47:24 +00:00
|
|
|
EXPECT_CALL(*this, call(42));
|
2016-03-19 14:20:31 +00:00
|
|
|
}
|
|
|
|
|
2018-01-13 20:57:27 +00:00
|
|
|
using base::operator();
|
2016-11-20 16:47:24 +00:00
|
|
|
|
2018-03-30 18:20:12 +00:00
|
|
|
iterator operator()(int value) {
|
|
|
|
call(value);
|
|
|
|
return base::operator()(value);
|
|
|
|
}
|
2016-11-20 16:47:24 +00:00
|
|
|
|
2018-04-08 14:03:44 +00:00
|
|
|
iterator operator()(fmt::basic_format_arg<fmt::format_context>::handle) {
|
2018-03-30 18:20:12 +00:00
|
|
|
return base::operator()(fmt::monostate());
|
|
|
|
}
|
2016-03-19 14:20:31 +00:00
|
|
|
};
|
|
|
|
|
2017-12-03 15:32:04 +00:00
|
|
|
void custom_vformat(fmt::string_view format_str, fmt::format_args args) {
|
2017-02-18 17:13:12 +00:00
|
|
|
fmt::memory_buffer buffer;
|
2018-03-04 14:40:43 +00:00
|
|
|
fmt::vformat_to<mock_arg_formatter>(buffer, format_str, args);
|
2016-03-19 14:20:31 +00:00
|
|
|
}
|
2016-08-27 00:23:13 +00:00
|
|
|
|
|
|
|
template <typename... Args>
|
|
|
|
void custom_format(const char *format_str, const Args & ... args) {
|
2018-04-08 14:21:26 +00:00
|
|
|
auto va = fmt::make_format_args(args...);
|
2016-10-07 15:37:06 +00:00
|
|
|
return custom_vformat(format_str, va);
|
2016-08-27 00:23:13 +00:00
|
|
|
}
|
2016-03-19 14:20:31 +00:00
|
|
|
|
|
|
|
TEST(FormatTest, CustomArgFormatter) {
|
2016-03-19 14:36:28 +00:00
|
|
|
custom_format("{}", 42);
|
2016-03-19 14:20:31 +00:00
|
|
|
}
|
2017-07-19 02:40:48 +00:00
|
|
|
|
|
|
|
TEST(FormatTest, NonNullTerminatedFormatString) {
|
|
|
|
EXPECT_EQ("42", format(string_view("{}foo", 2), 42));
|
|
|
|
}
|
2017-09-03 15:28:30 +00:00
|
|
|
|
|
|
|
struct variant {
|
|
|
|
enum {INT, STRING} type;
|
|
|
|
explicit variant(int) : type(INT) {}
|
|
|
|
explicit variant(const char *) : type(STRING) {}
|
|
|
|
};
|
|
|
|
|
2018-05-12 15:33:51 +00:00
|
|
|
FMT_BEGIN_NAMESPACE
|
2017-09-03 15:28:30 +00:00
|
|
|
template <>
|
|
|
|
struct formatter<variant> : dynamic_formatter<> {
|
2018-04-22 16:16:32 +00:00
|
|
|
auto format(variant value, format_context& ctx) -> decltype(ctx.out()) {
|
2017-09-03 15:28:30 +00:00
|
|
|
if (value.type == variant::INT)
|
2018-03-03 22:04:59 +00:00
|
|
|
return dynamic_formatter<>::format(42, ctx);
|
|
|
|
return dynamic_formatter<>::format("foo", ctx);
|
2017-09-03 15:28:30 +00:00
|
|
|
}
|
|
|
|
};
|
2018-05-12 15:33:51 +00:00
|
|
|
FMT_END_NAMESPACE
|
2017-09-03 15:28:30 +00:00
|
|
|
|
|
|
|
TEST(FormatTest, DynamicFormatter) {
|
|
|
|
auto num = variant(42);
|
|
|
|
auto str = variant("foo");
|
|
|
|
EXPECT_EQ("42", format("{:d}", num));
|
|
|
|
EXPECT_EQ("foo", format("{:s}", str));
|
2017-09-28 02:04:15 +00:00
|
|
|
EXPECT_EQ(" 42 foo ", format("{:{}} {:{}}", num, 3, str, 4));
|
2017-09-28 04:18:37 +00:00
|
|
|
EXPECT_THROW_MSG(format("{0:{}}", num),
|
|
|
|
format_error, "cannot switch from manual to automatic argument indexing");
|
|
|
|
EXPECT_THROW_MSG(format("{:{0}}", num),
|
|
|
|
format_error, "cannot switch from automatic to manual argument indexing");
|
2017-09-03 15:28:30 +00:00
|
|
|
EXPECT_THROW_MSG(format("{:=}", str),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2017-09-03 15:28:30 +00:00
|
|
|
EXPECT_THROW_MSG(format("{:+}", str),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2017-09-03 15:28:30 +00:00
|
|
|
EXPECT_THROW_MSG(format("{:-}", str),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2017-09-03 15:28:30 +00:00
|
|
|
EXPECT_THROW_MSG(format("{: }", str),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2017-09-03 15:28:30 +00:00
|
|
|
EXPECT_THROW_MSG(format("{:#}", str),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2017-09-03 15:28:30 +00:00
|
|
|
EXPECT_THROW_MSG(format("{:0}", str),
|
2017-11-18 15:42:54 +00:00
|
|
|
format_error, "format specifier requires numeric argument");
|
2017-09-03 15:28:30 +00:00
|
|
|
EXPECT_THROW_MSG(format("{:.2}", num),
|
2017-11-16 14:55:49 +00:00
|
|
|
format_error, "precision not allowed for this argument type");
|
2017-09-03 15:28:30 +00:00
|
|
|
}
|
2017-10-15 23:54:47 +00:00
|
|
|
|
2018-02-04 16:52:43 +00:00
|
|
|
TEST(FormatTest, ToString) {
|
|
|
|
EXPECT_EQ("42", fmt::to_string(42));
|
2018-02-17 09:38:46 +00:00
|
|
|
EXPECT_EQ("0x1234", fmt::to_string(reinterpret_cast<void*>(0x1234)));
|
2018-02-04 16:52:43 +00:00
|
|
|
}
|
|
|
|
|
2018-02-07 15:08:14 +00:00
|
|
|
TEST(FormatTest, ToWString) {
|
|
|
|
EXPECT_EQ(L"42", fmt::to_wstring(42));
|
|
|
|
}
|
|
|
|
|
2018-02-04 16:52:43 +00:00
|
|
|
TEST(FormatTest, OutputIterators) {
|
|
|
|
std::list<char> out;
|
|
|
|
fmt::format_to(std::back_inserter(out), "{}", 42);
|
|
|
|
EXPECT_EQ("42", std::string(out.begin(), out.end()));
|
|
|
|
std::stringstream s;
|
|
|
|
fmt::format_to(std::ostream_iterator<char>(s), "{}", 42);
|
|
|
|
EXPECT_EQ("42", s.str());
|
|
|
|
}
|
|
|
|
|
2018-04-04 14:38:21 +00:00
|
|
|
TEST(FormatTest, FormattedSize) {
|
|
|
|
EXPECT_EQ(2u, fmt::formatted_size("{}", 42));
|
2018-02-04 16:52:43 +00:00
|
|
|
}
|
|
|
|
|
2018-03-30 01:13:10 +00:00
|
|
|
TEST(FormatTest, FormatToN) {
|
|
|
|
char buffer[4];
|
|
|
|
buffer[3] = 'x';
|
|
|
|
auto result = fmt::format_to_n(buffer, 3, "{}", 12345);
|
|
|
|
EXPECT_EQ(5u, result.size);
|
2018-03-30 18:20:12 +00:00
|
|
|
EXPECT_EQ(buffer + 3, result.out);
|
2018-03-30 01:13:10 +00:00
|
|
|
EXPECT_EQ("123x", fmt::string_view(buffer, 4));
|
2018-03-30 18:20:12 +00:00
|
|
|
result = fmt::format_to_n(buffer, 3, "{:s}", "foobar");
|
|
|
|
EXPECT_EQ(6u, result.size);
|
|
|
|
EXPECT_EQ(buffer + 3, result.out);
|
|
|
|
EXPECT_EQ("foox", fmt::string_view(buffer, 4));
|
2018-03-30 01:13:10 +00:00
|
|
|
}
|
|
|
|
|
2018-02-04 16:52:43 +00:00
|
|
|
#if FMT_USE_CONSTEXPR
|
2017-10-22 13:43:41 +00:00
|
|
|
struct test_arg_id_handler {
|
|
|
|
enum result { NONE, EMPTY, INDEX, NAME, ERROR };
|
|
|
|
result res = NONE;
|
2017-10-15 23:54:47 +00:00
|
|
|
unsigned index = 0;
|
|
|
|
string_view name;
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void operator()() { res = EMPTY; }
|
2017-10-15 23:54:47 +00:00
|
|
|
|
2018-04-05 03:57:02 +00:00
|
|
|
FMT_CONSTEXPR void operator()(unsigned i) {
|
2017-10-22 13:43:41 +00:00
|
|
|
res = INDEX;
|
2018-04-05 03:57:02 +00:00
|
|
|
index = i;
|
2017-10-15 23:54:47 +00:00
|
|
|
}
|
|
|
|
|
2018-04-05 03:57:02 +00:00
|
|
|
FMT_CONSTEXPR void operator()(string_view n) {
|
2017-10-22 13:43:41 +00:00
|
|
|
res = NAME;
|
2018-04-05 03:57:02 +00:00
|
|
|
name = n;
|
2017-10-15 23:54:47 +00:00
|
|
|
}
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_error(const char *) { res = ERROR; }
|
2017-10-15 23:54:47 +00:00
|
|
|
};
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR test_arg_id_handler parse_arg_id(const char* s) {
|
2017-10-22 13:43:41 +00:00
|
|
|
test_arg_id_handler h;
|
2017-10-19 14:28:17 +00:00
|
|
|
fmt::internal::parse_arg_id(s, h);
|
2017-10-15 23:54:47 +00:00
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
2017-10-19 14:28:17 +00:00
|
|
|
TEST(FormatTest, ConstexprParseArgID) {
|
2017-10-22 13:43:41 +00:00
|
|
|
static_assert(parse_arg_id(":").res == test_arg_id_handler::EMPTY, "");
|
|
|
|
static_assert(parse_arg_id("}").res == test_arg_id_handler::EMPTY, "");
|
|
|
|
static_assert(parse_arg_id("42:").res == test_arg_id_handler::INDEX, "");
|
2017-10-15 23:54:47 +00:00
|
|
|
static_assert(parse_arg_id("42:").index == 42, "");
|
2017-10-22 13:43:41 +00:00
|
|
|
static_assert(parse_arg_id("foo:").res == test_arg_id_handler::NAME, "");
|
2017-10-15 23:54:47 +00:00
|
|
|
static_assert(parse_arg_id("foo:").name.size() == 3, "");
|
2017-10-22 13:43:41 +00:00
|
|
|
static_assert(parse_arg_id("!").res == test_arg_id_handler::ERROR, "");
|
2017-10-19 14:28:17 +00:00
|
|
|
}
|
|
|
|
|
2017-10-22 15:18:26 +00:00
|
|
|
struct test_format_specs_handler {
|
2017-10-19 14:28:17 +00:00
|
|
|
enum Result { NONE, PLUS, MINUS, SPACE, HASH, ZERO, ERROR };
|
2017-10-22 13:43:41 +00:00
|
|
|
Result res = NONE;
|
2017-10-19 14:28:17 +00:00
|
|
|
|
2018-04-05 04:11:31 +00:00
|
|
|
fmt::alignment align_ = fmt::ALIGN_DEFAULT;
|
2017-10-19 14:28:17 +00:00
|
|
|
char fill = 0;
|
|
|
|
unsigned width = 0;
|
|
|
|
fmt::internal::arg_ref<char> width_ref;
|
|
|
|
unsigned precision = 0;
|
|
|
|
fmt::internal::arg_ref<char> precision_ref;
|
|
|
|
char type = 0;
|
|
|
|
|
2017-10-25 13:42:48 +00:00
|
|
|
// Workaround for MSVC2017 bug that results in "expression did not evaluate
|
|
|
|
// to a constant" with compiler-generated copy ctor.
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR test_format_specs_handler() {}
|
|
|
|
FMT_CONSTEXPR test_format_specs_handler(const test_format_specs_handler &other)
|
2018-04-05 04:11:31 +00:00
|
|
|
: res(other.res), align_(other.align_), fill(other.fill),
|
2017-10-25 13:42:48 +00:00
|
|
|
width(other.width), width_ref(other.width_ref),
|
|
|
|
precision(other.precision), precision_ref(other.precision_ref),
|
|
|
|
type(other.type) {}
|
|
|
|
|
2018-04-05 04:11:31 +00:00
|
|
|
FMT_CONSTEXPR void on_align(fmt::alignment a) { align_ = a; }
|
2018-04-05 03:57:02 +00:00
|
|
|
FMT_CONSTEXPR void on_fill(char f) { fill = f; }
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_plus() { res = PLUS; }
|
|
|
|
FMT_CONSTEXPR void on_minus() { res = MINUS; }
|
|
|
|
FMT_CONSTEXPR void on_space() { res = SPACE; }
|
|
|
|
FMT_CONSTEXPR void on_hash() { res = HASH; }
|
|
|
|
FMT_CONSTEXPR void on_zero() { res = ZERO; }
|
2017-10-19 14:28:17 +00:00
|
|
|
|
2018-04-05 03:57:02 +00:00
|
|
|
FMT_CONSTEXPR void on_width(unsigned w) { width = w; }
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_dynamic_width(fmt::internal::auto_id) {}
|
|
|
|
FMT_CONSTEXPR void on_dynamic_width(unsigned index) { width_ref = index; }
|
|
|
|
FMT_CONSTEXPR void on_dynamic_width(string_view) {}
|
2017-10-19 14:28:17 +00:00
|
|
|
|
2018-04-05 03:57:02 +00:00
|
|
|
FMT_CONSTEXPR void on_precision(unsigned p) { precision = p; }
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_dynamic_precision(fmt::internal::auto_id) {}
|
2018-04-05 04:11:31 +00:00
|
|
|
FMT_CONSTEXPR void on_dynamic_precision(unsigned index) {
|
|
|
|
precision_ref = index;
|
|
|
|
}
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_dynamic_precision(string_view) {}
|
2017-10-19 14:28:17 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void end_precision() {}
|
2018-04-05 04:11:31 +00:00
|
|
|
FMT_CONSTEXPR void on_type(char t) { type = t; }
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_error(const char *) { res = ERROR; }
|
2017-10-19 14:28:17 +00:00
|
|
|
};
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR test_format_specs_handler parse_test_specs(const char *s) {
|
2017-10-22 15:18:26 +00:00
|
|
|
test_format_specs_handler h;
|
2017-10-19 14:28:17 +00:00
|
|
|
fmt::internal::parse_format_specs(s, h);
|
|
|
|
return h;
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatTest, ConstexprParseFormatSpecs) {
|
2018-02-11 17:23:47 +00:00
|
|
|
typedef test_format_specs_handler handler;
|
2018-04-05 04:11:31 +00:00
|
|
|
static_assert(parse_test_specs("<").align_ == fmt::ALIGN_LEFT, "");
|
2017-10-22 15:18:26 +00:00
|
|
|
static_assert(parse_test_specs("*^").fill == '*', "");
|
|
|
|
static_assert(parse_test_specs("+").res == handler::PLUS, "");
|
|
|
|
static_assert(parse_test_specs("-").res == handler::MINUS, "");
|
|
|
|
static_assert(parse_test_specs(" ").res == handler::SPACE, "");
|
|
|
|
static_assert(parse_test_specs("#").res == handler::HASH, "");
|
|
|
|
static_assert(parse_test_specs("0").res == handler::ZERO, "");
|
|
|
|
static_assert(parse_test_specs("42").width == 42, "");
|
|
|
|
static_assert(parse_test_specs("{42}").width_ref.index == 42, "");
|
|
|
|
static_assert(parse_test_specs(".42").precision == 42, "");
|
|
|
|
static_assert(parse_test_specs(".{42}").precision_ref.index == 42, "");
|
|
|
|
static_assert(parse_test_specs("d").type == 'd', "");
|
|
|
|
static_assert(parse_test_specs("{<").res == handler::ERROR, "");
|
|
|
|
}
|
|
|
|
|
|
|
|
struct test_context {
|
2018-02-11 17:23:47 +00:00
|
|
|
typedef char char_type;
|
2017-10-22 15:18:26 +00:00
|
|
|
|
2018-04-04 14:38:21 +00:00
|
|
|
FMT_CONSTEXPR fmt::basic_format_arg<test_context> next_arg() {
|
2017-10-22 16:32:46 +00:00
|
|
|
return fmt::internal::make_arg<test_context>(11);
|
2017-10-22 15:18:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename Id>
|
2018-04-04 14:38:21 +00:00
|
|
|
FMT_CONSTEXPR fmt::basic_format_arg<test_context> get_arg(Id) {
|
2017-10-22 16:32:46 +00:00
|
|
|
return fmt::internal::make_arg<test_context>(22);
|
2017-10-22 15:18:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
template <typename Id>
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void check_arg_id(Id) {}
|
2017-10-22 17:19:09 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR unsigned next_arg_id() { return 33; }
|
2017-11-13 03:14:35 +00:00
|
|
|
|
|
|
|
void on_error(const char *) {}
|
2017-11-18 15:42:54 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR test_context &parse_context() { return *this; }
|
|
|
|
FMT_CONSTEXPR test_context error_handler() { return *this; }
|
2017-10-22 15:18:26 +00:00
|
|
|
};
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR fmt::format_specs parse_specs(const char *s) {
|
2017-10-22 15:18:26 +00:00
|
|
|
fmt::format_specs specs;
|
2018-02-16 10:04:33 +00:00
|
|
|
test_context ctx{};
|
2017-10-22 15:18:26 +00:00
|
|
|
fmt::internal::specs_handler<test_context> h(specs, ctx);
|
|
|
|
parse_format_specs(s, h);
|
|
|
|
return specs;
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatTest, ConstexprSpecsHandler) {
|
|
|
|
static_assert(parse_specs("<").align() == fmt::ALIGN_LEFT, "");
|
|
|
|
static_assert(parse_specs("*^").fill() == '*', "");
|
|
|
|
static_assert(parse_specs("+").flag(fmt::PLUS_FLAG), "");
|
|
|
|
static_assert(parse_specs("-").flag(fmt::MINUS_FLAG), "");
|
|
|
|
static_assert(parse_specs(" ").flag(fmt::SIGN_FLAG), "");
|
|
|
|
static_assert(parse_specs("#").flag(fmt::HASH_FLAG), "");
|
|
|
|
static_assert(parse_specs("0").align() == fmt::ALIGN_NUMERIC, "");
|
|
|
|
static_assert(parse_specs("42").width() == 42, "");
|
2017-10-22 16:32:46 +00:00
|
|
|
static_assert(parse_specs("{}").width() == 11, "");
|
|
|
|
static_assert(parse_specs("{0}").width() == 22, "");
|
2017-10-22 15:18:26 +00:00
|
|
|
static_assert(parse_specs(".42").precision() == 42, "");
|
2017-10-22 16:32:46 +00:00
|
|
|
static_assert(parse_specs(".{}").precision() == 11, "");
|
|
|
|
static_assert(parse_specs(".{0}").precision() == 22, "");
|
2017-10-22 15:18:26 +00:00
|
|
|
static_assert(parse_specs("d").type() == 'd', "");
|
2017-10-15 23:54:47 +00:00
|
|
|
}
|
2017-10-22 17:19:09 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR fmt::internal::dynamic_format_specs<char>
|
2017-10-22 17:19:09 +00:00
|
|
|
parse_dynamic_specs(const char *s) {
|
|
|
|
fmt::internal::dynamic_format_specs<char> specs;
|
2018-02-16 10:04:33 +00:00
|
|
|
test_context ctx{};
|
2017-10-22 17:19:09 +00:00
|
|
|
fmt::internal::dynamic_specs_handler<test_context> h(specs, ctx);
|
|
|
|
parse_format_specs(s, h);
|
|
|
|
return specs;
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatTest, ConstexprDynamicSpecsHandler) {
|
|
|
|
static_assert(parse_dynamic_specs("<").align() == fmt::ALIGN_LEFT, "");
|
|
|
|
static_assert(parse_dynamic_specs("*^").fill() == '*', "");
|
|
|
|
static_assert(parse_dynamic_specs("+").flag(fmt::PLUS_FLAG), "");
|
|
|
|
static_assert(parse_dynamic_specs("-").flag(fmt::MINUS_FLAG), "");
|
|
|
|
static_assert(parse_dynamic_specs(" ").flag(fmt::SIGN_FLAG), "");
|
|
|
|
static_assert(parse_dynamic_specs("#").flag(fmt::HASH_FLAG), "");
|
|
|
|
static_assert(parse_dynamic_specs("0").align() == fmt::ALIGN_NUMERIC, "");
|
|
|
|
static_assert(parse_dynamic_specs("42").width() == 42, "");
|
|
|
|
static_assert(parse_dynamic_specs("{}").width_ref.index == 33, "");
|
|
|
|
static_assert(parse_dynamic_specs("{42}").width_ref.index == 42, "");
|
|
|
|
static_assert(parse_dynamic_specs(".42").precision() == 42, "");
|
|
|
|
static_assert(parse_dynamic_specs(".{}").precision_ref.index == 33, "");
|
|
|
|
static_assert(parse_dynamic_specs(".{42}").precision_ref.index == 42, "");
|
|
|
|
static_assert(parse_dynamic_specs("d").type() == 'd', "");
|
|
|
|
}
|
2017-10-24 04:02:54 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR test_format_specs_handler check_specs(const char *s) {
|
2017-10-24 04:02:54 +00:00
|
|
|
fmt::internal::specs_checker<test_format_specs_handler>
|
2018-02-16 17:20:33 +00:00
|
|
|
checker(test_format_specs_handler(), fmt::internal::double_type);
|
2017-10-24 04:02:54 +00:00
|
|
|
parse_format_specs(s, checker);
|
|
|
|
return checker;
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatTest, ConstexprSpecsChecker) {
|
2018-02-11 17:23:47 +00:00
|
|
|
typedef test_format_specs_handler handler;
|
2018-04-05 04:11:31 +00:00
|
|
|
static_assert(check_specs("<").align_ == fmt::ALIGN_LEFT, "");
|
2017-10-24 04:02:54 +00:00
|
|
|
static_assert(check_specs("*^").fill == '*', "");
|
|
|
|
static_assert(check_specs("+").res == handler::PLUS, "");
|
|
|
|
static_assert(check_specs("-").res == handler::MINUS, "");
|
|
|
|
static_assert(check_specs(" ").res == handler::SPACE, "");
|
|
|
|
static_assert(check_specs("#").res == handler::HASH, "");
|
|
|
|
static_assert(check_specs("0").res == handler::ZERO, "");
|
|
|
|
static_assert(check_specs("42").width == 42, "");
|
|
|
|
static_assert(check_specs("{42}").width_ref.index == 42, "");
|
|
|
|
static_assert(check_specs(".42").precision == 42, "");
|
|
|
|
static_assert(check_specs(".{42}").precision_ref.index == 42, "");
|
|
|
|
static_assert(check_specs("d").type == 'd', "");
|
|
|
|
static_assert(check_specs("{<").res == handler::ERROR, "");
|
|
|
|
}
|
2017-10-29 14:32:14 +00:00
|
|
|
|
|
|
|
struct test_format_string_handler {
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_text(const char *, const char *) {}
|
2017-10-29 14:32:14 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_arg_id() {}
|
2017-10-29 14:32:14 +00:00
|
|
|
|
|
|
|
template <typename T>
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_arg_id(T) {}
|
2017-10-29 14:32:14 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_replacement_field(const char *) {}
|
2017-10-29 14:32:14 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR const char *on_format_specs(const char *s) { return s; }
|
2017-10-29 14:32:14 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_error(const char *) { error = true; }
|
2017-10-29 14:32:14 +00:00
|
|
|
|
|
|
|
bool error = false;
|
|
|
|
};
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR bool parse_string(const char *s) {
|
2017-10-29 14:32:14 +00:00
|
|
|
test_format_string_handler h;
|
|
|
|
fmt::internal::parse_format_string(s, h);
|
|
|
|
return !h.error;
|
|
|
|
}
|
|
|
|
|
|
|
|
TEST(FormatTest, ConstexprParseFormatString) {
|
|
|
|
static_assert(parse_string("foo"), "");
|
|
|
|
static_assert(!parse_string("}"), "");
|
|
|
|
static_assert(parse_string("{}"), "");
|
|
|
|
static_assert(parse_string("{42}"), "");
|
|
|
|
static_assert(parse_string("{foo}"), "");
|
|
|
|
static_assert(parse_string("{:}"), "");
|
|
|
|
}
|
2017-11-04 15:23:24 +00:00
|
|
|
|
2017-11-11 18:28:05 +00:00
|
|
|
struct test_error_handler {
|
|
|
|
const char *&error;
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR test_error_handler(const char *&err): error(err) {}
|
2017-11-12 14:58:11 +00:00
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR test_error_handler(const test_error_handler &other)
|
2017-11-12 14:58:11 +00:00
|
|
|
: error(other.error) {}
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR void on_error(const char *message) {
|
2017-11-12 14:58:11 +00:00
|
|
|
if (!error)
|
|
|
|
error = message;
|
|
|
|
}
|
2017-11-11 18:28:05 +00:00
|
|
|
};
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR size_t len(const char *s) {
|
2017-11-11 18:28:05 +00:00
|
|
|
size_t len = 0;
|
|
|
|
while (*s++)
|
|
|
|
++len;
|
|
|
|
return len;
|
|
|
|
}
|
|
|
|
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR bool equal(const char *s1, const char *s2) {
|
2017-11-23 17:14:37 +00:00
|
|
|
if (!s1 || !s2)
|
|
|
|
return s1 == s2;
|
2017-11-11 18:28:05 +00:00
|
|
|
while (*s1 && *s1 == *s2) {
|
|
|
|
++s1;
|
|
|
|
++s2;
|
|
|
|
}
|
|
|
|
return *s1 == *s2;
|
|
|
|
}
|
|
|
|
|
|
|
|
template <typename... Args>
|
2018-02-03 14:14:10 +00:00
|
|
|
FMT_CONSTEXPR bool test_error(const char *fmt, const char *expected_error) {
|
2017-11-11 18:28:05 +00:00
|
|
|
const char *actual_error = nullptr;
|
|
|
|
fmt::internal::check_format_string<char, test_error_handler, Args...>(
|
2017-11-12 17:42:26 +00:00
|
|
|
string_view(fmt, len(fmt)), test_error_handler(actual_error));
|
2017-11-12 14:58:11 +00:00
|
|
|
return equal(actual_error, expected_error);
|
2017-11-11 18:28:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
#define EXPECT_ERROR(fmt, error, ...) \
|
|
|
|
static_assert(test_error<__VA_ARGS__>(fmt, error), "")
|
|
|
|
|
|
|
|
TEST(FormatTest, FormatStringErrors) {
|
|
|
|
EXPECT_ERROR("foo", nullptr);
|
|
|
|
EXPECT_ERROR("}", "unmatched '}' in format string");
|
2018-02-24 09:29:15 +00:00
|
|
|
EXPECT_ERROR("{0:s", "unknown format specifier", Date);
|
2017-11-12 17:42:26 +00:00
|
|
|
#ifndef _MSC_VER
|
|
|
|
// This causes an internal compiler error in MSVC2017.
|
2017-11-24 15:54:22 +00:00
|
|
|
EXPECT_ERROR("{0:=5", "unknown format specifier", int);
|
2017-11-13 03:14:35 +00:00
|
|
|
EXPECT_ERROR("{:{<}", "invalid fill character '{'", int);
|
2017-11-16 16:09:12 +00:00
|
|
|
EXPECT_ERROR("{:10000000000}", "number is too big", int);
|
|
|
|
EXPECT_ERROR("{:.10000000000}", "number is too big", int);
|
2017-11-18 15:42:54 +00:00
|
|
|
EXPECT_ERROR("{:x}", "argument index out of range");
|
|
|
|
EXPECT_ERROR("{:=}", "format specifier requires numeric argument",
|
|
|
|
const char *);
|
|
|
|
EXPECT_ERROR("{:+}", "format specifier requires numeric argument",
|
|
|
|
const char *);
|
|
|
|
EXPECT_ERROR("{:-}", "format specifier requires numeric argument",
|
|
|
|
const char *);
|
|
|
|
EXPECT_ERROR("{:#}", "format specifier requires numeric argument",
|
|
|
|
const char *);
|
|
|
|
EXPECT_ERROR("{: }", "format specifier requires numeric argument",
|
|
|
|
const char *);
|
|
|
|
EXPECT_ERROR("{:0}", "format specifier requires numeric argument",
|
|
|
|
const char *);
|
|
|
|
EXPECT_ERROR("{:+}", "format specifier requires signed argument", unsigned);
|
|
|
|
EXPECT_ERROR("{:-}", "format specifier requires signed argument", unsigned);
|
|
|
|
EXPECT_ERROR("{: }", "format specifier requires signed argument", unsigned);
|
|
|
|
EXPECT_ERROR("{:.2}", "precision not allowed for this argument type", int);
|
2017-11-19 17:06:49 +00:00
|
|
|
EXPECT_ERROR("{:s}", "invalid type specifier", int);
|
2017-11-23 17:14:37 +00:00
|
|
|
EXPECT_ERROR("{:s}", "invalid type specifier", bool);
|
2017-11-24 15:54:22 +00:00
|
|
|
EXPECT_ERROR("{:s}", "invalid type specifier", char);
|
|
|
|
EXPECT_ERROR("{:+}", "invalid format specifier for char", char);
|
2017-11-23 17:14:37 +00:00
|
|
|
EXPECT_ERROR("{:s}", "invalid type specifier", double);
|
2017-11-24 17:54:28 +00:00
|
|
|
EXPECT_ERROR("{:d}", "invalid type specifier", const char *);
|
|
|
|
EXPECT_ERROR("{:d}", "invalid type specifier", std::string);
|
|
|
|
EXPECT_ERROR("{:s}", "invalid type specifier", void *);
|
2017-11-18 16:38:58 +00:00
|
|
|
#endif
|
|
|
|
EXPECT_ERROR("{foo", "missing '}' in format string", int);
|
|
|
|
EXPECT_ERROR("{10000000000}", "number is too big");
|
|
|
|
EXPECT_ERROR("{0x}", "invalid format string");
|
|
|
|
EXPECT_ERROR("{-}", "invalid format string");
|
|
|
|
EXPECT_ERROR("{:{0x}}", "invalid format string", int);
|
|
|
|
EXPECT_ERROR("{:{-}}", "invalid format string", int);
|
|
|
|
EXPECT_ERROR("{:.{0x}}", "invalid format string", int);
|
|
|
|
EXPECT_ERROR("{:.{-}}", "invalid format string", int);
|
|
|
|
EXPECT_ERROR("{:.x}", "missing precision specifier", int);
|
|
|
|
EXPECT_ERROR("{}", "argument index out of range");
|
|
|
|
EXPECT_ERROR("{1}", "argument index out of range", int);
|
2017-11-19 14:35:23 +00:00
|
|
|
EXPECT_ERROR("{1}{}",
|
|
|
|
"cannot switch from manual to automatic argument indexing",
|
|
|
|
int, int);
|
2017-11-19 15:36:01 +00:00
|
|
|
EXPECT_ERROR("{}{1}",
|
|
|
|
"cannot switch from automatic to manual argument indexing",
|
|
|
|
int, int);
|
2017-11-11 18:28:05 +00:00
|
|
|
}
|
2018-02-04 16:52:43 +00:00
|
|
|
#endif // FMT_USE_CONSTEXPR
|
2018-03-21 14:50:59 +00:00
|
|
|
|