mirror of
https://github.com/fmtlib/fmt.git
synced 2024-12-25 15:21:54 +00:00
925 lines
28 KiB
C++
925 lines
28 KiB
C++
/*
|
|
Utility tests.
|
|
|
|
Copyright (c) 2012-2014, Victor Zverovich
|
|
All rights reserved.
|
|
|
|
Redistribution and use in source and binary forms, with or without
|
|
modification, are permitted provided that the following conditions are met:
|
|
|
|
1. Redistributions of source code must retain the above copyright notice, this
|
|
list of conditions and the following disclaimer.
|
|
2. Redistributions in binary form must reproduce the above copyright notice,
|
|
this list of conditions and the following disclaimer in the documentation
|
|
and/or other materials provided with the distribution.
|
|
|
|
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
|
|
ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
|
|
WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
|
|
ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
|
|
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
|
|
LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
|
|
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
|
|
(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
|
|
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*/
|
|
|
|
#include "test-assert.h"
|
|
|
|
#include <cfloat>
|
|
#include <climits>
|
|
#include <cstring>
|
|
#include <functional>
|
|
#include <limits>
|
|
|
|
#if FMT_USE_TYPE_TRAITS
|
|
# include <type_traits>
|
|
#endif
|
|
|
|
#include "gmock/gmock.h"
|
|
#include "gtest-extra.h"
|
|
#include "mock-allocator.h"
|
|
#include "util.h"
|
|
|
|
// Check if format.h compiles with windows.h included.
|
|
#ifdef _WIN32
|
|
# include <windows.h>
|
|
#endif
|
|
|
|
#include "fmt/format.h"
|
|
|
|
#undef max
|
|
|
|
using fmt::StringRef;
|
|
using fmt::internal::Arg;
|
|
using fmt::Buffer;
|
|
using fmt::internal::MemoryBuffer;
|
|
|
|
using testing::Return;
|
|
using testing::StrictMock;
|
|
|
|
namespace {
|
|
|
|
struct Test {};
|
|
|
|
template <typename Char>
|
|
void format_value(fmt::BasicWriter<Char> &w, Test,
|
|
fmt::basic_format_context<Char> &) {
|
|
w << "test";
|
|
}
|
|
|
|
template <typename Char, typename T>
|
|
Arg make_arg(const T &value) {
|
|
typedef fmt::internal::MakeValue< fmt::basic_format_context<Char> > MakeValue;
|
|
Arg arg = MakeValue(value);
|
|
arg.type = fmt::internal::type<T>();
|
|
return arg;
|
|
}
|
|
} // namespace
|
|
|
|
void CheckForwarding(
|
|
MockAllocator<int> &alloc, AllocatorRef< MockAllocator<int> > &ref) {
|
|
int mem;
|
|
// Check if value_type is properly defined.
|
|
AllocatorRef< MockAllocator<int> >::value_type *ptr = &mem;
|
|
// Check forwarding.
|
|
EXPECT_CALL(alloc, allocate(42)).WillOnce(Return(ptr));
|
|
ref.allocate(42);
|
|
EXPECT_CALL(alloc, deallocate(ptr, 42));
|
|
ref.deallocate(ptr, 42);
|
|
}
|
|
|
|
TEST(AllocatorTest, AllocatorRef) {
|
|
StrictMock< MockAllocator<int> > alloc;
|
|
typedef AllocatorRef< MockAllocator<int> > TestAllocatorRef;
|
|
TestAllocatorRef ref(&alloc);
|
|
// Check if AllocatorRef forwards to the underlying allocator.
|
|
CheckForwarding(alloc, ref);
|
|
TestAllocatorRef ref2(ref);
|
|
CheckForwarding(alloc, ref2);
|
|
TestAllocatorRef ref3;
|
|
EXPECT_EQ(0, ref3.get());
|
|
ref3 = ref;
|
|
CheckForwarding(alloc, ref3);
|
|
}
|
|
|
|
#if FMT_USE_TYPE_TRAITS
|
|
TEST(BufferTest, Noncopyable) {
|
|
EXPECT_FALSE(std::is_copy_constructible<Buffer<char> >::value);
|
|
EXPECT_FALSE(std::is_copy_assignable<Buffer<char> >::value);
|
|
}
|
|
|
|
TEST(BufferTest, Nonmoveable) {
|
|
EXPECT_FALSE(std::is_move_constructible<Buffer<char> >::value);
|
|
EXPECT_FALSE(std::is_move_assignable<Buffer<char> >::value);
|
|
}
|
|
#endif
|
|
|
|
// A test buffer with a dummy grow method.
|
|
template <typename T>
|
|
struct TestBuffer : Buffer<T> {
|
|
void grow(std::size_t size) { this->capacity_ = size; }
|
|
};
|
|
|
|
template <typename T>
|
|
struct MockBuffer : Buffer<T> {
|
|
MOCK_METHOD1(do_grow, void (std::size_t size));
|
|
|
|
void grow(std::size_t size) {
|
|
this->capacity_ = size;
|
|
do_grow(size);
|
|
}
|
|
|
|
MockBuffer() {}
|
|
MockBuffer(T *ptr) : Buffer<T>(ptr) {}
|
|
MockBuffer(T *ptr, std::size_t capacity) : Buffer<T>(ptr, capacity) {}
|
|
};
|
|
|
|
TEST(BufferTest, Ctor) {
|
|
{
|
|
MockBuffer<int> buffer;
|
|
EXPECT_EQ(0, &buffer[0]);
|
|
EXPECT_EQ(0u, buffer.size());
|
|
EXPECT_EQ(0u, buffer.capacity());
|
|
}
|
|
{
|
|
int dummy;
|
|
MockBuffer<int> buffer(&dummy);
|
|
EXPECT_EQ(&dummy, &buffer[0]);
|
|
EXPECT_EQ(0u, buffer.size());
|
|
EXPECT_EQ(0u, buffer.capacity());
|
|
}
|
|
{
|
|
int dummy;
|
|
std::size_t capacity = std::numeric_limits<std::size_t>::max();
|
|
MockBuffer<int> buffer(&dummy, capacity);
|
|
EXPECT_EQ(&dummy, &buffer[0]);
|
|
EXPECT_EQ(0u, buffer.size());
|
|
EXPECT_EQ(capacity, buffer.capacity());
|
|
}
|
|
}
|
|
|
|
struct DyingBuffer : TestBuffer<int> {
|
|
MOCK_METHOD0(die, void());
|
|
~DyingBuffer() { die(); }
|
|
};
|
|
|
|
TEST(BufferTest, VirtualDtor) {
|
|
typedef StrictMock<DyingBuffer> StictMockBuffer;
|
|
StictMockBuffer *mock_buffer = new StictMockBuffer();
|
|
EXPECT_CALL(*mock_buffer, die());
|
|
Buffer<int> *buffer = mock_buffer;
|
|
delete buffer;
|
|
}
|
|
|
|
TEST(BufferTest, Access) {
|
|
char data[10];
|
|
MockBuffer<char> buffer(data, sizeof(data));
|
|
buffer[0] = 11;
|
|
EXPECT_EQ(11, buffer[0]);
|
|
buffer[3] = 42;
|
|
EXPECT_EQ(42, *(&buffer[0] + 3));
|
|
const Buffer<char> &const_buffer = buffer;
|
|
EXPECT_EQ(42, const_buffer[3]);
|
|
}
|
|
|
|
TEST(BufferTest, Resize) {
|
|
char data[123];
|
|
MockBuffer<char> buffer(data, sizeof(data));
|
|
buffer[10] = 42;
|
|
EXPECT_EQ(42, buffer[10]);
|
|
buffer.resize(20);
|
|
EXPECT_EQ(20u, buffer.size());
|
|
EXPECT_EQ(123u, buffer.capacity());
|
|
EXPECT_EQ(42, buffer[10]);
|
|
buffer.resize(5);
|
|
EXPECT_EQ(5u, buffer.size());
|
|
EXPECT_EQ(123u, buffer.capacity());
|
|
EXPECT_EQ(42, buffer[10]);
|
|
// Check if resize calls grow.
|
|
EXPECT_CALL(buffer, do_grow(124));
|
|
buffer.resize(124);
|
|
EXPECT_CALL(buffer, do_grow(200));
|
|
buffer.resize(200);
|
|
}
|
|
|
|
TEST(BufferTest, Clear) {
|
|
TestBuffer<char> buffer;
|
|
buffer.resize(20);
|
|
buffer.clear();
|
|
EXPECT_EQ(0u, buffer.size());
|
|
EXPECT_EQ(20u, buffer.capacity());
|
|
}
|
|
|
|
TEST(BufferTest, PushBack) {
|
|
int data[15];
|
|
MockBuffer<int> buffer(data, 10);
|
|
buffer.push_back(11);
|
|
EXPECT_EQ(11, buffer[0]);
|
|
EXPECT_EQ(1u, buffer.size());
|
|
buffer.resize(10);
|
|
EXPECT_CALL(buffer, do_grow(11));
|
|
buffer.push_back(22);
|
|
EXPECT_EQ(22, buffer[10]);
|
|
EXPECT_EQ(11u, buffer.size());
|
|
}
|
|
|
|
TEST(BufferTest, Append) {
|
|
char data[15];
|
|
MockBuffer<char> buffer(data, 10);
|
|
const char *test = "test";
|
|
buffer.append(test, test + 5);
|
|
EXPECT_STREQ(test, &buffer[0]);
|
|
EXPECT_EQ(5u, buffer.size());
|
|
buffer.resize(10);
|
|
EXPECT_CALL(buffer, do_grow(12));
|
|
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];
|
|
MockBuffer<char> buffer(data, 10);
|
|
const char *test = "abcdefgh";
|
|
buffer.resize(10);
|
|
EXPECT_CALL(buffer, do_grow(19));
|
|
buffer.append(test, test + 9);
|
|
}
|
|
|
|
TEST(MemoryBufferTest, Ctor) {
|
|
MemoryBuffer<char, 123> buffer;
|
|
EXPECT_EQ(0u, buffer.size());
|
|
EXPECT_EQ(123u, buffer.capacity());
|
|
}
|
|
|
|
#if FMT_USE_RVALUE_REFERENCES
|
|
|
|
typedef AllocatorRef< std::allocator<char> > TestAllocator;
|
|
|
|
void check_move_buffer(const char *str,
|
|
MemoryBuffer<char, 5, TestAllocator> &buffer) {
|
|
std::allocator<char> *alloc = buffer.get_allocator().get();
|
|
MemoryBuffer<char, 5, TestAllocator> buffer2(std::move(buffer));
|
|
// Move shouldn't destroy the inline content of the first buffer.
|
|
EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
|
|
EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
|
|
EXPECT_EQ(5u, buffer2.capacity());
|
|
// Move should transfer allocator.
|
|
EXPECT_EQ(0, buffer.get_allocator().get());
|
|
EXPECT_EQ(alloc, buffer2.get_allocator().get());
|
|
}
|
|
|
|
TEST(MemoryBufferTest, MoveCtor) {
|
|
std::allocator<char> alloc;
|
|
MemoryBuffer<char, 5, TestAllocator> buffer((TestAllocator(&alloc)));
|
|
const char test[] = "test";
|
|
buffer.append(test, test + 4);
|
|
check_move_buffer("test", buffer);
|
|
// Adding one more character fills the inline buffer, but doesn't cause
|
|
// dynamic allocation.
|
|
buffer.push_back('a');
|
|
check_move_buffer("testa", buffer);
|
|
const char *inline_buffer_ptr = &buffer[0];
|
|
// Adding one more character causes the content to move from the inline to
|
|
// a dynamically allocated buffer.
|
|
buffer.push_back('b');
|
|
MemoryBuffer<char, 5, TestAllocator> buffer2(std::move(buffer));
|
|
// Move should rip the guts of the first buffer.
|
|
EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
|
|
EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
|
|
EXPECT_GT(buffer2.capacity(), 5u);
|
|
}
|
|
|
|
void check_move_assign_buffer(const char *str, MemoryBuffer<char, 5> &buffer) {
|
|
MemoryBuffer<char, 5> buffer2;
|
|
buffer2 = std::move(buffer);
|
|
// Move shouldn't destroy the inline content of the first buffer.
|
|
EXPECT_EQ(str, std::string(&buffer[0], buffer.size()));
|
|
EXPECT_EQ(str, std::string(&buffer2[0], buffer2.size()));
|
|
EXPECT_EQ(5u, buffer2.capacity());
|
|
}
|
|
|
|
TEST(MemoryBufferTest, MoveAssignment) {
|
|
MemoryBuffer<char, 5> buffer;
|
|
const char test[] = "test";
|
|
buffer.append(test, test + 4);
|
|
check_move_assign_buffer("test", buffer);
|
|
// Adding one more character fills the inline buffer, but doesn't cause
|
|
// dynamic allocation.
|
|
buffer.push_back('a');
|
|
check_move_assign_buffer("testa", buffer);
|
|
const char *inline_buffer_ptr = &buffer[0];
|
|
// Adding one more character causes the content to move from the inline to
|
|
// a dynamically allocated buffer.
|
|
buffer.push_back('b');
|
|
MemoryBuffer<char, 5> buffer2;
|
|
buffer2 = std::move(buffer);
|
|
// Move should rip the guts of the first buffer.
|
|
EXPECT_EQ(inline_buffer_ptr, &buffer[0]);
|
|
EXPECT_EQ("testab", std::string(&buffer2[0], buffer2.size()));
|
|
EXPECT_GT(buffer2.capacity(), 5u);
|
|
}
|
|
|
|
#endif // FMT_USE_RVALUE_REFERENCES
|
|
|
|
TEST(MemoryBufferTest, Grow) {
|
|
typedef AllocatorRef< MockAllocator<int> > Allocator;
|
|
typedef MemoryBuffer<int, 10, Allocator> Base;
|
|
MockAllocator<int> alloc;
|
|
struct TestMemoryBuffer : Base {
|
|
TestMemoryBuffer(Allocator alloc) : Base(alloc) {}
|
|
void grow(std::size_t size) { Base::grow(size); }
|
|
} buffer((Allocator(&alloc)));
|
|
buffer.resize(7);
|
|
using fmt::internal::to_unsigned;
|
|
for (int i = 0; i < 7; ++i)
|
|
buffer[to_unsigned(i)] = i * i;
|
|
EXPECT_EQ(10u, buffer.capacity());
|
|
int mem[20];
|
|
mem[7] = 0xdead;
|
|
EXPECT_CALL(alloc, allocate(20)).WillOnce(Return(mem));
|
|
buffer.grow(20);
|
|
EXPECT_EQ(20u, buffer.capacity());
|
|
// Check if size elements have been copied
|
|
for (int i = 0; i < 7; ++i)
|
|
EXPECT_EQ(i * i, buffer[to_unsigned(i)]);
|
|
// and no more than that.
|
|
EXPECT_EQ(0xdead, buffer[7]);
|
|
EXPECT_CALL(alloc, deallocate(mem, 20));
|
|
}
|
|
|
|
TEST(MemoryBufferTest, Allocator) {
|
|
typedef AllocatorRef< MockAllocator<char> > TestAllocator;
|
|
MemoryBuffer<char, 10, TestAllocator> buffer;
|
|
EXPECT_EQ(0, buffer.get_allocator().get());
|
|
StrictMock< MockAllocator<char> > alloc;
|
|
char mem;
|
|
{
|
|
MemoryBuffer<char, 10, TestAllocator> buffer2((TestAllocator(&alloc)));
|
|
EXPECT_EQ(&alloc, buffer2.get_allocator().get());
|
|
std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
|
|
EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem));
|
|
buffer2.reserve(size);
|
|
EXPECT_CALL(alloc, deallocate(&mem, size));
|
|
}
|
|
}
|
|
|
|
TEST(MemoryBufferTest, ExceptionInDeallocate) {
|
|
typedef AllocatorRef< MockAllocator<char> > TestAllocator;
|
|
StrictMock< MockAllocator<char> > alloc;
|
|
MemoryBuffer<char, 10, TestAllocator> buffer((TestAllocator(&alloc)));
|
|
std::size_t size = 2 * fmt::internal::INLINE_BUFFER_SIZE;
|
|
std::vector<char> mem(size);
|
|
{
|
|
EXPECT_CALL(alloc, allocate(size)).WillOnce(Return(&mem[0]));
|
|
buffer.resize(size);
|
|
std::fill(&buffer[0], &buffer[0] + size, 'x');
|
|
}
|
|
std::vector<char> mem2(2 * size);
|
|
{
|
|
EXPECT_CALL(alloc, allocate(2 * size)).WillOnce(Return(&mem2[0]));
|
|
std::exception e;
|
|
EXPECT_CALL(alloc, deallocate(&mem[0], size)).WillOnce(testing::Throw(e));
|
|
EXPECT_THROW(buffer.reserve(2 * size), std::exception);
|
|
EXPECT_EQ(&mem2[0], &buffer[0]);
|
|
// Check that the data has been copied.
|
|
for (std::size_t i = 0; i < size; ++i)
|
|
EXPECT_EQ('x', buffer[i]);
|
|
}
|
|
EXPECT_CALL(alloc, deallocate(&mem2[0], 2 * size));
|
|
}
|
|
|
|
TEST(UtilTest, Increment) {
|
|
char s[10] = "123";
|
|
increment(s);
|
|
EXPECT_STREQ("124", s);
|
|
s[2] = '8';
|
|
increment(s);
|
|
EXPECT_STREQ("129", s);
|
|
increment(s);
|
|
EXPECT_STREQ("130", s);
|
|
s[1] = s[2] = '9';
|
|
increment(s);
|
|
EXPECT_STREQ("200", s);
|
|
}
|
|
|
|
template <Arg::Type>
|
|
struct ArgInfo;
|
|
|
|
#define ARG_INFO(type_code, Type, field) \
|
|
template <> \
|
|
struct ArgInfo<Arg::type_code> { \
|
|
static Type get(const Arg &arg) { return arg.field; } \
|
|
}
|
|
|
|
ARG_INFO(INT, int, int_value);
|
|
ARG_INFO(UINT, unsigned, uint_value);
|
|
ARG_INFO(LONG_LONG, fmt::LongLong, long_long_value);
|
|
ARG_INFO(ULONG_LONG, fmt::ULongLong, ulong_long_value);
|
|
ARG_INFO(BOOL, int, int_value);
|
|
ARG_INFO(CHAR, int, int_value);
|
|
ARG_INFO(DOUBLE, double, double_value);
|
|
ARG_INFO(LONG_DOUBLE, long double, long_double_value);
|
|
ARG_INFO(CSTRING, const char *, string.value);
|
|
ARG_INFO(STRING, const char *, string.value);
|
|
ARG_INFO(WSTRING, const wchar_t *, wstring.value);
|
|
ARG_INFO(POINTER, const void *, pointer);
|
|
ARG_INFO(CUSTOM, Arg::CustomValue, custom);
|
|
|
|
#define CHECK_ARG_INFO(Type, field, value) { \
|
|
Arg arg = Arg(); \
|
|
arg.field = value; \
|
|
EXPECT_EQ(value, ArgInfo<Arg::Type>::get(arg)); \
|
|
}
|
|
|
|
TEST(ArgTest, ArgInfo) {
|
|
CHECK_ARG_INFO(INT, int_value, 42);
|
|
CHECK_ARG_INFO(UINT, uint_value, 42u);
|
|
CHECK_ARG_INFO(LONG_LONG, long_long_value, 42);
|
|
CHECK_ARG_INFO(ULONG_LONG, ulong_long_value, 42u);
|
|
CHECK_ARG_INFO(DOUBLE, double_value, 4.2);
|
|
CHECK_ARG_INFO(LONG_DOUBLE, long_double_value, 4.2);
|
|
CHECK_ARG_INFO(CHAR, int_value, 'x');
|
|
const char STR[] = "abc";
|
|
CHECK_ARG_INFO(CSTRING, string.value, STR);
|
|
const wchar_t WSTR[] = L"abc";
|
|
CHECK_ARG_INFO(WSTRING, wstring.value, WSTR);
|
|
int p = 0;
|
|
CHECK_ARG_INFO(POINTER, pointer, &p);
|
|
Arg arg = Arg();
|
|
arg.custom.value = &p;
|
|
EXPECT_EQ(&p, ArgInfo<Arg::CUSTOM>::get(arg).value);
|
|
}
|
|
|
|
#define EXPECT_ARG_(Char, type_code, MakeArgType, ExpectedType, value) { \
|
|
MakeArgType input = static_cast<MakeArgType>(value); \
|
|
Arg arg = make_arg<Char>(input); \
|
|
EXPECT_EQ(Arg::type_code, arg.type); \
|
|
ExpectedType expected_value = static_cast<ExpectedType>(value); \
|
|
EXPECT_EQ(expected_value, ArgInfo<Arg::type_code>::get(arg)); \
|
|
}
|
|
|
|
#define EXPECT_ARG(type_code, Type, value) \
|
|
EXPECT_ARG_(char, type_code, Type, Type, value)
|
|
|
|
#define EXPECT_ARGW(type_code, Type, value) \
|
|
EXPECT_ARG_(wchar_t, type_code, Type, Type, value)
|
|
|
|
TEST(ArgTest, MakeArg) {
|
|
// Test bool.
|
|
EXPECT_ARG_(char, BOOL, bool, int, true);
|
|
EXPECT_ARG_(wchar_t, BOOL, bool, int, true);
|
|
|
|
// Test char.
|
|
EXPECT_ARG(CHAR, char, 'a');
|
|
EXPECT_ARG(CHAR, char, CHAR_MIN);
|
|
EXPECT_ARG(CHAR, char, CHAR_MAX);
|
|
|
|
// Test wchar_t.
|
|
EXPECT_ARGW(CHAR, wchar_t, L'a');
|
|
EXPECT_ARGW(CHAR, wchar_t, WCHAR_MIN);
|
|
EXPECT_ARGW(CHAR, wchar_t, WCHAR_MAX);
|
|
|
|
// Test signed/unsigned char.
|
|
EXPECT_ARG(INT, signed char, 42);
|
|
EXPECT_ARG(INT, signed char, SCHAR_MIN);
|
|
EXPECT_ARG(INT, signed char, SCHAR_MAX);
|
|
EXPECT_ARG(UINT, unsigned char, 42);
|
|
EXPECT_ARG(UINT, unsigned char, UCHAR_MAX );
|
|
|
|
// Test short.
|
|
EXPECT_ARG(INT, short, 42);
|
|
EXPECT_ARG(INT, short, SHRT_MIN);
|
|
EXPECT_ARG(INT, short, SHRT_MAX);
|
|
EXPECT_ARG(UINT, unsigned short, 42);
|
|
EXPECT_ARG(UINT, unsigned short, USHRT_MAX);
|
|
|
|
// Test int.
|
|
EXPECT_ARG(INT, int, 42);
|
|
EXPECT_ARG(INT, int, INT_MIN);
|
|
EXPECT_ARG(INT, int, INT_MAX);
|
|
EXPECT_ARG(UINT, unsigned, 42);
|
|
EXPECT_ARG(UINT, unsigned, UINT_MAX);
|
|
|
|
// Test long.
|
|
#if LONG_MAX == INT_MAX
|
|
# define LONG INT
|
|
# define ULONG UINT
|
|
# define long_value int_value
|
|
# define ulong_value uint_value
|
|
#else
|
|
# define LONG LONG_LONG
|
|
# define ULONG ULONG_LONG
|
|
# define long_value long_long_value
|
|
# define ulong_value ulong_long_value
|
|
#endif
|
|
EXPECT_ARG(LONG, long, 42);
|
|
EXPECT_ARG(LONG, long, LONG_MIN);
|
|
EXPECT_ARG(LONG, long, LONG_MAX);
|
|
EXPECT_ARG(ULONG, unsigned long, 42);
|
|
EXPECT_ARG(ULONG, unsigned long, ULONG_MAX);
|
|
|
|
// Test long long.
|
|
EXPECT_ARG(LONG_LONG, fmt::LongLong, 42);
|
|
EXPECT_ARG(LONG_LONG, fmt::LongLong, LLONG_MIN);
|
|
EXPECT_ARG(LONG_LONG, fmt::LongLong, LLONG_MAX);
|
|
EXPECT_ARG(ULONG_LONG, fmt::ULongLong, 42);
|
|
EXPECT_ARG(ULONG_LONG, fmt::ULongLong, ULLONG_MAX);
|
|
|
|
// Test float.
|
|
EXPECT_ARG(DOUBLE, float, 4.2);
|
|
EXPECT_ARG(DOUBLE, float, FLT_MIN);
|
|
EXPECT_ARG(DOUBLE, float, FLT_MAX);
|
|
|
|
// Test double.
|
|
EXPECT_ARG(DOUBLE, double, 4.2);
|
|
EXPECT_ARG(DOUBLE, double, DBL_MIN);
|
|
EXPECT_ARG(DOUBLE, double, DBL_MAX);
|
|
|
|
// Test long double.
|
|
EXPECT_ARG(LONG_DOUBLE, long double, 4.2);
|
|
EXPECT_ARG(LONG_DOUBLE, long double, LDBL_MIN);
|
|
EXPECT_ARG(LONG_DOUBLE, long double, LDBL_MAX);
|
|
|
|
// Test string.
|
|
char STR[] = "test";
|
|
EXPECT_ARG(CSTRING, char*, STR);
|
|
EXPECT_ARG(CSTRING, const char*, STR);
|
|
EXPECT_ARG(STRING, std::string, STR);
|
|
EXPECT_ARG(STRING, fmt::StringRef, STR);
|
|
|
|
// Test wide string.
|
|
wchar_t WSTR[] = L"test";
|
|
EXPECT_ARGW(WSTRING, wchar_t*, WSTR);
|
|
EXPECT_ARGW(WSTRING, const wchar_t*, WSTR);
|
|
EXPECT_ARGW(WSTRING, std::wstring, WSTR);
|
|
EXPECT_ARGW(WSTRING, fmt::WStringRef, WSTR);
|
|
|
|
int n = 42;
|
|
EXPECT_ARG(POINTER, void*, &n);
|
|
EXPECT_ARG(POINTER, const void*, &n);
|
|
|
|
::Test t;
|
|
Arg arg = make_arg<char>(t);
|
|
EXPECT_EQ(fmt::internal::Arg::CUSTOM, arg.type);
|
|
EXPECT_EQ(&t, arg.custom.value);
|
|
fmt::MemoryWriter w;
|
|
fmt::format_context ctx("}", fmt::format_args());
|
|
arg.custom.format(&w, &t, &ctx);
|
|
EXPECT_EQ("test", w.str());
|
|
}
|
|
|
|
TEST(UtilTest, FormatArgs) {
|
|
fmt::format_args args;
|
|
EXPECT_EQ(Arg::NONE, args[1].type);
|
|
}
|
|
|
|
struct CustomFormatter {
|
|
typedef char char_type;
|
|
bool called;
|
|
};
|
|
|
|
void format_value(fmt::Writer &, const Test &, CustomFormatter &ctx) {
|
|
ctx.called = true;
|
|
}
|
|
|
|
TEST(UtilTest, MakeValueWithCustomFormatter) {
|
|
::Test t;
|
|
Arg arg = fmt::internal::MakeValue<CustomFormatter>(t);
|
|
CustomFormatter ctx = {false};
|
|
fmt::MemoryWriter w;
|
|
arg.custom.format(&w, &t, &ctx);
|
|
EXPECT_TRUE(ctx.called);
|
|
}
|
|
|
|
struct Result {
|
|
Arg arg;
|
|
|
|
Result() : arg(make_arg<char>(0xdeadbeef)) {}
|
|
|
|
template <typename T>
|
|
Result(const T& value) : arg(make_arg<char>(value)) {}
|
|
Result(const wchar_t *s) : arg(make_arg<wchar_t>(s)) {}
|
|
};
|
|
|
|
struct TestVisitor {
|
|
Result operator()(int value) { return value; }
|
|
Result operator()(unsigned value) { return value; }
|
|
Result operator()(fmt::LongLong value) { return value; }
|
|
Result operator()(fmt::ULongLong value) { return value; }
|
|
Result operator()(double value) { return value; }
|
|
Result operator()(long double value) { return value; }
|
|
Result operator()(wchar_t value) { return static_cast<char>(value); }
|
|
Result operator()(const char *s) { return s; }
|
|
Result operator()(fmt::format_arg::StringValue<char> s) {
|
|
return s.value;
|
|
}
|
|
Result operator()(fmt::format_arg::StringValue<wchar_t> s) {
|
|
return s.value;
|
|
}
|
|
Result operator()(const void *p) { return p; }
|
|
Result operator()(fmt::format_arg::CustomValue c) {
|
|
return *static_cast<const ::Test*>(c.value);
|
|
}
|
|
};
|
|
|
|
#define EXPECT_RESULT_(Char, type_code, value) { \
|
|
Arg arg = make_arg<Char>(value); \
|
|
Result result = fmt::visit(TestVisitor(), arg); \
|
|
EXPECT_EQ(Arg::type_code, result.arg.type); \
|
|
EXPECT_EQ(value, ArgInfo<Arg::type_code>::get(result.arg)); \
|
|
}
|
|
|
|
#define EXPECT_RESULT(type_code, value) \
|
|
EXPECT_RESULT_(char, type_code, value)
|
|
#define EXPECT_RESULTW(type_code, value) \
|
|
EXPECT_RESULT_(wchar_t, type_code, value)
|
|
|
|
TEST(ArgVisitorTest, VisitAll) {
|
|
EXPECT_RESULT(INT, 42);
|
|
EXPECT_RESULT(UINT, 42u);
|
|
EXPECT_RESULT(LONG_LONG, 42ll);
|
|
EXPECT_RESULT(ULONG_LONG, 42ull);
|
|
EXPECT_RESULT(DOUBLE, 4.2);
|
|
EXPECT_RESULT(LONG_DOUBLE, 4.2l);
|
|
EXPECT_RESULT(CHAR, 'x');
|
|
const char STR[] = "abc";
|
|
EXPECT_RESULT(CSTRING, STR);
|
|
const wchar_t WSTR[] = L"abc";
|
|
EXPECT_RESULTW(WSTRING, WSTR);
|
|
const void *p = STR;
|
|
EXPECT_RESULT(POINTER, p);
|
|
::Test t;
|
|
Result result = visit(TestVisitor(), make_arg<char>(t));
|
|
EXPECT_EQ(Arg::CUSTOM, result.arg.type);
|
|
EXPECT_EQ(&t, result.arg.custom.value);
|
|
}
|
|
|
|
TEST(ArgVisitorTest, VisitInvalidArg) {
|
|
Arg arg = Arg();
|
|
arg.type = static_cast<Arg::Type>(Arg::NONE);
|
|
EXPECT_ASSERT(visit(TestVisitor(), arg), "invalid argument type");
|
|
}
|
|
|
|
// Tests fmt::internal::count_digits for integer type Int.
|
|
template <typename Int>
|
|
void test_count_digits() {
|
|
for (Int i = 0; i < 10; ++i)
|
|
EXPECT_EQ(1u, fmt::internal::count_digits(i));
|
|
for (Int i = 1, n = 1,
|
|
end = std::numeric_limits<Int>::max() / 10; n <= end; ++i) {
|
|
n *= 10;
|
|
EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
|
|
EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
|
|
}
|
|
}
|
|
|
|
TEST(UtilTest, StringRef) {
|
|
// Test that StringRef::size() returns string length, not buffer size.
|
|
char str[100] = "some string";
|
|
EXPECT_EQ(std::strlen(str), StringRef(str).size());
|
|
EXPECT_LT(std::strlen(str), sizeof(str));
|
|
}
|
|
|
|
// Check StringRef's comparison operator.
|
|
template <template <typename> class Op>
|
|
void CheckOp() {
|
|
const char *inputs[] = {"foo", "fop", "fo"};
|
|
std::size_t num_inputs = sizeof(inputs) / sizeof(*inputs);
|
|
for (std::size_t i = 0; i < num_inputs; ++i) {
|
|
for (std::size_t j = 0; j < num_inputs; ++j) {
|
|
StringRef lhs(inputs[i]), rhs(inputs[j]);
|
|
EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<StringRef>()(lhs, rhs));
|
|
}
|
|
}
|
|
}
|
|
|
|
TEST(UtilTest, StringRefCompare) {
|
|
EXPECT_EQ(0, StringRef("foo").compare(StringRef("foo")));
|
|
EXPECT_GT(StringRef("fop").compare(StringRef("foo")), 0);
|
|
EXPECT_LT(StringRef("foo").compare(StringRef("fop")), 0);
|
|
EXPECT_GT(StringRef("foo").compare(StringRef("fo")), 0);
|
|
EXPECT_LT(StringRef("fo").compare(StringRef("foo")), 0);
|
|
CheckOp<std::equal_to>();
|
|
CheckOp<std::not_equal_to>();
|
|
CheckOp<std::less>();
|
|
CheckOp<std::less_equal>();
|
|
CheckOp<std::greater>();
|
|
CheckOp<std::greater_equal>();
|
|
}
|
|
|
|
TEST(UtilTest, CountDigits) {
|
|
test_count_digits<uint32_t>();
|
|
test_count_digits<uint64_t>();
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
TEST(UtilTest, UTF16ToUTF8) {
|
|
std::string s = "ёжик";
|
|
fmt::internal::UTF16ToUTF8 u(L"\x0451\x0436\x0438\x043A");
|
|
EXPECT_EQ(s, u.str());
|
|
EXPECT_EQ(s.size(), u.size());
|
|
}
|
|
|
|
TEST(UtilTest, UTF8ToUTF16) {
|
|
std::string s = "лошадка";
|
|
fmt::internal::UTF8ToUTF16 u(s.c_str());
|
|
EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
|
|
EXPECT_EQ(7, u.size());
|
|
}
|
|
|
|
template <typename Converter, typename Char>
|
|
void check_utf_conversion_error(
|
|
const char *message,
|
|
fmt::BasicStringRef<Char> str = fmt::BasicStringRef<Char>(0, 0)) {
|
|
fmt::MemoryWriter out;
|
|
fmt::internal::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
|
|
fmt::SystemError error(0, "");
|
|
try {
|
|
(Converter)(str);
|
|
} catch (const fmt::SystemError &e) {
|
|
error = e;
|
|
}
|
|
EXPECT_EQ(ERROR_INVALID_PARAMETER, error.error_code());
|
|
EXPECT_EQ(out.str(), error.what());
|
|
}
|
|
|
|
TEST(UtilTest, UTF16ToUTF8Error) {
|
|
check_utf_conversion_error<fmt::internal::UTF16ToUTF8, wchar_t>(
|
|
"cannot convert string from UTF-16 to UTF-8");
|
|
}
|
|
|
|
TEST(UtilTest, UTF8ToUTF16Error) {
|
|
const char *message = "cannot convert string from UTF-8 to UTF-16";
|
|
check_utf_conversion_error<fmt::internal::UTF8ToUTF16, char>(message);
|
|
check_utf_conversion_error<fmt::internal::UTF8ToUTF16, char>(
|
|
message, fmt::StringRef("foo", INT_MAX + 1u));
|
|
}
|
|
|
|
TEST(UtilTest, UTF16ToUTF8Convert) {
|
|
fmt::internal::UTF16ToUTF8 u;
|
|
EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::WStringRef(0, 0)));
|
|
EXPECT_EQ(ERROR_INVALID_PARAMETER,
|
|
u.convert(fmt::WStringRef(L"foo", INT_MAX + 1u)));
|
|
}
|
|
#endif // _WIN32
|
|
|
|
typedef void (*FormatErrorMessage)(
|
|
fmt::Writer &out, int error_code, StringRef message);
|
|
|
|
template <typename Error>
|
|
void check_throw_error(int error_code, FormatErrorMessage format) {
|
|
fmt::SystemError error(0, "");
|
|
try {
|
|
throw Error(error_code, "test {}", "error");
|
|
} catch (const fmt::SystemError &e) {
|
|
error = e;
|
|
}
|
|
fmt::MemoryWriter message;
|
|
format(message, error_code, "test error");
|
|
EXPECT_EQ(message.str(), error.what());
|
|
EXPECT_EQ(error_code, error.error_code());
|
|
}
|
|
|
|
TEST(UtilTest, FormatSystemError) {
|
|
fmt::MemoryWriter message;
|
|
fmt::format_system_error(message, EDOM, "test");
|
|
EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), message.str());
|
|
message.clear();
|
|
fmt::format_system_error(
|
|
message, EDOM, fmt::StringRef(0, std::numeric_limits<size_t>::max()));
|
|
EXPECT_EQ(fmt::format("error {}", EDOM), message.str());
|
|
}
|
|
|
|
TEST(UtilTest, SystemError) {
|
|
fmt::SystemError e(EDOM, "test");
|
|
EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
|
|
EXPECT_EQ(EDOM, e.error_code());
|
|
check_throw_error<fmt::SystemError>(EDOM, fmt::format_system_error);
|
|
}
|
|
|
|
TEST(UtilTest, ReportSystemError) {
|
|
fmt::MemoryWriter out;
|
|
fmt::format_system_error(out, EDOM, "test error");
|
|
out << '\n';
|
|
EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"), out.str());
|
|
}
|
|
|
|
#ifdef _WIN32
|
|
|
|
TEST(UtilTest, FormatWindowsError) {
|
|
LPWSTR message = 0;
|
|
FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
|
|
ERROR_FILE_EXISTS, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
reinterpret_cast<LPWSTR>(&message), 0, 0);
|
|
fmt::internal::UTF16ToUTF8 utf8_message(message);
|
|
LocalFree(message);
|
|
fmt::MemoryWriter actual_message;
|
|
fmt::internal::format_windows_error(
|
|
actual_message, ERROR_FILE_EXISTS, "test");
|
|
EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
|
|
actual_message.str());
|
|
actual_message.clear();
|
|
fmt::internal::format_windows_error(
|
|
actual_message, ERROR_FILE_EXISTS,
|
|
fmt::StringRef(0, std::numeric_limits<size_t>::max()));
|
|
EXPECT_EQ(fmt::format("error {}", ERROR_FILE_EXISTS), actual_message.str());
|
|
}
|
|
|
|
TEST(UtilTest, FormatLongWindowsError) {
|
|
LPWSTR message = 0;
|
|
// this error code is not available on all Windows platforms and
|
|
// Windows SDKs, so do not fail the test if the error string cannot
|
|
// be retrieved.
|
|
const int provisioning_not_allowed = 0x80284013L /*TBS_E_PROVISIONING_NOT_ALLOWED*/;
|
|
if (FormatMessageW(FORMAT_MESSAGE_ALLOCATE_BUFFER |
|
|
FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, 0,
|
|
provisioning_not_allowed, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT),
|
|
reinterpret_cast<LPWSTR>(&message), 0, 0) == 0) {
|
|
return;
|
|
}
|
|
fmt::internal::UTF16ToUTF8 utf8_message(message);
|
|
LocalFree(message);
|
|
fmt::MemoryWriter actual_message;
|
|
fmt::internal::format_windows_error(
|
|
actual_message, provisioning_not_allowed, "test");
|
|
EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
|
|
actual_message.str());
|
|
}
|
|
|
|
TEST(UtilTest, WindowsError) {
|
|
check_throw_error<fmt::WindowsError>(
|
|
ERROR_FILE_EXISTS, fmt::internal::format_windows_error);
|
|
}
|
|
|
|
TEST(UtilTest, ReportWindowsError) {
|
|
fmt::MemoryWriter out;
|
|
fmt::internal::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
|
|
out << '\n';
|
|
EXPECT_WRITE(stderr,
|
|
fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"), out.str());
|
|
}
|
|
|
|
#endif // _WIN32
|
|
|
|
enum TestEnum2 {};
|
|
|
|
TEST(UtilTest, ConvertToInt) {
|
|
EXPECT_TRUE(fmt::internal::ConvertToInt<char>::enable_conversion);
|
|
EXPECT_FALSE(fmt::internal::ConvertToInt<const char *>::enable_conversion);
|
|
EXPECT_TRUE(fmt::internal::ConvertToInt<TestEnum2>::value);
|
|
}
|
|
|
|
#if FMT_USE_ENUM_BASE
|
|
enum TestEnum : char {TestValue};
|
|
TEST(UtilTest, IsEnumConvertibleToInt) {
|
|
EXPECT_TRUE(fmt::internal::ConvertToInt<TestEnum>::enable_conversion);
|
|
}
|
|
#endif
|
|
|
|
template <typename T>
|
|
bool check_enable_if(
|
|
typename fmt::internal::EnableIf<sizeof(T) == sizeof(int), T>::type *) {
|
|
return true;
|
|
}
|
|
|
|
template <typename T>
|
|
bool check_enable_if(
|
|
typename fmt::internal::EnableIf<sizeof(T) != sizeof(int), T>::type *) {
|
|
return false;
|
|
}
|
|
|
|
TEST(UtilTest, EnableIf) {
|
|
int i = 0;
|
|
EXPECT_TRUE(check_enable_if<int>(&i));
|
|
char c = 0;
|
|
EXPECT_FALSE(check_enable_if<char>(&c));
|
|
}
|
|
|
|
TEST(UtilTest, Conditional) {
|
|
int i = 0;
|
|
fmt::internal::Conditional<true, int, char>::type *pi = &i;
|
|
(void)pi;
|
|
char c = 0;
|
|
fmt::internal::Conditional<false, int, char>::type *pc = &c;
|
|
(void)pc;
|
|
}
|
|
|
|
struct TestLConv {
|
|
char *thousands_sep;
|
|
};
|
|
|
|
struct EmptyLConv {};
|
|
|
|
TEST(UtilTest, ThousandsSep) {
|
|
char foo[] = "foo";
|
|
TestLConv lc = {foo};
|
|
EXPECT_EQ("foo", fmt::internal::thousands_sep(&lc).to_string());
|
|
EmptyLConv empty_lc;
|
|
EXPECT_EQ("", fmt::internal::thousands_sep(&empty_lc));
|
|
}
|