feedc0de/fmt
1
0
Fork 0
forked from fmtlib/fmt
Code Pull Requests Activity

Remove legacy code

Browse Source
This commit is contained in:
Victor Zverovich
2017-08-26 09:09:43 -07:00
parent 07f8ffc44f
commit 016acebb56
9 changed files with 60 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

6
fmt/format.cc
View File

@@ -281,10 +281,8 @@ template <typename T>
const uint64_t internal::basic_data<T>::POWERS_OF_10_64[] = { const uint64_t internal::basic_data<T>::POWERS_OF_10_64[] = {
0, 0,
FMT_POWERS_OF_10(1), FMT_POWERS_OF_10(1),
FMT_POWERS_OF_10(ulong_long(1000000000)), FMT_POWERS_OF_10(1000000000ull),
// Multiply several constants instead of using a single long long constant 10000000000000000000ull
// to avoid warnings about C++98 not supporting long long.
ulong_long(1000000000) * ulong_long(1000000000) * 10
}; };
FMT_FUNC void internal::report_unknown_type(char code, const char *type) { FMT_FUNC void internal::report_unknown_type(char code, const char *type) {

73
fmt/format.h
View File

@@ -41,6 +41,7 @@
#include <type_traits> #include <type_traits>
#include <vector> #include <vector>
#include <utility> #include <utility>
#include <stdint.h>
#ifdef _SECURE_SCL #ifdef _SECURE_SCL
# define FMT_SECURE_SCL _SECURE_SCL # define FMT_SECURE_SCL _SECURE_SCL
@@ -52,20 +53,6 @@
# include <iterator> # include <iterator>
#endif #endif
#ifdef _MSC_VER
# define FMT_MSC_VER _MSC_VER
#else
# define FMT_MSC_VER 0
#endif
#if FMT_MSC_VER && FMT_MSC_VER <= 1500
typedef unsigned __int32 uint32_t;
typedef unsigned __int64 uint64_t;
typedef __int64 intmax_t;
#else
#include <stdint.h>
#endif
#if !defined(FMT_HEADER_ONLY) && defined(_WIN32) #if !defined(FMT_HEADER_ONLY) && defined(_WIN32)
# ifdef FMT_EXPORT # ifdef FMT_EXPORT
# define FMT_API __declspec(dllexport) # define FMT_API __declspec(dllexport)
@@ -79,14 +66,9 @@ typedef __int64 intmax_t;
#ifdef __GNUC__ #ifdef __GNUC__
# define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__) # define FMT_GCC_VERSION (__GNUC__ * 100 + __GNUC_MINOR__)
# define FMT_GCC_EXTENSION __extension__
# if FMT_GCC_VERSION >= 406 # if FMT_GCC_VERSION >= 406
# pragma GCC diagnostic push # pragma GCC diagnostic push
// Disable the warning about "long long" which is sometimes reported even
// when using __extension__.
# pragma GCC diagnostic ignored "-Wlong-long"
// Disable the warning about declaration shadowing because it affects too // Disable the warning about declaration shadowing because it affects too
// many valid cases. // many valid cases.
# pragma GCC diagnostic ignored "-Wshadow" # pragma GCC diagnostic ignored "-Wshadow"
@@ -99,8 +81,6 @@ typedef __int64 intmax_t;
# if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__ # if __cplusplus >= 201103L || defined __GXX_EXPERIMENTAL_CXX0X__
# define FMT_HAS_GXX_CXX11 1 # define FMT_HAS_GXX_CXX11 1
# endif # endif
#else
# define FMT_GCC_EXTENSION
#endif #endif
#if defined(__INTEL_COMPILER) #if defined(__INTEL_COMPILER)
@@ -119,6 +99,12 @@ typedef __int64 intmax_t;
# define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__) # define FMT_GNUC_LIBSTD_VERSION (__GNUC_LIBSTD__ * 100 + __GNUC_LIBSTD_MINOR__)
#endif #endif
#ifdef _MSC_VER
# define FMT_MSC_VER _MSC_VER
#else
# define FMT_MSC_VER 0
#endif
#ifdef __has_feature #ifdef __has_feature
# define FMT_HAS_FEATURE(x) __has_feature(x) # define FMT_HAS_FEATURE(x) __has_feature(x)
#else #else
@@ -368,11 +354,6 @@ class numeric_limits<fmt::internal::dummy_int> :
namespace fmt { namespace fmt {
// Fix the warning about long long on older versions of GCC
// that don't support the diagnostic pragma.
FMT_GCC_EXTENSION typedef long long long_long;
FMT_GCC_EXTENSION typedef unsigned long long ulong_long;
#if FMT_USE_RVALUE_REFERENCES #if FMT_USE_RVALUE_REFERENCES
using std::move; using std::move;
#endif #endif
@@ -523,7 +504,7 @@ FMT_SPECIALIZE_MAKE_UNSIGNED(signed char, unsigned char);
FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short); FMT_SPECIALIZE_MAKE_UNSIGNED(short, unsigned short);
FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned); FMT_SPECIALIZE_MAKE_UNSIGNED(int, unsigned);
FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long); FMT_SPECIALIZE_MAKE_UNSIGNED(long, unsigned long);
FMT_SPECIALIZE_MAKE_UNSIGNED(long_long, ulong_long); FMT_SPECIALIZE_MAKE_UNSIGNED(long long, unsigned long long);
// Casts nonnegative integer to unsigned. // Casts nonnegative integer to unsigned.
template <typename Int> template <typename Int>
@@ -1168,7 +1149,7 @@ typedef char no[2];
template <typename T> template <typename T>
T &get(); T &get();
yes &convert(fmt::ulong_long); yes &convert(unsigned long long);
no &convert(...); no &convert(...);
template<typename T, bool ENABLE_CONVERSION> template<typename T, bool ENABLE_CONVERSION>
@@ -1267,8 +1248,8 @@ template <> constexpr Type gettype<unsigned long>() {
return sizeof(unsigned long) == sizeof(unsigned) ? return sizeof(unsigned long) == sizeof(unsigned) ?
UINT : ULONG_LONG; UINT : ULONG_LONG;
} }
template <> constexpr Type gettype<long_long>() { return LONG_LONG; } template <> constexpr Type gettype<long long>() { return LONG_LONG; }
template <> constexpr Type gettype<ulong_long>() { return ULONG_LONG; } template <> constexpr Type gettype<unsigned long long>() { return ULONG_LONG; }
template <> constexpr Type gettype<float>() { return DOUBLE; } template <> constexpr Type gettype<float>() { return DOUBLE; }
template <> constexpr Type gettype<double>() { return DOUBLE; } template <> constexpr Type gettype<double>() { return DOUBLE; }
template <> constexpr Type gettype<long double>() { return LONG_DOUBLE; } template <> constexpr Type gettype<long double>() { return LONG_DOUBLE; }
@@ -1305,8 +1286,8 @@ class value {
union { union {
int int_value; int int_value;
unsigned uint_value; unsigned uint_value;
long_long long_long_value; long long long_long_value;
ulong_long ulong_long_value; unsigned long long ulong_long_value;
double double_value; double double_value;
long double long_double_value; long double long_double_value;
const void *pointer; const void *pointer;
@@ -1401,8 +1382,8 @@ class value {
this->ulong_long_value = value; this->ulong_long_value = value;
} }
FMT_MAKE_VALUE(long_long, long_long_value, LONG_LONG) FMT_MAKE_VALUE(long long, long_long_value, LONG_LONG)
FMT_MAKE_VALUE(ulong_long, ulong_long_value, ULONG_LONG) FMT_MAKE_VALUE(unsigned long long, ulong_long_value, ULONG_LONG)
FMT_MAKE_VALUE(float, double_value, DOUBLE) FMT_MAKE_VALUE(float, double_value, DOUBLE)
FMT_MAKE_VALUE(double, double_value, DOUBLE) FMT_MAKE_VALUE(double, double_value, DOUBLE)
FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE) FMT_MAKE_VALUE(long double, long_double_value, LONG_DOUBLE)
@@ -2437,7 +2418,7 @@ class basic_writer {
void write(long value) { void write(long value) {
write_decimal(value); write_decimal(value);
} }
void write(long_long value) { void write(long long value) {
write_decimal(value); write_decimal(value);
} }
@@ -3039,12 +3020,12 @@ class FormatInt {
private: private:
// Buffer should be large enough to hold all digits (digits10 + 1), // Buffer should be large enough to hold all digits (digits10 + 1),
// a sign and a null character. // a sign and a null character.
enum {BUFFER_SIZE = std::numeric_limits<ulong_long>::digits10 + 3}; enum {BUFFER_SIZE = std::numeric_limits<unsigned long long>::digits10 + 3};
mutable char buffer_[BUFFER_SIZE]; mutable char buffer_[BUFFER_SIZE];
char *str_; char *str_;
// Formats value in reverse and returns the number of digits. // Formats value in reverse and returns the number of digits.
char *format_decimal(ulong_long value) { char *format_decimal(unsigned long long value) {
char *buffer_end = buffer_ + BUFFER_SIZE - 1; char *buffer_end = buffer_ + BUFFER_SIZE - 1;
while (value >= 100) { while (value >= 100) {
// Integer division is slow so do it for a group of two digits instead // Integer division is slow so do it for a group of two digits instead
@@ -3065,8 +3046,8 @@ class FormatInt {
return buffer_end; return buffer_end;
} }
void FormatSigned(long_long value) { void FormatSigned(long long value) {
ulong_long abs_value = static_cast<ulong_long>(value); unsigned long long abs_value = static_cast<unsigned long long>(value);
bool negative = value < 0; bool negative = value < 0;
if (negative) if (negative)
abs_value = 0 - abs_value; abs_value = 0 - abs_value;
@@ -3078,10 +3059,10 @@ class FormatInt {
public: public:
explicit FormatInt(int value) { FormatSigned(value); } explicit FormatInt(int value) { FormatSigned(value); }
explicit FormatInt(long value) { FormatSigned(value); } explicit FormatInt(long value) { FormatSigned(value); }
explicit FormatInt(long_long value) { FormatSigned(value); } explicit FormatInt(long long value) { FormatSigned(value); }
explicit FormatInt(unsigned value) : str_(format_decimal(value)) {} explicit FormatInt(unsigned value) : str_(format_decimal(value)) {}
explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {} explicit FormatInt(unsigned long value) : str_(format_decimal(value)) {}
explicit FormatInt(ulong_long value) : str_(format_decimal(value)) {} explicit FormatInt(unsigned long long value) : str_(format_decimal(value)) {}
/** Returns the number of characters written to the output buffer. */ /** Returns the number of characters written to the output buffer. */
std::size_t size() const { std::size_t size() const {
@@ -3246,7 +3227,7 @@ struct is_integer {
struct width_handler { struct width_handler {
template <typename T> template <typename T>
typename std::enable_if<is_integer<T>::value, ulong_long>::type typename std::enable_if<is_integer<T>::value, unsigned long long>::type
operator()(T value) { operator()(T value) {
if (is_negative(value)) if (is_negative(value))
FMT_THROW(format_error("negative width")); FMT_THROW(format_error("negative width"));
@@ -3254,7 +3235,7 @@ struct width_handler {
} }
template <typename T> template <typename T>
typename std::enable_if<!is_integer<T>::value, ulong_long>::type typename std::enable_if<!is_integer<T>::value, unsigned long long>::type
operator()(T value) { operator()(T value) {
FMT_THROW(format_error("width is not integer")); FMT_THROW(format_error("width is not integer"));
return 0; return 0;
@@ -3263,7 +3244,7 @@ struct width_handler {
struct precision_handler { struct precision_handler {
template <typename T> template <typename T>
typename std::enable_if<is_integer<T>::value, ulong_long>::type typename std::enable_if<is_integer<T>::value, unsigned long long>::type
operator()(T value) { operator()(T value) {
if (is_negative(value)) if (is_negative(value))
FMT_THROW(format_error("negative precision")); FMT_THROW(format_error("negative precision"));
@@ -3271,7 +3252,7 @@ struct precision_handler {
} }
template <typename T> template <typename T>
typename std::enable_if<!is_integer<T>::value, ulong_long>::type typename std::enable_if<!is_integer<T>::value, unsigned long long>::type
operator()(T value) { operator()(T value) {
FMT_THROW(format_error("precision is not integer")); FMT_THROW(format_error("precision is not integer"));
return 0; return 0;
@@ -3308,7 +3289,7 @@ class specs_handler_base {
template <typename Handler, typename T, typename Context> template <typename Handler, typename T, typename Context>
inline void set_dynamic_spec(T &value, basic_arg<Context> arg) { inline void set_dynamic_spec(T &value, basic_arg<Context> arg) {
ulong_long big_value = visit(Handler(), arg); unsigned long long big_value = visit(Handler(), arg);
if (big_value > (std::numeric_limits<int>::max)()) if (big_value > (std::numeric_limits<int>::max)())
FMT_THROW(format_error("number is too big")); FMT_THROW(format_error("number is too big"));
value = static_cast<int>(big_value); value = static_cast<int>(big_value);

6
fmt/posix.cc
View File

@@ -124,7 +124,7 @@ void fmt::File::close() {
throw system_error(errno, "cannot close file"); throw system_error(errno, "cannot close file");
} }
fmt::long_long fmt::File::size() const { long long fmt::File::size() const {
#ifdef _WIN32 #ifdef _WIN32
// Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT // Use GetFileSize instead of GetFileSizeEx for the case when _WIN32_WINNT
// is less than 0x0500 as is the case with some default MinGW builds. // is less than 0x0500 as is the case with some default MinGW builds.
@@ -137,14 +137,14 @@ fmt::long_long fmt::File::size() const {
if (error != NO_ERROR) if (error != NO_ERROR)
throw windows_error(GetLastError(), "cannot get file size"); throw windows_error(GetLastError(), "cannot get file size");
} }
fmt::ulong_long long_size = size_upper; unsigned long long long_size = size_upper;
return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower; return (long_size << sizeof(DWORD) * CHAR_BIT) | size_lower;
#else #else
typedef struct stat Stat; typedef struct stat Stat;
Stat file_stat = Stat(); Stat file_stat = Stat();
if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1) if (FMT_POSIX_CALL(fstat(fd_, &file_stat)) == -1)
throw system_error(errno, "cannot get file attributes"); throw system_error(errno, "cannot get file attributes");
FMT_STATIC_ASSERT(sizeof(fmt::long_long) >= sizeof(file_stat.st_size), FMT_STATIC_ASSERT(sizeof(long long) >= sizeof(file_stat.st_size),
"return type of File::size is not large enough"); "return type of File::size is not large enough");
return file_stat.st_size; return file_stat.st_size;
#endif #endif

2
fmt/posix.h
View File

@@ -322,7 +322,7 @@ class File {
// Returns the file size. The size has signed type for consistency with // Returns the file size. The size has signed type for consistency with
// stat::st_size. // stat::st_size.
long_long size() const; long long size() const;
// Attempts to read count bytes from the file into the specified buffer. // Attempts to read count bytes from the file into the specified buffer.
std::size_t read(void *buffer, std::size_t count); std::size_t read(void *buffer, std::size_t count);

4
fmt/printf.h
View File

@@ -119,7 +119,7 @@ class ArgConverter {
// glibc's printf doesn't sign extend arguments of smaller types: // glibc's printf doesn't sign extend arguments of smaller types:
// std::printf("%lld", -42); // prints "4294967254" // std::printf("%lld", -42); // prints "4294967254"
// but we don't have to do the same because it's a UB. // but we don't have to do the same because it's a UB.
arg_ = internal::make_arg<Context>(static_cast<long_long>(value)); arg_ = internal::make_arg<Context>(static_cast<long long>(value));
} else { } else {
arg_ = internal::make_arg<Context>( arg_ = internal::make_arg<Context>(
static_cast<typename internal::make_unsigned<U>::type>(value)); static_cast<typename internal::make_unsigned<U>::type>(value));
@@ -486,7 +486,7 @@ void printf_context<Char, AF>::format(
break; break;
case 'l': case 'l':
if (*it == 'l') if (*it == 'l')
convert_arg<fmt::long_long>(arg, *++it); convert_arg<long long>(arg, *++it);
else else
convert_arg<long>(arg, *it); convert_arg<long>(arg, *it);
break; break;

7
test/format-impl-test.cc
View File

@@ -56,11 +56,10 @@ struct ValueExtractor {
}; };
TEST(FormatTest, ArgConverter) { TEST(FormatTest, ArgConverter) {
fmt::long_long value = std::numeric_limits<fmt::long_long>::max(); long long value = std::numeric_limits<long long>::max();
auto arg = fmt::internal::make_arg<fmt::context>(value); auto arg = fmt::internal::make_arg<fmt::context>(value);
visit(fmt::internal::ArgConverter< visit(fmt::internal::ArgConverter<long long, fmt::context>(arg, 'd'), arg);
fmt::long_long, fmt::context>(arg, 'd'), arg); EXPECT_EQ(value, visit(ValueExtractor<long long>(), arg));
EXPECT_EQ(value, visit(ValueExtractor<fmt::long_long>(), arg));
} }
TEST(FormatTest, FormatNegativeNaN) { TEST(FormatTest, FormatNegativeNaN) {

2
test/posix-mock-test.cc
View File

@@ -277,7 +277,7 @@ TEST(FileTest, Size) {
write_file("test", content); write_file("test", content);
File f("test", File::RDONLY); File f("test", File::RDONLY);
EXPECT_GE(f.size(), 0); EXPECT_GE(f.size(), 0);
EXPECT_EQ(content.size(), static_cast<fmt::ulong_long>(f.size())); EXPECT_EQ(content.size(), static_cast<unsigned long long>(f.size()));
#ifdef _WIN32 #ifdef _WIN32
fmt::memory_buffer message; fmt::memory_buffer message;
fmt::internal::format_windows_error( fmt::internal::format_windows_error(

36
test/printf-test.cc
View File

@@ -269,8 +269,8 @@ TEST(PrintfTest, DynamicPrecision) {
"argument index out of range"); "argument index out of range");
EXPECT_THROW_MSG(fmt::sprintf("%.*d", BIG_NUM, 42), format_error, EXPECT_THROW_MSG(fmt::sprintf("%.*d", BIG_NUM, 42), format_error,
"number is too big"); "number is too big");
if (sizeof(fmt::long_long) != sizeof(int)) { if (sizeof(long long) != sizeof(int)) {
fmt::long_long prec = static_cast<fmt::long_long>(INT_MIN) - 1; long long prec = static_cast<long long>(INT_MIN) - 1;
EXPECT_THROW_MSG(fmt::sprintf("%.*d", prec, 42), format_error, EXPECT_THROW_MSG(fmt::sprintf("%.*d", prec, 42), format_error,
"number is too big"); "number is too big");
} }
@@ -288,16 +288,16 @@ SPECIALIZE_MAKE_SIGNED(unsigned char, signed char);
SPECIALIZE_MAKE_SIGNED(unsigned short, short); SPECIALIZE_MAKE_SIGNED(unsigned short, short);
SPECIALIZE_MAKE_SIGNED(unsigned, int); SPECIALIZE_MAKE_SIGNED(unsigned, int);
SPECIALIZE_MAKE_SIGNED(unsigned long, long); SPECIALIZE_MAKE_SIGNED(unsigned long, long);
SPECIALIZE_MAKE_SIGNED(fmt::ulong_long, fmt::long_long); SPECIALIZE_MAKE_SIGNED(unsigned long long, long long);
// Test length format specifier ``length_spec``. // Test length format specifier ``length_spec``.
template <typename T, typename U> template <typename T, typename U>
void TestLength(const char *length_spec, U value) { void TestLength(const char *length_spec, U value) {
fmt::long_long signed_value = 0; long long signed_value = 0;
fmt::ulong_long unsigned_value = 0; unsigned long long unsigned_value = 0;
// Apply integer promotion to the argument. // Apply integer promotion to the argument.
using std::numeric_limits; using std::numeric_limits;
fmt::ulong_long max = numeric_limits<U>::max(); unsigned long long max = numeric_limits<U>::max();
using fmt::internal::const_check; using fmt::internal::const_check;
if (const_check(max <= static_cast<unsigned>(numeric_limits<int>::max()))) { if (const_check(max <= static_cast<unsigned>(numeric_limits<int>::max()))) {
signed_value = static_cast<int>(value); signed_value = static_cast<int>(value);
@@ -308,7 +308,7 @@ void TestLength(const char *length_spec, U value) {
} }
using fmt::internal::make_unsigned; using fmt::internal::make_unsigned;
if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) { if (sizeof(U) <= sizeof(int) && sizeof(int) < sizeof(T)) {
signed_value = static_cast<fmt::long_long>(value); signed_value = static_cast<long long>(value);
unsigned_value = static_cast<typename make_unsigned<unsigned>::type>(value); unsigned_value = static_cast<typename make_unsigned<unsigned>::type>(value);
} else { } else {
signed_value = static_cast<typename make_signed<T>::type>(value); signed_value = static_cast<typename make_signed<T>::type>(value);
@@ -339,20 +339,20 @@ void TestLength(const char *length_spec) {
TestLength<T>(length_spec, -42); TestLength<T>(length_spec, -42);
TestLength<T>(length_spec, min); TestLength<T>(length_spec, min);
TestLength<T>(length_spec, max); TestLength<T>(length_spec, max);
TestLength<T>(length_spec, fmt::long_long(min) - 1); TestLength<T>(length_spec, static_cast<long long>(min) - 1);
fmt::ulong_long long_long_max = std::numeric_limits<fmt::long_long>::max(); unsigned long long long_long_max = std::numeric_limits<long long>::max();
if (static_cast<fmt::ulong_long>(max) < long_long_max) if (static_cast<unsigned long long>(max) < long_long_max)
TestLength<T>(length_spec, fmt::long_long(max) + 1); TestLength<T>(length_spec, static_cast<long long>(max) + 1);
TestLength<T>(length_spec, std::numeric_limits<short>::min()); TestLength<T>(length_spec, std::numeric_limits<short>::min());
TestLength<T>(length_spec, std::numeric_limits<unsigned short>::max()); TestLength<T>(length_spec, std::numeric_limits<unsigned short>::max());
TestLength<T>(length_spec, std::numeric_limits<int>::min()); TestLength<T>(length_spec, std::numeric_limits<int>::min());
TestLength<T>(length_spec, std::numeric_limits<int>::max()); TestLength<T>(length_spec, std::numeric_limits<int>::max());
TestLength<T>(length_spec, std::numeric_limits<unsigned>::min()); TestLength<T>(length_spec, std::numeric_limits<unsigned>::min());
TestLength<T>(length_spec, std::numeric_limits<unsigned>::max()); TestLength<T>(length_spec, std::numeric_limits<unsigned>::max());
TestLength<T>(length_spec, std::numeric_limits<fmt::long_long>::min()); TestLength<T>(length_spec, std::numeric_limits<long long>::min());
TestLength<T>(length_spec, std::numeric_limits<fmt::long_long>::max()); TestLength<T>(length_spec, std::numeric_limits<long long>::max());
TestLength<T>(length_spec, std::numeric_limits<fmt::ulong_long>::min()); TestLength<T>(length_spec, std::numeric_limits<unsigned long long>::min());
TestLength<T>(length_spec, std::numeric_limits<fmt::ulong_long>::max()); TestLength<T>(length_spec, std::numeric_limits<unsigned long long>::max());
} }
TEST(PrintfTest, Length) { TEST(PrintfTest, Length) {
@@ -363,8 +363,8 @@ TEST(PrintfTest, Length) {
TestLength<unsigned short>("h"); TestLength<unsigned short>("h");
TestLength<long>("l"); TestLength<long>("l");
TestLength<unsigned long>("l"); TestLength<unsigned long>("l");
TestLength<fmt::long_long>("ll"); TestLength<long long>("ll");
TestLength<fmt::ulong_long>("ll"); TestLength<unsigned long long>("ll");
TestLength<intmax_t>("j"); TestLength<intmax_t>("j");
TestLength<std::size_t>("z"); TestLength<std::size_t>("z");
TestLength<std::ptrdiff_t>("t"); TestLength<std::ptrdiff_t>("t");
@@ -391,7 +391,7 @@ TEST(PrintfTest, Int) {
TEST(PrintfTest, long_long) { TEST(PrintfTest, long_long) {
// fmt::printf allows passing long long arguments to %d without length // fmt::printf allows passing long long arguments to %d without length
// specifiers. // specifiers.
fmt::long_long max = std::numeric_limits<fmt::long_long>::max(); long long max = std::numeric_limits<long long>::max();
EXPECT_PRINTF(fmt::format("{}", max), "%d", max); EXPECT_PRINTF(fmt::format("{}", max), "%d", max);
} }

6
test/util-test.cc
View File

@@ -510,8 +510,8 @@ VISIT_TYPE(unsigned short, unsigned);
VISIT_TYPE(long, int); VISIT_TYPE(long, int);
VISIT_TYPE(unsigned long, unsigned); VISIT_TYPE(unsigned long, unsigned);
#else #else
VISIT_TYPE(long, fmt::long_long); VISIT_TYPE(long, long long);
VISIT_TYPE(unsigned long, fmt::ulong_long); VISIT_TYPE(unsigned long, unsigned long long);
#endif #endif
VISIT_TYPE(float, double); VISIT_TYPE(float, double);
@@ -533,7 +533,7 @@ class NumericArgTest : public testing::Test {};
typedef ::testing::Types< typedef ::testing::Types<
bool, signed char, unsigned char, signed, unsigned short, bool, signed char, unsigned char, signed, unsigned short,
int, unsigned, long, unsigned long, fmt::long_long, fmt::ulong_long, int, unsigned, long, unsigned long, long long, unsigned long long,
float, double, long double> Types; float, double, long double> Types;
TYPED_TEST_CASE(NumericArgTest, Types); TYPED_TEST_CASE(NumericArgTest, Types);