fmt/test/compile-test.cc

173 lines
5.4 KiB
C++
Raw Normal View History

// Formatting library for C++ - formatting library tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
2019-07-25 16:01:21 +00:00
// For the license information refer to format.h.
2019-01-13 02:27:38 +00:00
#include <stdint.h>
2020-05-07 22:59:46 +00:00
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstring>
#include <deque>
#include <list>
#include <memory>
#include <string>
2019-07-25 16:01:21 +00:00
// Check if fmt/compile.h compiles with windows.h included before it.
#ifdef _WIN32
2019-01-13 02:27:38 +00:00
# include <windows.h>
#endif
2019-07-25 16:01:21 +00:00
#include "fmt/compile.h"
#include "gmock.h"
#include "gtest-extra.h"
#include "mock-allocator.h"
#include "util.h"
#undef ERROR
#undef min
#undef max
using testing::Return;
using testing::StrictMock;
// 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) {
2020-05-10 14:25:42 +00:00
typedef fmt::detail::compiled_format_base<decltype(format)> provider;
typedef fmt::detail::format_part<char>
2019-09-01 21:57:36 +00:00
expected_parts_type[EXPECTED_PARTS_COUNT];
static_assert(std::is_same<typename provider::parts_container,
expected_parts_type>::value,
"CompileTimePreparedPartsTypeProvider test failed");
}
2019-08-25 13:22:13 +00:00
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("{:{}.{}} {:{}}"));
2019-01-13 02:27:38 +00:00
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>(
2019-01-13 02:27:38 +00:00
FMT_STRING("text{{}}text")); // 'text', '{', '}', 'text'
}
#endif
2019-08-25 13:22:13 +00:00
TEST(CompileTest, PassStringLiteralFormat) {
2020-06-23 21:03:37 +00:00
const auto prepared = fmt::detail::compile<int>("test {}");
2019-08-03 13:28:31 +00:00
EXPECT_EQ("test 42", fmt::format(prepared, 42));
2020-06-23 21:03:37 +00:00
const auto wprepared = fmt::detail::compile<int>(L"test {}");
2019-08-03 13:28:31 +00:00
EXPECT_EQ(L"test 42", fmt::format(wprepared, 42));
}
2019-08-25 13:22:13 +00:00
TEST(CompileTest, FormatToArrayOfChars) {
char buffer[32] = {0};
2020-06-23 21:03:37 +00:00
const auto prepared = fmt::detail::compile<int>("4{}");
2020-05-10 14:25:42 +00:00
fmt::format_to(fmt::detail::make_checked(buffer, 32), prepared, 2);
EXPECT_EQ(std::string("42"), buffer);
wchar_t wbuffer[32] = {0};
2020-06-23 21:03:37 +00:00
const auto wprepared = fmt::detail::compile<int>(L"4{}");
2020-05-10 14:25:42 +00:00
fmt::format_to(fmt::detail::make_checked(wbuffer, 32), wprepared, 2);
EXPECT_EQ(std::wstring(L"42"), wbuffer);
}
2019-08-25 13:22:13 +00:00
TEST(CompileTest, FormatToIterator) {
std::string s(2, ' ');
2020-06-23 21:03:37 +00:00
const auto prepared = fmt::detail::compile<int>("4{}");
2019-08-03 15:35:02 +00:00
fmt::format_to(s.begin(), prepared, 2);
EXPECT_EQ("42", s);
std::wstring ws(2, L' ');
2020-06-23 21:03:37 +00:00
const auto wprepared = fmt::detail::compile<int>(L"4{}");
2019-08-03 15:35:02 +00:00
fmt::format_to(ws.begin(), wprepared, 2);
EXPECT_EQ(L"42", ws);
}
TEST(CompileTest, FormatToN) {
char buf[5];
2020-06-23 21:03:37 +00:00
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) {
2020-06-23 21:03:37 +00:00
auto f = fmt::detail::compile<int>("{:10}");
EXPECT_EQ(fmt::formatted_size(f, 42), 10);
}
TEST(CompileTest, MultipleTypes) {
2020-06-23 21:03:37 +00:00
auto f = fmt::detail::compile<int, int>("{} {}");
EXPECT_EQ(fmt::format(f, 42, 42), "42 42");
}
2020-07-14 18:13:21 +00:00
struct test_formattable {};
2019-09-01 19:12:19 +00:00
FMT_BEGIN_NAMESPACE
2020-07-14 18:13:21 +00:00
template <> struct formatter<test_formattable> : formatter<const char*> {
template <typename FormatContext>
2020-07-14 18:13:21 +00:00
auto format(test_formattable, FormatContext& ctx) -> decltype(ctx.out()) {
return formatter<const char*>::format("foo", ctx);
}
};
2019-09-01 19:12:19 +00:00
FMT_END_NAMESPACE
TEST(CompileTest, FormatUserDefinedType) {
2020-07-14 18:13:21 +00:00
auto f = fmt::detail::compile<test_formattable>("{}");
EXPECT_EQ(fmt::format(f, test_formattable()), "foo");
}
2019-09-01 21:57:36 +00:00
TEST(CompileTest, EmptyFormatString) {
2020-06-23 21:03:37 +00:00
auto f = fmt::detail::compile<>("");
2019-09-01 21:57:36 +00:00
EXPECT_EQ(fmt::format(f), "");
}
2020-06-12 20:24:49 +00:00
#ifdef __cpp_if_constexpr
TEST(CompileTest, FormatDefault) {
2020-06-12 20:24:49 +00:00
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));
2020-06-12 20:24:49 +00:00
EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), "foo"));
EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), std::string("foo")));
2020-07-14 18:13:21 +00:00
EXPECT_EQ("foo", fmt::format(FMT_COMPILE("{}"), test_formattable()));
}
TEST(CompileTest, FormatSpecs) {
EXPECT_EQ("42", fmt::format(FMT_COMPILE("{:x}"), 0x42));
2020-06-12 20:24:49 +00:00
}
2020-06-14 18:04:41 +00:00
TEST(CompileTest, DynamicWidth) {
EXPECT_EQ(" 42foo ",
fmt::format(FMT_COMPILE("{:{}}{:{}}"), 42, 4, "foo", 5));
}
2020-06-20 15:50:02 +00:00
TEST(CompileTest, FormatTo) {
char buf[8];
auto end = fmt::format_to(buf, FMT_COMPILE("{}"), 42);
*end = '\0';
EXPECT_STREQ("42", buf);
}
2020-06-14 18:04:41 +00:00
TEST(CompileTest, TextAndArg) {
EXPECT_EQ(">>>42<<<", fmt::format(FMT_COMPILE(">>>{}<<<"), 42));
2020-07-11 15:35:26 +00:00
EXPECT_EQ("42!", fmt::format(FMT_COMPILE("{}!"), 42));
2020-06-14 18:04:41 +00:00
}
2020-06-12 20:24:49 +00:00
#endif