fmt/test/core-test.cc

759 lines
22 KiB
C++
Raw Normal View History

// Formatting library for C++ - core tests
2018-03-04 17:16:51 +00:00
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
#include <algorithm>
#include <climits>
#include <cstring>
2015-10-22 15:56:52 +00:00
#include <functional>
#include <iterator>
2014-06-06 15:07:05 +00:00
#include <limits>
2019-01-13 02:27:38 +00:00
#include <memory>
#include <string>
#include <type_traits>
#include "gmock.h"
#include "test-assert.h"
// Check if fmt/core.h compiles with windows.h included before it.
2014-06-06 14:29:57 +00:00
#ifdef _WIN32
2019-01-13 02:27:38 +00:00
# include <windows.h>
2014-06-06 14:29:57 +00:00
#endif
#include "fmt/core.h"
2014-06-06 14:29:57 +00:00
#undef min
2014-06-06 15:18:53 +00:00
#undef max
using fmt::basic_format_arg;
2019-01-13 02:27:38 +00:00
using fmt::string_view;
2020-05-10 14:25:42 +00:00
using fmt::detail::buffer;
2020-07-11 03:54:15 +00:00
using fmt::detail::make_arg;
2020-05-10 14:25:42 +00:00
using fmt::detail::value;
using testing::_;
2020-07-10 14:50:37 +00:00
using testing::Return;
2014-09-30 14:30:27 +00:00
using testing::StrictMock;
struct test_struct {};
2016-05-06 14:37:20 +00:00
2018-05-12 15:33:51 +00:00
FMT_BEGIN_NAMESPACE
2019-01-13 02:27:38 +00:00
template <typename Char> struct formatter<test_struct, Char> {
template <typename ParseContext>
2019-01-13 02:27:38 +00:00
auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
2017-08-13 20:09:02 +00:00
}
auto format(test_struct, format_context& ctx) -> decltype(ctx.out()) {
2019-01-13 02:27:38 +00:00
const Char* test = "test";
2018-04-22 16:16:32 +00:00
return std::copy_n(test, std::strlen(test), ctx.out());
2017-08-13 20:09:02 +00:00
}
};
2018-05-12 15:33:51 +00:00
FMT_END_NAMESPACE
2017-08-13 20:09:02 +00:00
2018-10-24 13:34:28 +00:00
#if !FMT_GCC_VERSION || FMT_GCC_VERSION >= 470
2014-10-01 15:12:10 +00:00
TEST(BufferTest, Noncopyable) {
EXPECT_FALSE(std::is_copy_constructible<buffer<char>>::value);
2019-01-13 02:27:38 +00:00
# if !FMT_MSC_VER
// std::is_copy_assignable is broken in MSVC2013.
EXPECT_FALSE(std::is_copy_assignable<buffer<char>>::value);
2019-01-13 02:27:38 +00:00
# endif
}
2014-10-01 15:12:10 +00:00
TEST(BufferTest, Nonmoveable) {
EXPECT_FALSE(std::is_move_constructible<buffer<char>>::value);
2019-01-13 02:27:38 +00:00
# if !FMT_MSC_VER
// std::is_move_assignable is broken in MSVC2013.
EXPECT_FALSE(std::is_move_assignable<buffer<char>>::value);
2019-01-13 02:27:38 +00:00
# endif
}
2018-10-24 13:34:28 +00:00
#endif
2020-07-11 03:54:15 +00:00
TEST(BufferTest, Indestructible) {
static_assert(!std::is_destructible<fmt::detail::buffer<int>>(),
"buffer's destructor is protected");
}
2014-09-30 14:30:27 +00:00
template <typename T> struct mock_buffer : buffer<T> {
2020-07-10 14:50:37 +00:00
MOCK_METHOD1(do_grow, size_t(size_t capacity));
2014-10-01 16:32:31 +00:00
2020-07-10 14:50:37 +00:00
void grow(size_t capacity) { this->set(this->data(), do_grow(capacity)); }
2014-09-30 14:30:27 +00:00
2020-07-10 14:50:37 +00:00
mock_buffer(T* data = nullptr, size_t capacity = 0) {
this->set(data, capacity);
ON_CALL(*this, do_grow(_))
.WillByDefault(
testing::Invoke([](size_t capacity) { return capacity; }));
}
2014-09-30 14:30:27 +00:00
};
TEST(BufferTest, Ctor) {
{
mock_buffer<int> buffer;
EXPECT_EQ(nullptr, buffer.data());
EXPECT_EQ(static_cast<size_t>(0), buffer.size());
EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
2014-09-30 14:30:27 +00:00
}
{
int dummy;
mock_buffer<int> buffer(&dummy);
2014-09-30 14:30:27 +00:00
EXPECT_EQ(&dummy, &buffer[0]);
EXPECT_EQ(static_cast<size_t>(0), buffer.size());
EXPECT_EQ(static_cast<size_t>(0), buffer.capacity());
2014-09-30 14:30:27 +00:00
}
{
int dummy;
2020-05-07 22:59:46 +00:00
size_t capacity = std::numeric_limits<size_t>::max();
mock_buffer<int> buffer(&dummy, capacity);
2014-09-30 14:30:27 +00:00
EXPECT_EQ(&dummy, &buffer[0]);
EXPECT_EQ(static_cast<size_t>(0), buffer.size());
2014-09-30 14:30:27 +00:00
EXPECT_EQ(capacity, buffer.capacity());
}
}
TEST(BufferTest, Access) {
char data[10];
mock_buffer<char> buffer(data, sizeof(data));
2014-09-30 14:30:27 +00:00
buffer[0] = 11;
EXPECT_EQ(11, buffer[0]);
buffer[3] = 42;
EXPECT_EQ(42, *(&buffer[0] + 3));
2020-05-10 14:25:42 +00:00
const fmt::detail::buffer<char>& const_buffer = buffer;
2014-09-30 14:30:27 +00:00
EXPECT_EQ(42, const_buffer[3]);
}
2020-07-10 14:50:37 +00:00
TEST(BufferTest, TryResize) {
2014-10-01 15:12:10 +00:00
char data[123];
mock_buffer<char> buffer(data, sizeof(data));
2014-10-01 15:12:10 +00:00
buffer[10] = 42;
EXPECT_EQ(42, buffer[10]);
2020-07-10 14:50:37 +00:00
buffer.try_resize(20);
2014-10-01 15:12:10 +00:00
EXPECT_EQ(20u, buffer.size());
EXPECT_EQ(123u, buffer.capacity());
EXPECT_EQ(42, buffer[10]);
2020-07-10 14:50:37 +00:00
buffer.try_resize(5);
2014-10-01 15:12:10 +00:00
EXPECT_EQ(5u, buffer.size());
EXPECT_EQ(123u, buffer.capacity());
EXPECT_EQ(42, buffer[10]);
2020-07-10 14:50:37 +00:00
// Check if try_resize calls grow.
2014-10-01 16:32:31 +00:00
EXPECT_CALL(buffer, do_grow(124));
2020-07-10 14:50:37 +00:00
buffer.try_resize(124);
2014-10-01 16:32:31 +00:00
EXPECT_CALL(buffer, do_grow(200));
2020-07-10 14:50:37 +00:00
buffer.try_resize(200);
}
TEST(BufferTest, TryResizePartial) {
char data[10];
mock_buffer<char> buffer(data, sizeof(data));
EXPECT_CALL(buffer, do_grow(20)).WillOnce(Return(15));
buffer.try_resize(20);
EXPECT_EQ(buffer.capacity(), 15);
EXPECT_EQ(buffer.size(), 15);
2014-10-01 15:12:10 +00:00
}
TEST(BufferTest, Clear) {
2020-07-11 03:54:15 +00:00
mock_buffer<char> buffer;
EXPECT_CALL(buffer, do_grow(20));
2020-07-10 14:50:37 +00:00
buffer.try_resize(20);
buffer.try_resize(0);
EXPECT_EQ(static_cast<size_t>(0), buffer.size());
2014-10-01 15:12:10 +00:00
EXPECT_EQ(20u, buffer.capacity());
}
TEST(BufferTest, Append) {
char data[15];
mock_buffer<char> buffer(data, 10);
2020-07-11 03:54:15 +00:00
auto test = "test";
2014-10-01 15:12:10 +00:00
buffer.append(test, test + 5);
EXPECT_STREQ(test, &buffer[0]);
EXPECT_EQ(5u, buffer.size());
2020-07-10 14:50:37 +00:00
buffer.try_resize(10);
2014-10-01 16:32:31 +00:00
EXPECT_CALL(buffer, do_grow(12));
2014-10-01 15:12:10 +00:00
buffer.append(test, test + 2);
EXPECT_EQ('t', buffer[10]);
EXPECT_EQ('e', buffer[11]);
EXPECT_EQ(12u, buffer.size());
}
TEST(BufferTest, AppendAllocatesEnoughStorage) {
char data[19];
mock_buffer<char> buffer(data, 10);
2020-07-11 03:54:15 +00:00
auto test = "abcdefgh";
2020-07-10 14:50:37 +00:00
buffer.try_resize(10);
2014-10-01 16:32:31 +00:00
EXPECT_CALL(buffer, do_grow(19));
2014-10-01 15:12:10 +00:00
buffer.append(test, test + 9);
}
TEST(ArgTest, FormatArgs) {
2020-07-11 03:54:15 +00:00
auto args = fmt::format_args();
2018-04-21 21:29:24 +00:00
EXPECT_FALSE(args.get(1));
2014-09-25 16:11:51 +00:00
}
2018-01-14 19:00:27 +00:00
struct custom_context {
2020-04-12 14:38:54 +00:00
using char_type = char;
using parse_context_type = fmt::format_parse_context;
2017-08-13 20:09:02 +00:00
2019-01-13 02:27:38 +00:00
template <typename T> struct formatter_type {
template <typename ParseContext>
auto parse(ParseContext& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
const char* format(const T&, custom_context& ctx) {
ctx.called = true;
return nullptr;
}
2017-08-13 20:09:02 +00:00
};
2016-11-07 00:11:24 +00:00
bool called;
fmt::format_parse_context ctx;
2015-12-02 16:41:05 +00:00
fmt::format_parse_context& parse_context() { return ctx; }
2019-01-13 02:27:38 +00:00
void advance_to(const char*) {}
2017-08-13 20:09:02 +00:00
};
2015-12-02 16:41:05 +00:00
TEST(ArgTest, MakeValueWithCustomContext) {
2020-07-11 03:54:15 +00:00
auto t = test_struct();
2020-05-10 14:25:42 +00:00
fmt::detail::value<custom_context> arg(
fmt::detail::arg_mapper<custom_context>().map(t));
custom_context ctx = {false, fmt::format_parse_context("")};
arg.custom.format(&t, ctx.parse_context(), ctx);
2016-11-07 00:11:24 +00:00
EXPECT_TRUE(ctx.called);
2015-12-02 16:41:05 +00:00
}
2018-05-12 15:33:51 +00:00
FMT_BEGIN_NAMESPACE
2020-05-10 14:25:42 +00:00
namespace detail {
2016-12-28 15:55:33 +00:00
template <typename Char>
2017-02-19 14:46:51 +00:00
bool operator==(custom_value<Char> lhs, custom_value<Char> rhs) {
return lhs.value == rhs.value;
}
2020-05-10 14:25:42 +00:00
} // namespace detail
2018-05-12 15:33:51 +00:00
FMT_END_NAMESPACE
2014-07-14 13:55:29 +00:00
2018-03-03 22:04:59 +00:00
// Use a unique result type to make sure that there are no undesirable
// conversions.
struct test_result {};
2019-01-13 02:27:38 +00:00
template <typename T> struct mock_visitor {
2020-07-11 03:54:15 +00:00
template <typename U> struct result { using type = test_result; };
mock_visitor() {
2020-07-10 14:50:37 +00:00
ON_CALL(*this, visit(_)).WillByDefault(Return(test_result()));
}
2019-01-13 02:27:38 +00:00
MOCK_METHOD1_T(visit, test_result(T value));
MOCK_METHOD0_T(unexpected, void());
test_result operator()(T value) { return visit(value); }
2019-01-13 02:27:38 +00:00
template <typename U> test_result operator()(U) {
unexpected();
return test_result();
2014-07-14 14:27:07 +00:00
}
2014-07-14 13:55:29 +00:00
};
2020-07-11 03:54:15 +00:00
template <typename T> struct visit_type { using type = T; };
2020-07-11 03:54:15 +00:00
#define VISIT_TYPE(type_, visit_type_) \
template <> struct visit_type<type_> { using type = visit_type_; }
VISIT_TYPE(signed char, int);
VISIT_TYPE(unsigned char, unsigned);
VISIT_TYPE(short, int);
VISIT_TYPE(unsigned short, unsigned);
#if LONG_MAX == INT_MAX
VISIT_TYPE(long, int);
VISIT_TYPE(unsigned long, unsigned);
#else
2017-08-26 16:09:43 +00:00
VISIT_TYPE(long, long long);
VISIT_TYPE(unsigned long, unsigned long long);
#endif
#define CHECK_ARG_(Char, expected, value) \
{ \
testing::StrictMock<mock_visitor<decltype(expected)>> visitor; \
EXPECT_CALL(visitor, visit(expected)); \
2020-07-11 03:54:15 +00:00
using iterator = std::back_insert_iterator<buffer<Char>>; \
fmt::visit_format_arg( \
visitor, make_arg<fmt::basic_format_context<iterator, Char>>(value)); \
2019-01-13 02:27:38 +00:00
}
2019-01-13 02:27:38 +00:00
#define CHECK_ARG(value, typename_) \
{ \
2020-07-11 03:54:15 +00:00
using value_type = decltype(value); \
typename_ visit_type<value_type>::type expected = value; \
2019-01-13 02:27:38 +00:00
CHECK_ARG_(char, expected, value) \
CHECK_ARG_(wchar_t, expected, value) \
}
2019-01-13 02:27:38 +00:00
template <typename T> class NumericArgTest : public testing::Test {};
2020-07-11 03:54:15 +00:00
using types = ::testing::Types<bool, signed char, unsigned char, signed,
2019-01-13 02:27:38 +00:00
unsigned short, int, unsigned, long, unsigned long,
long long, unsigned long long, float, double,
2020-07-11 03:54:15 +00:00
long double>;
TYPED_TEST_CASE(NumericArgTest, types);
template <typename T>
2020-07-11 03:54:15 +00:00
fmt::enable_if_t<std::is_integral<T>::value, T> test_value() {
return static_cast<T>(42);
}
template <typename T>
2020-07-11 03:54:15 +00:00
fmt::enable_if_t<std::is_floating_point<T>::value, T> test_value() {
return static_cast<T>(4.2);
}
TYPED_TEST(NumericArgTest, MakeAndVisit) {
2018-03-03 22:04:59 +00:00
CHECK_ARG(test_value<TypeParam>(), typename);
CHECK_ARG(std::numeric_limits<TypeParam>::min(), typename);
CHECK_ARG(std::numeric_limits<TypeParam>::max(), typename);
}
TEST(ArgTest, CharArg) {
CHECK_ARG_(char, 'a', 'a');
CHECK_ARG_(wchar_t, L'a', 'a');
CHECK_ARG_(wchar_t, L'a', L'a');
}
TEST(ArgTest, StringArg) {
char str_data[] = "test";
2019-01-13 02:27:38 +00:00
char* str = str_data;
const char* cstr = str;
CHECK_ARG_(char, cstr, str);
2020-07-11 03:54:15 +00:00
auto sref = string_view(str);
2016-12-12 05:13:54 +00:00
CHECK_ARG_(char, sref, std::string(str));
}
TEST(ArgTest, WStringArg) {
wchar_t str_data[] = L"test";
2019-01-13 02:27:38 +00:00
wchar_t* str = str_data;
const wchar_t* cstr = str;
fmt::wstring_view sref(str);
CHECK_ARG_(wchar_t, cstr, str);
CHECK_ARG_(wchar_t, cstr, cstr);
2016-12-12 05:13:54 +00:00
CHECK_ARG_(wchar_t, sref, std::wstring(str));
CHECK_ARG_(wchar_t, sref, fmt::wstring_view(str));
}
TEST(ArgTest, PointerArg) {
void* p = nullptr;
const void* cp = nullptr;
CHECK_ARG_(char, cp, p);
CHECK_ARG_(wchar_t, cp, p);
2018-03-03 22:04:59 +00:00
CHECK_ARG(cp, );
}
2018-03-03 22:04:59 +00:00
struct check_custom {
test_result operator()(
fmt::basic_format_arg<fmt::format_context>::handle h) const {
2020-05-10 14:25:42 +00:00
struct test_buffer : fmt::detail::buffer<char> {
char data[10];
2020-05-10 14:25:42 +00:00
test_buffer() : fmt::detail::buffer<char>(data, 0, 10) {}
2020-05-07 22:59:46 +00:00
void grow(size_t) {}
} buffer;
2019-02-10 03:34:42 +00:00
fmt::format_parse_context parse_ctx("");
2020-07-09 16:04:46 +00:00
fmt::format_context ctx{fmt::detail::buffer_appender<char>(buffer),
fmt::format_args()};
2019-02-10 03:34:42 +00:00
h.format(parse_ctx, ctx);
EXPECT_EQ("test", std::string(buffer.data, buffer.size()));
return test_result();
2018-03-03 22:04:59 +00:00
}
};
TEST(ArgTest, CustomArg) {
test_struct test;
using visitor =
2020-07-09 16:04:46 +00:00
mock_visitor<fmt::basic_format_arg<fmt::format_context>::handle>;
2018-03-03 22:04:59 +00:00
testing::StrictMock<visitor> v;
EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke(check_custom()));
fmt::visit_format_arg(v, make_arg<fmt::format_context>(test));
2014-07-14 13:55:29 +00:00
}
TEST(ArgTest, VisitInvalidArg) {
2019-01-13 02:27:38 +00:00
testing::StrictMock<mock_visitor<fmt::monostate>> visitor;
2016-12-27 15:43:25 +00:00
EXPECT_CALL(visitor, visit(_));
2018-04-08 14:03:44 +00:00
fmt::basic_format_arg<fmt::format_context> arg;
fmt::visit_format_arg(visitor, arg);
2014-07-16 14:55:31 +00:00
}
TEST(FormatDynArgsTest, Basic) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
store.push_back(42);
store.push_back("abc1");
store.push_back(1.5f);
2020-07-11 03:54:15 +00:00
EXPECT_EQ("42 and abc1 and 1.5", fmt::vformat("{} and {} and {}", store));
}
TEST(FormatDynArgsTest, StringsAndRefs) {
// Unfortunately the tests are compiled with old ABI so strings use COW.
fmt::dynamic_format_arg_store<fmt::format_context> store;
char str[] = "1234567890";
store.push_back(str);
store.push_back(std::cref(str));
store.push_back(fmt::string_view{str});
str[0] = 'X';
std::string result = fmt::vformat("{} and {} and {}", store);
EXPECT_EQ("1234567890 and X234567890 and X234567890", result);
}
struct custom_type {
int i = 0;
};
FMT_BEGIN_NAMESPACE
template <> struct formatter<custom_type> {
auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
return ctx.begin();
}
template <typename FormatContext>
auto format(const custom_type& p, FormatContext& ctx) -> decltype(ctx.out()) {
return format_to(ctx.out(), "cust={}", p.i);
}
};
FMT_END_NAMESPACE
TEST(FormatDynArgsTest, CustomFormat) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
custom_type c{};
store.push_back(c);
++c.i;
store.push_back(c);
++c.i;
store.push_back(std::cref(c));
++c.i;
std::string result = fmt::vformat("{} and {} and {}", store);
EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
}
TEST(FormatDynArgsTest, NamedInt) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
store.push_back(fmt::arg("a1", 42));
2020-07-11 03:54:15 +00:00
EXPECT_EQ("42", fmt::vformat("{a1}", store));
}
TEST(FormatDynArgsTest, NamedStrings) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
char str[]{"1234567890"};
store.push_back(fmt::arg("a1", str));
store.push_back(fmt::arg("a2", std::cref(str)));
str[0] = 'X';
2020-07-11 03:54:15 +00:00
EXPECT_EQ("1234567890 and X234567890", fmt::vformat("{a1} and {a2}", store));
}
TEST(FormatDynArgsTest, NamedArgByRef) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
// Note: fmt::arg() constructs an object which holds a reference
// to its value. It's not an aggregate, so it doesn't extend the
// reference lifetime. As a result, it's a very bad idea passing temporary
// as a named argument value. Only GCC with optimization level >0
// complains about this.
//
// A real life usecase is when you have both name and value alive
// guarantee their lifetime and thus don't want them to be copied into
// storages.
int a1_val{42};
auto a1 = fmt::arg("a1_", a1_val);
store.push_back("abc");
store.push_back(1.5f);
store.push_back(std::cref(a1));
2020-05-10 14:25:42 +00:00
std::string result = fmt::vformat("{a1_} and {} and {} and {}", store);
EXPECT_EQ("42 and abc and 1.5 and 42", result);
}
TEST(FormatDynArgsTest, NamedCustomFormat) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
custom_type c{};
store.push_back(fmt::arg("c1", c));
++c.i;
store.push_back(fmt::arg("c2", c));
++c.i;
store.push_back(fmt::arg("c_ref", std::cref(c)));
++c.i;
std::string result = fmt::vformat("{c1} and {c2} and {c_ref}", store);
EXPECT_EQ("cust=0 and cust=1 and cust=3", result);
}
TEST(FormatDynArgsTest, Clear) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
store.push_back(42);
std::string result = fmt::vformat("{}", store);
EXPECT_EQ("42", result);
store.push_back(43);
result = fmt::vformat("{} and {}", store);
EXPECT_EQ("42 and 43", result);
store.clear();
store.push_back(44);
result = fmt::vformat("{}", store);
EXPECT_EQ("44", result);
}
TEST(FormatDynArgsTest, Reserve) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
store.reserve(2, 1);
store.push_back(1.5f);
store.push_back(fmt::arg("a1", 42));
std::string result = fmt::vformat("{a1} and {}", store);
EXPECT_EQ("42 and 1.5", result);
}
struct copy_throwable {
copy_throwable() {}
copy_throwable(const copy_throwable&) { throw "deal with it"; }
};
FMT_BEGIN_NAMESPACE
template <> struct formatter<copy_throwable> {
auto parse(format_parse_context& ctx) const -> decltype(ctx.begin()) {
return ctx.begin();
}
auto format(copy_throwable, format_context& ctx) -> decltype(ctx.out()) {
return ctx.out();
}
};
FMT_END_NAMESPACE
TEST(FormatDynArgsTest, ThrowOnCopy) {
fmt::dynamic_format_arg_store<fmt::format_context> store;
store.push_back(std::string("foo"));
try {
store.push_back(copy_throwable());
} catch (...) {
}
EXPECT_EQ(fmt::vformat("{}", store), "foo");
}
TEST(StringViewTest, ValueType) {
static_assert(std::is_same<string_view::value_type, char>::value, "");
}
TEST(StringViewTest, Length) {
// Test that string_view::size() returns string length, not buffer size.
2015-02-24 17:52:16 +00:00
char str[100] = "some string";
EXPECT_EQ(std::strlen(str), string_view(str).size());
2015-02-24 17:52:16 +00:00
EXPECT_LT(std::strlen(str), sizeof(str));
2014-10-30 13:27:44 +00:00
}
// Check string_view's comparison operator.
2019-01-13 02:27:38 +00:00
template <template <typename> class Op> void check_op() {
const char* inputs[] = {"foo", "fop", "fo"};
2020-05-07 22:59:46 +00:00
size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
for (size_t i = 0; i < num_inputs; ++i) {
for (size_t j = 0; j < num_inputs; ++j) {
string_view lhs(inputs[i]), rhs(inputs[j]);
EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<string_view>()(lhs, rhs));
}
}
}
TEST(StringViewTest, Compare) {
EXPECT_EQ(string_view("foo").compare(string_view("foo")), 0);
EXPECT_GT(string_view("fop").compare(string_view("foo")), 0);
EXPECT_LT(string_view("foo").compare(string_view("fop")), 0);
EXPECT_GT(string_view("foo").compare(string_view("fo")), 0);
EXPECT_LT(string_view("fo").compare(string_view("foo")), 0);
check_op<std::equal_to>();
check_op<std::not_equal_to>();
check_op<std::less>();
check_op<std::less_equal>();
check_op<std::greater>();
check_op<std::greater_equal>();
}
2019-06-07 14:08:04 +00:00
struct enabled_formatter {};
struct disabled_formatter {};
struct disabled_formatter_convertible {
operator int() const { return 42; }
};
FMT_BEGIN_NAMESPACE
template <> struct formatter<enabled_formatter> {
auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
auto format(enabled_formatter, format_context& ctx) -> decltype(ctx.out()) {
return ctx.out();
}
};
FMT_END_NAMESPACE
TEST(CoreTest, HasFormatter) {
using fmt::has_formatter;
2019-06-07 14:08:04 +00:00
using context = fmt::format_context;
static_assert(has_formatter<enabled_formatter, context>::value, "");
static_assert(!has_formatter<disabled_formatter, context>::value, "");
2019-12-21 21:10:45 +00:00
static_assert(!has_formatter<disabled_formatter_convertible, context>::value,
"");
}
struct convertible_to_int {
operator int() const { return 42; }
};
struct convertible_to_c_string {
operator const char*() const { return "foo"; }
};
FMT_BEGIN_NAMESPACE
template <> struct formatter<convertible_to_int> {
auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
auto format(convertible_to_int, format_context& ctx) -> decltype(ctx.out()) {
return std::copy_n("foo", 3, ctx.out());
}
};
template <> struct formatter<convertible_to_c_string> {
auto parse(format_parse_context& ctx) -> decltype(ctx.begin()) {
return ctx.begin();
}
auto format(convertible_to_c_string, format_context& ctx)
-> decltype(ctx.out()) {
return std::copy_n("bar", 3, ctx.out());
}
};
FMT_END_NAMESPACE
TEST(CoreTest, FormatterOverridesImplicitConversion) {
EXPECT_EQ(fmt::format("{}", convertible_to_int()), "foo");
EXPECT_EQ(fmt::format("{}", convertible_to_c_string()), "bar");
}
namespace my_ns {
2019-01-13 02:27:38 +00:00
template <typename Char> class my_string {
2020-07-11 03:54:15 +00:00
private:
std::basic_string<Char> s_;
public:
2019-01-13 02:27:38 +00:00
my_string(const Char* s) : s_(s) {}
const Char* data() const FMT_NOEXCEPT { return s_.data(); }
2020-05-07 22:59:46 +00:00
size_t length() const FMT_NOEXCEPT { return s_.size(); }
operator const Char*() const { return s_.c_str(); }
};
template <typename Char>
2019-01-13 02:27:38 +00:00
inline fmt::basic_string_view<Char> to_string_view(const my_string<Char>& s)
FMT_NOEXCEPT {
return {s.data(), s.length()};
}
struct non_string {};
2019-01-13 02:27:38 +00:00
} // namespace my_ns
2019-01-13 02:27:38 +00:00
template <typename T> class IsStringTest : public testing::Test {};
typedef ::testing::Types<char, wchar_t, char16_t, char32_t> StringCharTypes;
TYPED_TEST_CASE(IsStringTest, StringCharTypes);
namespace {
template <typename Char>
struct derived_from_string_view : fmt::basic_string_view<Char> {};
2019-01-13 02:27:38 +00:00
} // namespace
TYPED_TEST(IsStringTest, IsString) {
2020-05-10 14:25:42 +00:00
EXPECT_TRUE(fmt::detail::is_string<TypeParam*>::value);
EXPECT_TRUE(fmt::detail::is_string<const TypeParam*>::value);
EXPECT_TRUE(fmt::detail::is_string<TypeParam[2]>::value);
EXPECT_TRUE(fmt::detail::is_string<const TypeParam[2]>::value);
EXPECT_TRUE(fmt::detail::is_string<std::basic_string<TypeParam>>::value);
EXPECT_TRUE(fmt::detail::is_string<fmt::basic_string_view<TypeParam>>::value);
EXPECT_TRUE(
2020-05-10 14:25:42 +00:00
fmt::detail::is_string<derived_from_string_view<TypeParam>>::value);
using string_view = fmt::detail::std_string_view<TypeParam>;
2019-05-31 03:50:07 +00:00
EXPECT_TRUE(std::is_empty<string_view>::value !=
2020-05-10 14:25:42 +00:00
fmt::detail::is_string<string_view>::value);
EXPECT_TRUE(fmt::detail::is_string<my_ns::my_string<TypeParam>>::value);
EXPECT_FALSE(fmt::detail::is_string<my_ns::non_string>::value);
}
TEST(CoreTest, Format) {
// This should work without including fmt/format.h.
#ifdef FMT_FORMAT_H_
2019-01-13 02:27:38 +00:00
# error fmt/format.h must not be included in the core test
#endif
EXPECT_EQ(fmt::format("{}", 42), "42");
}
2018-10-25 01:42:42 +00:00
TEST(CoreTest, FormatTo) {
// This should work without including fmt/format.h.
#ifdef FMT_FORMAT_H_
2019-01-13 02:27:38 +00:00
# error fmt/format.h must not be included in the core test
2018-10-25 01:42:42 +00:00
#endif
std::string s;
fmt::format_to(std::back_inserter(s), "{}", 42);
EXPECT_EQ(s, "42");
}
TEST(CoreTest, ToStringViewForeignStrings) {
using namespace my_ns;
EXPECT_EQ(to_string_view(my_string<char>("42")), "42");
2020-05-10 14:25:42 +00:00
fmt::detail::type type =
fmt::detail::mapped_type_constant<my_string<char>,
fmt::format_context>::value;
EXPECT_EQ(type, fmt::detail::type::string_type);
}
TEST(CoreTest, FormatForeignStrings) {
using namespace my_ns;
EXPECT_EQ(fmt::format(my_string<char>("{}"), 42), "42");
}
2018-10-28 00:10:19 +00:00
2019-06-10 04:10:09 +00:00
struct implicitly_convertible_to_string {
operator std::string() const { return "foo"; }
};
2018-10-28 00:10:19 +00:00
struct implicitly_convertible_to_string_view {
operator fmt::string_view() const { return "foo"; }
};
2020-07-11 03:54:15 +00:00
TEST(CoreTest, FormatImplicitlyConvertibleToStringView) {
2018-10-28 00:10:19 +00:00
EXPECT_EQ("foo", fmt::format("{}", implicitly_convertible_to_string_view()));
}
// std::is_constructible is broken in MSVC until version 2015.
#if !FMT_MSC_VER || FMT_MSC_VER >= 1900
2018-10-28 00:10:19 +00:00
struct explicitly_convertible_to_string_view {
explicit operator fmt::string_view() const { return "foo"; }
};
2020-07-11 03:54:15 +00:00
TEST(CoreTest, FormatExplicitlyConvertibleToStringView) {
2018-10-28 00:10:19 +00:00
EXPECT_EQ("foo", fmt::format("{}", explicitly_convertible_to_string_view()));
}
2019-12-21 21:10:45 +00:00
# ifdef FMT_USE_STRING_VIEW
struct explicitly_convertible_to_std_string_view {
explicit operator std::string_view() const { return "foo"; }
};
2020-07-11 03:54:15 +00:00
TEST(CoreTest, FormatExplicitlyConvertibleToStdStringView) {
EXPECT_EQ("foo",
fmt::format("{}", explicitly_convertible_to_std_string_view()));
}
2019-12-21 21:10:45 +00:00
# endif
2018-10-28 00:10:19 +00:00
#endif
struct disabled_rvalue_conversion {
operator const char*() const& { return "foo"; }
2019-12-21 21:10:45 +00:00
operator const char*() & { return "foo"; }
operator const char*() const&& = delete;
2019-12-21 21:10:45 +00:00
operator const char*() && = delete;
};
2020-07-11 03:54:15 +00:00
TEST(CoreTest, DisabledRValueConversion) {
EXPECT_EQ("foo", fmt::format("{}", disabled_rvalue_conversion()));
}