fmt/test/util-test.cc

852 lines
25 KiB
C++
Raw Normal View History

/*
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.
*/
2015-06-22 15:17:23 +00:00
#include "test-assert.h"
#include <cfloat>
#include <climits>
#include <cstring>
2015-10-22 15:56:52 +00:00
#include <functional>
2014-06-06 15:07:05 +00:00
#include <limits>
#if FMT_USE_TYPE_TRAITS
# include <type_traits>
#endif
#include "fmt/locale.h"
#include "gmock/gmock.h"
#include "gtest-extra.h"
#include "mock-allocator.h"
#include "util.h"
2014-06-06 14:29:57 +00:00
// Check if format.h compiles with windows.h included.
#ifdef _WIN32
# include <windows.h>
#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_arg;
2017-02-14 17:08:37 +00:00
using fmt::basic_buffer;
using fmt::basic_memory_buffer;
using fmt::string_view;
2016-12-30 16:05:26 +00:00
using fmt::internal::value;
using testing::_;
using testing::Return;
2014-09-30 14:30:27 +00:00
using testing::StrictMock;
namespace {
2014-07-04 14:18:44 +00:00
struct Test {};
2016-05-06 14:37:20 +00:00
template <typename Context, typename T>
basic_arg<Context> make_arg(const T &value) {
return fmt::internal::make_arg<Context>(value);
2014-09-23 14:59:43 +00:00
}
} // namespace
2017-08-13 20:09:02 +00:00
namespace fmt {
template <typename Char>
struct formatter<Test, Char> {
template <typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
return ctx.begin();
2017-08-13 20:09:02 +00:00
}
2018-01-14 15:19:23 +00:00
using range = fmt::internal::dynamic_range<basic_buffer<Char>>;
void format(Test, basic_context<range> &ctx) {
2017-08-13 20:09:02 +00:00
const Char *test = "test";
2018-01-14 15:19:23 +00:00
ctx.range().container().append(test, test + std::strlen(test));
2017-08-13 20:09:02 +00:00
}
};
}
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) {
2014-09-30 14:30:27 +00:00
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
2014-10-01 15:12:10 +00:00
TEST(BufferTest, Noncopyable) {
2017-02-14 17:08:37 +00:00
EXPECT_FALSE(std::is_copy_constructible<basic_buffer<char> >::value);
EXPECT_FALSE(std::is_copy_assignable<basic_buffer<char> >::value);
}
2014-10-01 15:12:10 +00:00
TEST(BufferTest, Nonmoveable) {
2017-02-14 17:08:37 +00:00
EXPECT_FALSE(std::is_move_constructible<basic_buffer<char> >::value);
EXPECT_FALSE(std::is_move_assignable<basic_buffer<char> >::value);
}
#endif
2014-10-01 15:12:10 +00:00
// A test buffer with a dummy grow method.
2014-09-30 14:30:27 +00:00
template <typename T>
2017-02-14 17:08:37 +00:00
struct TestBuffer : basic_buffer<T> {
2017-03-12 14:30:20 +00:00
void grow(std::size_t capacity) { this->set(0, capacity); }
2014-10-01 15:12:10 +00:00
};
2014-09-30 14:30:27 +00:00
2014-10-01 15:12:10 +00:00
template <typename T>
2017-02-14 17:08:37 +00:00
struct MockBuffer : basic_buffer<T> {
2017-03-12 14:30:20 +00:00
MOCK_METHOD1(do_grow, void (std::size_t capacity));
2014-10-01 16:32:31 +00:00
2017-03-12 14:30:20 +00:00
void grow(std::size_t capacity) {
this->set(this->data(), capacity);
do_grow(capacity);
2014-10-01 16:32:31 +00:00
}
2014-09-30 14:30:27 +00:00
MockBuffer() {}
2017-03-12 14:30:20 +00:00
MockBuffer(T *data) { this->set(data, 0); }
MockBuffer(T *data, std::size_t capacity) { this->set(data, capacity); }
2014-09-30 14:30:27 +00:00
};
TEST(BufferTest, Ctor) {
{
MockBuffer<int> buffer;
EXPECT_EQ(0, &buffer[0]);
2014-10-13 13:46:07 +00:00
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(0u, buffer.capacity());
2014-09-30 14:30:27 +00:00
}
{
int dummy;
MockBuffer<int> buffer(&dummy);
EXPECT_EQ(&dummy, &buffer[0]);
2014-10-13 13:46:07 +00:00
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(0u, buffer.capacity());
2014-09-30 14:30:27 +00:00
}
{
int dummy;
std::size_t capacity = std::numeric_limits<std::size_t>::max();
MockBuffer<int> buffer(&dummy, capacity);
EXPECT_EQ(&dummy, &buffer[0]);
2014-10-13 13:46:07 +00:00
EXPECT_EQ(0u, buffer.size());
2014-09-30 14:30:27 +00:00
EXPECT_EQ(capacity, buffer.capacity());
}
}
2014-10-01 15:24:47 +00:00
struct DyingBuffer : TestBuffer<int> {
MOCK_METHOD0(die, void());
~DyingBuffer() { die(); }
};
2014-09-30 14:30:27 +00:00
TEST(BufferTest, VirtualDtor) {
2014-10-01 15:12:10 +00:00
typedef StrictMock<DyingBuffer> StictMockBuffer;
2014-09-30 14:30:27 +00:00
StictMockBuffer *mock_buffer = new StictMockBuffer();
2014-10-01 15:12:10 +00:00
EXPECT_CALL(*mock_buffer, die());
2017-02-14 17:08:37 +00:00
basic_buffer<int> *buffer = mock_buffer;
2014-09-30 14:30:27 +00:00
delete buffer;
}
TEST(BufferTest, Access) {
char data[10];
2014-10-01 15:12:10 +00:00
MockBuffer<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));
2017-02-14 17:08:37 +00:00
const fmt::basic_buffer<char> &const_buffer = buffer;
2014-09-30 14:30:27 +00:00
EXPECT_EQ(42, const_buffer[3]);
}
2014-10-01 15:12:10 +00:00
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.
2014-10-01 16:32:31 +00:00
EXPECT_CALL(buffer, do_grow(124));
2014-10-01 15:12:10 +00:00
buffer.resize(124);
2014-10-01 16:32:31 +00:00
EXPECT_CALL(buffer, do_grow(200));
2014-10-01 15:12:10 +00:00
buffer.resize(200);
}
TEST(BufferTest, Clear) {
TestBuffer<char> buffer;
buffer.resize(20);
buffer.resize(0);
2014-10-01 15:12:10 +00:00
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(20u, buffer.capacity());
}
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);
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];
MockBuffer<char> buffer(data, 10);
const char *test = "abcdefgh";
buffer.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(MemoryBufferTest, Ctor) {
basic_memory_buffer<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,
basic_memory_buffer<char, 5, TestAllocator> &buffer) {
std::allocator<char> *alloc = buffer.get_allocator().get();
basic_memory_buffer<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()));
2014-10-13 20:28:47 +00:00
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;
basic_memory_buffer<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');
basic_memory_buffer<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, basic_memory_buffer<char, 5> &buffer) {
basic_memory_buffer<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()));
2014-10-13 20:28:47 +00:00
EXPECT_EQ(5u, buffer2.capacity());
}
TEST(MemoryBufferTest, MoveAssignment) {
basic_memory_buffer<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');
basic_memory_buffer<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) {
2014-10-01 15:12:10 +00:00
typedef AllocatorRef< MockAllocator<int> > Allocator;
typedef basic_memory_buffer<int, 10, Allocator> Base;
2014-10-01 15:12:10 +00:00
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);
2016-03-02 15:53:14 +00:00
using fmt::internal::to_unsigned;
2014-10-01 15:12:10 +00:00
for (int i = 0; i < 7; ++i)
2016-03-02 15:53:14 +00:00
buffer[to_unsigned(i)] = i * i;
2014-10-01 15:12:10 +00:00
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());
2014-10-01 15:12:10 +00:00
// Check if size elements have been copied
for (int i = 0; i < 7; ++i)
2016-03-02 15:53:14 +00:00
EXPECT_EQ(i * i, buffer[to_unsigned(i)]);
2014-10-01 15:12:10 +00:00
// and no more than that.
EXPECT_EQ(0xdead, buffer[7]);
EXPECT_CALL(alloc, deallocate(mem, 20));
}
TEST(MemoryBufferTest, Allocator) {
typedef AllocatorRef< MockAllocator<char> > TestAllocator;
basic_memory_buffer<char, 10, TestAllocator> buffer;
EXPECT_EQ(0, buffer.get_allocator().get());
2014-09-30 14:30:27 +00:00
StrictMock< MockAllocator<char> > alloc;
char mem;
{
basic_memory_buffer<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;
2014-09-30 14:30:27 +00:00
StrictMock< MockAllocator<char> > alloc;
basic_memory_buffer<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));
}
2017-02-15 01:12:39 +00:00
TEST(FixedBufferTest, Ctor) {
char array[10] = "garbage";
2017-02-19 14:46:51 +00:00
fmt::basic_fixed_buffer<char> buffer(array, sizeof(array));
2017-02-15 01:12:39 +00:00
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(10u, buffer.capacity());
EXPECT_EQ(array, buffer.data());
}
TEST(FixedBufferTest, CompileTimeSizeCtor) {
char array[10] = "garbage";
2017-02-19 14:46:51 +00:00
fmt::basic_fixed_buffer<char> buffer(array);
2017-02-15 01:12:39 +00:00
EXPECT_EQ(0u, buffer.size());
EXPECT_EQ(10u, buffer.capacity());
EXPECT_EQ(array, buffer.data());
}
TEST(FixedBufferTest, BufferOverflow) {
char array[10];
2017-02-19 14:46:51 +00:00
fmt::basic_fixed_buffer<char> buffer(array);
2017-02-15 01:12:39 +00:00
buffer.resize(10);
EXPECT_THROW_MSG(buffer.resize(11), std::runtime_error, "buffer overflow");
}
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);
}
2016-08-25 15:50:07 +00:00
TEST(UtilTest, FormatArgs) {
2017-12-03 15:32:04 +00:00
fmt::format_args args;
EXPECT_FALSE(args[1]);
2014-09-25 16:11:51 +00:00
}
2016-12-30 02:07:05 +00:00
struct CustomContext {
2017-08-13 20:09:02 +00:00
using char_type = char;
template <typename T>
struct formatter_type {
template <typename ParseContext>
auto parse(ParseContext &ctx) -> decltype(ctx.begin()) {
return ctx.begin();
2017-08-13 20:09:02 +00:00
}
2018-01-06 17:09:50 +00:00
void format(const T &, CustomContext& ctx) {
2017-08-13 20:09:02 +00:00
ctx.called = true;
}
};
2016-11-07 00:11:24 +00:00
bool called;
2015-12-02 16:41:05 +00:00
fmt::parse_context parse_context() { return fmt::parse_context(""); }
2017-08-13 20:09:02 +00:00
};
2015-12-02 16:41:05 +00:00
TEST(UtilTest, MakeValueWithCustomFormatter) {
::Test t;
2016-12-30 17:25:01 +00:00
fmt::internal::value<CustomContext> arg(t);
2016-12-30 02:07:05 +00:00
CustomContext ctx = {false};
2018-01-06 17:09:50 +00:00
arg.custom.format(&t, ctx);
2016-11-07 00:11:24 +00:00
EXPECT_TRUE(ctx.called);
2015-12-02 16:41:05 +00:00
}
namespace fmt {
namespace internal {
2014-07-14 13:55:29 +00:00
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;
}
}
}
2014-07-14 13:55:29 +00:00
template <typename T>
struct MockVisitor {
// Use a unique result type to make sure that there are no undesirable
// conversions.
struct Result {};
MockVisitor() {
ON_CALL(*this, visit(_)).WillByDefault(Return(Result()));
}
MOCK_METHOD1_T(visit, Result (T value));
MOCK_METHOD0_T(unexpected, void ());
Result operator()(T value) { return visit(value); }
template <typename U>
2017-08-26 16:32:37 +00:00
Result operator()(U) {
unexpected();
return Result();
2014-07-14 14:27:07 +00:00
}
2014-07-14 13:55:29 +00:00
};
template <typename T>
struct VisitType { typedef T Type; };
#define VISIT_TYPE(Type_, VisitType_) \
template <> \
struct VisitType<Type_> { typedef VisitType_ 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
VISIT_TYPE(float, double);
#define CHECK_ARG_(Char, expected, value) { \
testing::StrictMock<MockVisitor<decltype(expected)>> visitor; \
EXPECT_CALL(visitor, visit(expected)); \
2018-01-14 15:19:23 +00:00
using range = fmt::internal::dynamic_range<basic_buffer<Char>>; \
fmt::visit(visitor, make_arg<fmt::basic_context<range>>(value)); \
}
#define CHECK_ARG(value) { \
typename VisitType<decltype(value)>::Type expected = value; \
CHECK_ARG_(char, expected, value) \
CHECK_ARG_(wchar_t, expected, value) \
}
template <typename T>
class NumericArgTest : public testing::Test {};
typedef ::testing::Types<
bool, signed char, unsigned char, signed, unsigned short,
2017-08-26 16:09:43 +00:00
int, unsigned, long, unsigned long, long long, unsigned long long,
float, double, long double> Types;
TYPED_TEST_CASE(NumericArgTest, Types);
template <typename T>
typename std::enable_if<std::is_integral<T>::value, T>::type test_value() {
return static_cast<T>(42);
}
template <typename T>
typename std::enable_if<std::is_floating_point<T>::value, T>::type
test_value() {
return static_cast<T>(4.2);
}
TYPED_TEST(NumericArgTest, MakeAndVisit) {
CHECK_ARG(test_value<TypeParam>());
CHECK_ARG(std::numeric_limits<TypeParam>::min());
CHECK_ARG(std::numeric_limits<TypeParam>::max());
}
TEST(UtilTest, CharArg) {
CHECK_ARG_(char, 'a', 'a');
CHECK_ARG_(wchar_t, L'a', 'a');
CHECK_ARG_(wchar_t, L'a', L'a');
}
TEST(UtilTest, StringArg) {
char str_data[] = "test";
char *str = str_data;
const char *cstr = str;
CHECK_ARG_(char, cstr, str);
string_view sref(str);
2016-12-12 05:13:54 +00:00
CHECK_ARG_(char, sref, std::string(str));
}
TEST(UtilTest, WStringArg) {
wchar_t str_data[] = L"test";
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(UtilTest, PointerArg) {
void *p = 0;
const void *cp = 0;
CHECK_ARG_(char, cp, p);
CHECK_ARG_(wchar_t, cp, p);
CHECK_ARG(cp);
}
TEST(UtilTest, CustomArg) {
::Test test;
2017-12-02 17:44:48 +00:00
using handle = typename fmt::basic_arg<fmt::context>::handle;
using visitor = MockVisitor<handle>;
testing::StrictMock<visitor> v;
EXPECT_CALL(v, visit(_)).WillOnce(testing::Invoke([&](handle h) {
fmt::memory_buffer buffer;
2018-01-06 17:09:50 +00:00
fmt::context ctx(buffer, "", fmt::format_args());
h.format(ctx);
EXPECT_EQ("test", std::string(buffer.data(), buffer.size()));
2017-12-02 17:44:48 +00:00
return visitor::Result();
}));
2017-12-02 17:44:48 +00:00
fmt::visit(v, make_arg<fmt::context>(test));
2014-07-14 13:55:29 +00:00
}
2014-07-16 14:55:31 +00:00
TEST(ArgVisitorTest, VisitInvalidArg) {
2016-12-27 15:43:25 +00:00
typedef MockVisitor<fmt::monostate> Visitor;
testing::StrictMock<Visitor> visitor;
EXPECT_CALL(visitor, visit(_));
2017-02-05 14:54:03 +00:00
fmt::basic_arg<fmt::context> arg;
2016-12-27 15:43:25 +00:00
visit(visitor, arg);
2014-07-16 14:55:31 +00:00
}
2014-07-24 16:07:43 +00:00
// Tests fmt::internal::count_digits for integer type Int.
template <typename Int>
void test_count_digits() {
for (Int i = 0; i < 10; ++i)
2014-07-24 16:07:43 +00:00
EXPECT_EQ(1u, fmt::internal::count_digits(i));
for (Int i = 1, n = 1,
2014-07-24 16:07:43 +00:00
end = std::numeric_limits<Int>::max() / 10; n <= end; ++i) {
n *= 10;
2014-07-24 16:07:43 +00:00
EXPECT_EQ(i, fmt::internal::count_digits(n - 1));
EXPECT_EQ(i + 1, fmt::internal::count_digits(n));
}
}
2014-10-30 13:27:44 +00:00
TEST(UtilTest, StringRef) {
2015-02-17 14:45:45 +00:00
// Test that StringRef::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 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) {
string_view lhs(inputs[i]), rhs(inputs[j]);
EXPECT_EQ(Op<int>()(lhs.compare(rhs), 0), Op<string_view>()(lhs, rhs));
}
}
}
TEST(UtilTest, StringRefCompare) {
EXPECT_EQ(0, string_view("foo").compare(string_view("foo")));
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);
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 = "ёжик";
2017-02-19 16:41:38 +00:00
fmt::internal::utf16_to_utf8 u(L"\x0451\x0436\x0438\x043A");
2014-07-01 01:12:57 +00:00
EXPECT_EQ(s, u.str());
EXPECT_EQ(s.size(), u.size());
}
TEST(UtilTest, UTF8ToUTF16) {
std::string s = "лошадка";
2017-02-19 14:46:51 +00:00
fmt::internal::utf8_to_utf16 u(s.c_str());
2014-07-01 01:12:57 +00:00
EXPECT_EQ(L"\x043B\x043E\x0448\x0430\x0434\x043A\x0430", u.str());
EXPECT_EQ(7, u.size());
}
2014-10-30 20:00:44 +00:00
template <typename Converter, typename Char>
2015-08-07 14:34:58 +00:00
void check_utf_conversion_error(
const char *message,
fmt::basic_string_view<Char> str = fmt::basic_string_view<Char>(0, 0)) {
2017-02-19 14:46:51 +00:00
fmt::memory_buffer out;
fmt::internal::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
2017-03-08 15:34:10 +00:00
fmt::system_error error(0, "");
try {
2015-08-07 14:34:58 +00:00
(Converter)(str);
2017-03-08 15:34:10 +00:00
} catch (const fmt::system_error &e) {
error = e;
}
EXPECT_EQ(ERROR_INVALID_PARAMETER, error.error_code());
2017-02-17 14:38:53 +00:00
EXPECT_EQ(fmt::to_string(out), error.what());
}
TEST(UtilTest, UTF16ToUTF8Error) {
2017-02-19 16:41:38 +00:00
check_utf_conversion_error<fmt::internal::utf16_to_utf8, wchar_t>(
"cannot convert string from UTF-16 to UTF-8");
}
TEST(UtilTest, UTF8ToUTF16Error) {
2015-08-07 14:34:58 +00:00
const char *message = "cannot convert string from UTF-8 to UTF-16";
2017-02-19 14:46:51 +00:00
check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(message);
check_utf_conversion_error<fmt::internal::utf8_to_utf16, char>(
message, fmt::string_view("foo", INT_MAX + 1u));
}
TEST(UtilTest, UTF16ToUTF8Convert) {
2017-02-19 16:41:38 +00:00
fmt::internal::utf16_to_utf8 u;
EXPECT_EQ(ERROR_INVALID_PARAMETER, u.convert(fmt::wstring_view(0, 0)));
2015-08-07 14:34:58 +00:00
EXPECT_EQ(ERROR_INVALID_PARAMETER,
u.convert(fmt::wstring_view(L"foo", INT_MAX + 1u)));
}
#endif // _WIN32
typedef void (*FormatErrorMessage)(
fmt::buffer &out, int error_code, string_view message);
2014-06-30 21:26:29 +00:00
template <typename Error>
void check_throw_error(int error_code, FormatErrorMessage format) {
2017-02-19 16:41:38 +00:00
fmt::system_error error(0, "");
try {
2014-06-30 21:26:29 +00:00
throw Error(error_code, "test {}", "error");
2017-02-19 16:41:38 +00:00
} catch (const fmt::system_error &e) {
error = e;
}
fmt::memory_buffer message;
format(message, error_code, "test error");
EXPECT_EQ(to_string(message), error.what());
EXPECT_EQ(error_code, error.error_code());
}
TEST(UtilTest, FormatSystemError) {
fmt::memory_buffer message;
fmt::format_system_error(message, EDOM, "test");
EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)),
to_string(message));
message.resize(0);
fmt::format_system_error(
message, EDOM, fmt::string_view(0, std::numeric_limits<size_t>::max()));
EXPECT_EQ(fmt::format("error {}", EDOM), to_string(message));
}
TEST(UtilTest, SystemError) {
2017-02-19 16:41:38 +00:00
fmt::system_error e(EDOM, "test");
EXPECT_EQ(fmt::format("test: {}", get_system_error(EDOM)), e.what());
EXPECT_EQ(EDOM, e.error_code());
2017-02-19 16:41:38 +00:00
check_throw_error<fmt::system_error>(EDOM, fmt::format_system_error);
}
TEST(UtilTest, ReportSystemError) {
fmt::memory_buffer out;
fmt::format_system_error(out, EDOM, "test error");
out.push_back('\n');
EXPECT_WRITE(stderr, fmt::report_system_error(EDOM, "test error"),
to_string(out));
}
#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);
2017-02-19 16:41:38 +00:00
fmt::internal::utf16_to_utf8 utf8_message(message);
LocalFree(message);
2017-02-19 14:46:51 +00:00
fmt::memory_buffer actual_message;
fmt::internal::format_windows_error(
actual_message, ERROR_FILE_EXISTS, "test");
2014-07-01 02:11:20 +00:00
EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
2017-02-17 14:38:53 +00:00
fmt::to_string(actual_message));
actual_message.resize(0);
fmt::internal::format_windows_error(
actual_message, ERROR_FILE_EXISTS,
fmt::string_view(0, std::numeric_limits<size_t>::max()));
2017-02-17 14:38:53 +00:00
EXPECT_EQ(fmt::format("error {}", ERROR_FILE_EXISTS),
fmt::to_string(actual_message));
}
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;
}
2017-02-19 16:41:38 +00:00
fmt::internal::utf16_to_utf8 utf8_message(message);
LocalFree(message);
2017-02-19 14:46:51 +00:00
fmt::memory_buffer actual_message;
fmt::internal::format_windows_error(
actual_message, provisioning_not_allowed, "test");
EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
2017-02-17 14:38:53 +00:00
fmt::to_string(actual_message));
}
TEST(UtilTest, WindowsError) {
2017-03-08 15:34:10 +00:00
check_throw_error<fmt::windows_error>(
ERROR_FILE_EXISTS, fmt::internal::format_windows_error);
}
TEST(UtilTest, ReportWindowsError) {
2017-02-19 14:46:51 +00:00
fmt::memory_buffer out;
fmt::internal::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
2017-02-17 14:38:53 +00:00
out.push_back('\n');
EXPECT_WRITE(stderr,
2017-02-17 14:38:53 +00:00
fmt::report_windows_error(ERROR_FILE_EXISTS, "test error"),
fmt::to_string(out));
}
#endif // _WIN32
enum TestEnum2 {};
TEST(UtilTest, ConvertToInt) {
2017-02-19 16:41:38 +00:00
EXPECT_TRUE(fmt::internal::convert_to_int<char>::enable_conversion);
EXPECT_FALSE(fmt::internal::convert_to_int<const char *>::enable_conversion);
EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum2>::value);
}
#if FMT_USE_ENUM_BASE
enum TestEnum : char {TestValue};
TEST(UtilTest, IsEnumConvertibleToInt) {
2017-02-19 16:41:38 +00:00
EXPECT_TRUE(fmt::internal::convert_to_int<TestEnum>::enable_conversion);
}
#endif
2017-11-12 14:58:11 +00:00
TEST(UtilTest, ParseNonnegativeInt) {
if (std::numeric_limits<int>::max() != (1 << 31)) {
fmt::print("Skipping parse_nonnegative_int test\n");
return;
}
const char *s = "10000000000";
EXPECT_THROW_MSG(
parse_nonnegative_int(s, fmt::internal::error_handler()),
fmt::format_error, "number is too big");
s = "2147483649";
EXPECT_THROW_MSG(
parse_nonnegative_int(s, fmt::internal::error_handler()),
fmt::format_error, "number is too big");
}