| // Formatting library for C++ - formatting library tests |
| // |
| // Copyright (c) 2012 - present, Victor Zverovich |
| // All rights reserved. |
| // |
| // For the license information refer to format.h. |
| |
| #include <string> |
| #include <type_traits> |
| |
| // Check that fmt/compile.h compiles with windows.h included before it. |
| #ifdef _WIN32 |
| # include <windows.h> |
| #endif |
| |
| #include "fmt/compile.h" |
| #include "gmock.h" |
| #include "gtest-extra.h" |
| #include "util.h" |
| |
| // compiletime_prepared_parts_type_provider is useful only with relaxed |
| // constexpr. |
| #if FMT_USE_CONSTEXPR |
| template <unsigned EXPECTED_PARTS_COUNT, typename Format> |
| void check_prepared_parts_type(Format format) { |
| typedef fmt::detail::compiled_format_base<decltype(format)> provider; |
| typedef fmt::detail::format_part<char> |
| expected_parts_type[EXPECTED_PARTS_COUNT]; |
| static_assert(std::is_same<typename provider::parts_container, |
| expected_parts_type>::value, |
| "CompileTimePreparedPartsTypeProvider test failed"); |
| } |
| |
| TEST(CompileTest, CompileTimePreparedPartsTypeProvider) { |
| check_prepared_parts_type<1u>(FMT_STRING("text")); |
| check_prepared_parts_type<1u>(FMT_STRING("{}")); |
| check_prepared_parts_type<2u>(FMT_STRING("text{}")); |
| check_prepared_parts_type<2u>(FMT_STRING("{}text")); |
| check_prepared_parts_type<3u>(FMT_STRING("text{}text")); |
| check_prepared_parts_type<3u>(FMT_STRING("{:{}.{}} {:{}}")); |
| |
| check_prepared_parts_type<3u>(FMT_STRING("{{{}}}")); // '{', 'argument', '}' |
| check_prepared_parts_type<2u>(FMT_STRING("text{{")); // 'text', '{' |
| check_prepared_parts_type<3u>(FMT_STRING("text{{ ")); // 'text', '{', ' ' |
| check_prepared_parts_type<2u>(FMT_STRING("}}text")); // '}', text |
| check_prepared_parts_type<2u>(FMT_STRING("text}}text")); // 'text}', 'text' |
| check_prepared_parts_type<4u>( |
| FMT_STRING("text{{}}text")); // 'text', '{', '}', 'text' |
| } |
| #endif |
| |
| TEST(CompileTest, PassStringLiteralFormat) { |
| const auto prepared = fmt::detail::compile<int>("test {}"); |
| EXPECT_EQ("test 42", fmt::format(prepared, 42)); |
| const auto wprepared = fmt::detail::compile<int>(L"test {}"); |
| EXPECT_EQ(L"test 42", fmt::format(wprepared, 42)); |
| } |
| |
| TEST(CompileTest, FormatToArrayOfChars) { |
| char buffer[32] = {0}; |
| const auto prepared = fmt::detail::compile<int>("4{}"); |
| fmt::format_to(fmt::detail::make_checked(buffer, 32), prepared, 2); |
| EXPECT_EQ(std::string("42"), buffer); |
| wchar_t wbuffer[32] = {0}; |
| const auto wprepared = fmt::detail::compile<int>(L"4{}"); |
| fmt::format_to(fmt::detail::make_checked(wbuffer, 32), wprepared, 2); |
| EXPECT_EQ(std::wstring(L"42"), wbuffer); |
| } |
| |
| TEST(CompileTest, FormatToIterator) { |
| std::string s(2, ' '); |
| const auto prepared = fmt::detail::compile<int>("4{}"); |
| fmt::format_to(s.begin(), prepared, 2); |
| EXPECT_EQ("42", s); |
| std::wstring ws(2, L' '); |
| const auto wprepared = fmt::detail::compile<int>(L"4{}"); |
| fmt::format_to(ws.begin(), wprepared, 2); |
| EXPECT_EQ(L"42", ws); |
| } |
| |
| TEST(CompileTest, FormatToN) { |
| char buf[5]; |
| auto f = fmt::detail::compile<int>("{:10}"); |
| auto result = fmt::format_to_n(buf, 5, f, 42); |
| EXPECT_EQ(result.size, 10); |
| EXPECT_EQ(result.out, buf + 5); |
| EXPECT_EQ(fmt::string_view(buf, 5), " "); |
| } |
| |
| TEST(CompileTest, FormattedSize) { |
| auto f = fmt::detail::compile<int>("{:10}"); |
| EXPECT_EQ(fmt::formatted_size(f, 42), 10); |
| } |
| |
| TEST(CompileTest, MultipleTypes) { |
| auto f = fmt::detail::compile<int, int>("{} {}"); |
| EXPECT_EQ(fmt::format(f, 42, 42), "42 42"); |
| } |
| |
| struct test_formattable {}; |
| |
| FMT_BEGIN_NAMESPACE |
| template <> struct formatter<test_formattable> : formatter<const char*> { |
| template <typename FormatContext> |
| auto format(test_formattable, FormatContext& ctx) -> decltype(ctx.out()) { |
| return formatter<const char*>::format("foo", ctx); |
| } |
| }; |
| FMT_END_NAMESPACE |
| |
| TEST(CompileTest, FormatUserDefinedType) { |
| auto f = fmt::detail::compile<test_formattable>("{}"); |
| EXPECT_EQ(fmt::format(f, test_formattable()), "foo"); |
| } |
| |
| TEST(CompileTest, EmptyFormatString) { |
| auto f = fmt::detail::compile<>(""); |
| EXPECT_EQ(fmt::format(f), ""); |
| } |
| |
| #ifdef __cpp_if_constexpr |
| TEST(CompileTest, FormatDefault) { |
| EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42)); |
| EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42u)); |
| EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ll)); |
| EXPECT_EQ("42", fmt::format(FMT_COMPILE("{}"), 42ull)); |
| EXPECT_EQ("true", fmt::format(FMT_COMPILE("{}"), true)); |
| EXPECT_EQ("x", fmt::format(FMT_COMPILE("{}"), 'x')); |
| EXPECT_EQ("4.2", fmt::format(FMT_COMPILE("{}"), 4.2)); |
| EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo")); |
| EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo"))); |
| EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable())); |
| } |
| |
| TEST(CompileTest, FormatWideString) { |
| EXPECT_EQ(L"42", fmt::format(FMT_COMPILE(L"{}"), 42)); |
| } |
| |
| TEST(CompileTest, FormatSpecs) { |
| EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42)); |
| } |
| |
| TEST(CompileTest, DynamicWidth) { |
| EXPECT_EQ(" 42foo ", |
| fmt::format(FMT_COMPILE("{:{}}{:{}}"), 42, 4, "foo", 5)); |
| } |
| |
| TEST(CompileTest, FormatTo) { |
| char buf[8]; |
| auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42); |
| *end = '\0'; |
| EXPECT_STREQ("42", buf); |
| end = fmt::format_to(buf, FMT_COMPILE("{:x}"), 42); |
| *end = '\0'; |
| EXPECT_STREQ("2a", buf); |
| } |
| |
| TEST(CompileTest, FormatToNWithCompileMacro) { |
| constexpr auto buffer_size = 8; |
| char buffer[buffer_size]; |
| auto res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{}"), 42); |
| *res.out = '\0'; |
| EXPECT_STREQ("42", buffer); |
| res = fmt::format_to_n(buffer, buffer_size, FMT_COMPILE("{:x}"), 42); |
| *res.out = '\0'; |
| EXPECT_STREQ("2a", buffer); |
| } |
| |
| TEST(CompileTest, TextAndArg) { |
| EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42)); |
| EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42)); |
| } |
| #endif |