fmt/test/format-impl-test.cc

119 lines
3.6 KiB
C++
Raw Normal View History

2018-03-04 17:16:51 +00:00
// Formatting library for C++ - formatting library implementation tests
//
// Copyright (c) 2012 - present, Victor Zverovich
// All rights reserved.
//
// For the license information refer to format.h.
2014-09-05 14:35:00 +00:00
2015-06-22 16:24:54 +00:00
#define FMT_NOEXCEPT
#undef FMT_SHARED
2015-06-22 15:17:23 +00:00
#include "test-assert.h"
2018-03-04 17:16:51 +00:00
// Include format.cc instead of format.h to test implementation.
2018-03-21 14:50:59 +00:00
#include "../src/format.cc"
2017-12-17 16:36:19 +00:00
#include "fmt/printf.h"
2016-03-04 17:04:28 +00:00
#include <algorithm>
#include <cstring>
2016-03-04 17:04:28 +00:00
#include "gmock/gmock.h"
2014-09-05 14:35:00 +00:00
#include "gtest-extra.h"
#include "util.h"
2014-09-05 14:35:00 +00:00
2016-03-04 17:04:28 +00:00
#undef min
2014-09-05 15:06:07 +00:00
#undef max
template <typename T>
2018-03-03 22:04:59 +00:00
struct ValueExtractor: fmt::internal::function<T> {
T operator()(T value) {
return value;
}
template <typename U>
T operator()(U) {
throw std::runtime_error(fmt::format("invalid type {}", typeid(U).name()));
return T();
}
};
2014-09-05 14:35:00 +00:00
TEST(FormatTest, ArgConverter) {
2017-08-26 16:09:43 +00:00
long long value = std::numeric_limits<long long>::max();
2017-02-05 14:54:03 +00:00
auto arg = fmt::internal::make_arg<fmt::context>(value);
2018-03-03 22:04:59 +00:00
visit(fmt::internal::arg_converter<long long, fmt::context>(arg, 'd'), arg);
2017-08-26 16:09:43 +00:00
EXPECT_EQ(value, visit(ValueExtractor<long long>(), arg));
2014-09-05 14:35:00 +00:00
}
2014-09-05 15:04:26 +00:00
TEST(FormatTest, FormatNegativeNaN) {
2014-09-05 14:35:00 +00:00
double nan = std::numeric_limits<double>::quiet_NaN();
2017-01-22 15:40:21 +00:00
if (fmt::internal::fputil::isnegative(-nan))
2014-09-05 14:35:00 +00:00
EXPECT_EQ("-nan", fmt::format("{}", -nan));
else
fmt::print("Warning: compiler doesn't handle negative NaN correctly");
}
2014-09-05 15:04:26 +00:00
TEST(FormatTest, StrError) {
char *message = 0;
char buffer[BUFFER_SIZE];
2015-06-22 15:17:23 +00:00
EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = 0, 0), "invalid buffer");
2016-03-08 14:55:41 +00:00
EXPECT_ASSERT(fmt::safe_strerror(EDOM, message = buffer, 0),
"invalid buffer");
buffer[0] = 'x';
2015-10-21 15:30:10 +00:00
#if defined(_GNU_SOURCE) && !defined(__COVERITY__)
// Use invalid error code to make sure that safe_strerror returns an error
// message in the buffer rather than a pointer to a static string.
2015-10-21 15:30:10 +00:00
int error_code = -1;
#else
int error_code = EDOM;
#endif
int result = fmt::safe_strerror(error_code, message = buffer, BUFFER_SIZE);
EXPECT_EQ(0, result);
std::size_t message_size = std::strlen(message);
EXPECT_GE(BUFFER_SIZE - 1u, message_size);
EXPECT_EQ(get_system_error(error_code), message);
// safe_strerror never uses buffer on MinGW.
#ifndef __MINGW32__
result = fmt::safe_strerror(error_code, message = buffer, message_size);
EXPECT_EQ(ERANGE, result);
result = fmt::safe_strerror(error_code, message = buffer, 1);
EXPECT_EQ(buffer, message); // Message should point to buffer.
EXPECT_EQ(ERANGE, result);
EXPECT_STREQ("", message);
#endif
}
2014-09-05 15:04:26 +00:00
TEST(FormatTest, FormatErrorCode) {
std::string msg = "error 42", sep = ": ";
{
fmt::memory_buffer buffer;
format_to(buffer, "garbage");
fmt::format_error_code(buffer, 42, "test");
EXPECT_EQ("test: " + msg, to_string(buffer));
2014-09-05 15:04:26 +00:00
}
{
fmt::memory_buffer buffer;
2014-09-05 15:04:26 +00:00
std::string prefix(
fmt::inline_buffer_size - msg.size() - sep.size() + 1, 'x');
fmt::format_error_code(buffer, 42, prefix);
EXPECT_EQ(msg, to_string(buffer));
2014-09-05 15:04:26 +00:00
}
int codes[] = {42, -1};
for (std::size_t i = 0, n = sizeof(codes) / sizeof(*codes); i < n; ++i) {
// Test maximum buffer size.
msg = fmt::format("error {}", codes[i]);
fmt::memory_buffer buffer;
2014-09-05 15:04:26 +00:00
std::string prefix(
fmt::inline_buffer_size - msg.size() - sep.size(), 'x');
fmt::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(prefix + sep + msg, to_string(buffer));
std::size_t size = fmt::inline_buffer_size;
EXPECT_EQ(size, buffer.size());
buffer.resize(0);
// Test with a message that doesn't fit into the buffer.
prefix += 'x';
fmt::format_error_code(buffer, codes[i], prefix);
EXPECT_EQ(msg, to_string(buffer));
2014-09-05 15:04:26 +00:00
}
}