External/fmt
8
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

clang-format, test fixes

Browse Source
This commit is contained in:
Walter Gray 2020-11-30 11:21:34 -08:00
parent 2f9484c74b
commit 3b6d21be15
3 changed files with 85 additions and 81 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
include/fmt/chrono.h
View File

@ -777,8 +777,7 @@ template <typename Char, typename Rep, typename OutputIt,
OutputIt format_duration_value(OutputIt out, Rep val, int precision) { OutputIt format_duration_value(OutputIt out, Rep val, int precision) {
static FMT_CONSTEXPR_DECL const Char pr_f[] = {'{', ':', '.', '{', static FMT_CONSTEXPR_DECL const Char pr_f[] = {'{', ':', '.', '{',
'}', 'f', '}', 0}; '}', 'f', '}', 0};
if (precision >= 0) if (precision >= 0) return format_to(out, FMT_STRING(pr_f), val, precision);
return format_to(out, FMT_STRING(pr_f), val, precision);
static FMT_CONSTEXPR_DECL const Char fp_f[] = {'{', ':', 'g', '}', 0}; static FMT_CONSTEXPR_DECL const Char fp_f[] = {'{', ':', 'g', '}', 0};
return format_to(out, FMT_STRING(fp_f), val); return format_to(out, FMT_STRING(fp_f), val);
} }
@ -805,8 +804,7 @@ OutputIt format_duration_unit(OutputIt out) {
return format_to(out, FMT_STRING(num_f), Period::num); return format_to(out, FMT_STRING(num_f), Period::num);
static FMT_CONSTEXPR_DECL const Char num_def_f[] = {'[', '{', '}', '/', '{', static FMT_CONSTEXPR_DECL const Char num_def_f[] = {'[', '{', '}', '/', '{',
'}', ']', 's', 0}; '}', ']', 's', 0};
return format_to(out, FMT_STRING(num_def_f), Period::num, return format_to(out, FMT_STRING(num_def_f), Period::num, Period::den);
Period::den);
} }
template <typename FormatContext, typename OutputIt, typename Rep, template <typename FormatContext, typename OutputIt, typename Rep,

3
include/fmt/core.h
View File

@ -1841,7 +1841,8 @@ inline auto format_to_n(OutputIt out, size_t n, const S& format_str,
Returns the number of characters in the output of Returns the number of characters in the output of
``format(format_str, args...)``. ``format(format_str, args...)``.
*/ */
template <typename S, typename... Args, FMT_ENABLE_IF(is_compile_string<S>::value)> template <typename S, typename... Args,
FMT_ENABLE_IF(is_compile_string<S>::value)>
inline size_t formatted_size(const S& format_str, Args&&... args) { inline size_t formatted_size(const S& format_str, Args&&... args) {
const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...); const auto& vargs = fmt::make_args_checked<Args...>(format_str, args...);
detail::counting_buffer<> buf; detail::counting_buffer<> buf;

151
test/enforce-compiletime-test.cc
View File

@ -5,20 +5,25 @@
// //
// For the license information refer to format.h. // For the license information refer to format.h.
#include <list> #include <array>
#include <iterator> #include <iterator>
#include <list>
#include <map>
#include <sstream>
#include <string> #include <string>
#include <utility> #include <utility>
#include <vector>
#ifdef WIN32 #ifdef WIN32
# define _CRT_SECURE_NO_WARNINGS # define _CRT_SECURE_NO_WARNINGS
#endif #endif
#include "fmt/format.h"
#include "fmt/locale.h"
#include "fmt/chrono.h" #include "fmt/chrono.h"
#include "fmt/color.h" #include "fmt/color.h"
#include "fmt/format.h"
#include "fmt/locale.h"
#include "fmt/ostream.h" #include "fmt/ostream.h"
#include "fmt/ranges.h"
#undef index #undef index
@ -52,7 +57,15 @@ template <> struct formatter<Answer> : formatter<int> {
}; };
FMT_END_NAMESPACE FMT_END_NAMESPACE
struct string_like {}; struct string_like {
const char* begin();
const char* end();
#if defined(FMT_USE_STRING_VIEW)
explicit operator fmt::string_view() const { return "foo"; }
explicit operator std::string_view() const { return "foo"; }
#endif
};
fmt::string_view to_string_view(string_like) { return "foo"; } fmt::string_view to_string_view(string_like) { return "foo"; }
constexpr char with_null[3] = {'{', '}', '\0'}; constexpr char with_null[3] = {'{', '}', '\0'};
@ -197,7 +210,8 @@ TEST(FormatTest, FormatToN) {
EXPECT_EQ("ABCD", fmt::string_view(buffer, 4)); EXPECT_EQ("ABCD", fmt::string_view(buffer, 4));
buffer[3] = 'x'; buffer[3] = 'x';
result = fmt::format_to_n(buffer, 3, FMT_STRING("{}"), std::string(1000, '*')); result =
fmt::format_to_n(buffer, 3, FMT_STRING("{}"), std::string(1000, '*'));
EXPECT_EQ(1000u, result.size); EXPECT_EQ(1000u, result.size);
EXPECT_EQ("***x", fmt::string_view(buffer, 4)); EXPECT_EQ("***x", fmt::string_view(buffer, 4));
} }
@ -274,10 +288,6 @@ TEST(FormatTest, FmtStringInTemplate) {
EXPECT_EQ(FmtToString(0), "0"); EXPECT_EQ(FmtToString(0), "0");
} }
#include "fmt/chrono.h"
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
TEST(ChronoTest, FormatDefault) { TEST(ChronoTest, FormatDefault) {
@ -306,7 +316,7 @@ TEST(ChronoTest, FormatFullSpecs) {
TEST(ChronoTest, FormatSimpleQq) { TEST(ChronoTest, FormatSimpleQq) {
typedef std::chrono::duration<float> fs; typedef std::chrono::duration<float> fs;
//EXPECT_EQ("1.234 s", fmt::format(FMT_STRING("{:%Q %q}"), fs(1.234))); // EXPECT_EQ("1.234 s", fmt::format(FMT_STRING("{:%Q %q}"), fs(1.234)));
typedef std::chrono::duration<float, std::milli> fms; typedef std::chrono::duration<float, std::milli> fms;
EXPECT_EQ("1.234 ms", fmt::format(FMT_STRING("{:%Q %q}"), fms(1.234))); EXPECT_EQ("1.234 ms", fmt::format(FMT_STRING("{:%Q %q}"), fms(1.234)));
typedef std::chrono::duration<double> ds; typedef std::chrono::duration<double> ds;
@ -321,62 +331,74 @@ TEST(ChronoTest, FormatPrecisionQq) {
TEST(ChronoTest, FormatFullSpecsQq) { TEST(ChronoTest, FormatFullSpecsQq) {
EXPECT_EQ("1.2 ms ", fmt::format(FMT_STRING("{:7.1%Q %q}"), dms(1.234))); EXPECT_EQ("1.2 ms ", fmt::format(FMT_STRING("{:7.1%Q %q}"), dms(1.234)));
EXPECT_EQ(" 1.2 ms ", fmt::format(FMT_STRING("{:^{}.{}%Q %q}"), dms(1.234), 8, 1)); EXPECT_EQ(" 1.2 ms ",
fmt::format(FMT_STRING("{:^{}.{}%Q %q}"), dms(1.234), 8, 1));
} }
TEST(ChronoTest, UnsignedDuration) { TEST(ChronoTest, UnsignedDuration) {
EXPECT_EQ("42s", fmt::format(FMT_STRING("{}"), std::chrono::duration<unsigned>(42))); EXPECT_EQ("42s",
fmt::format(FMT_STRING("{}"), std::chrono::duration<unsigned>(42)));
} }
#endif // FMT_STATIC_THOUSANDS_SEPARATOR #endif // FMT_STATIC_THOUSANDS_SEPARATOR
TEST(ColorsTest, ColorsPrint) { TEST(ColorsTest, ColorsPrint) {
EXPECT_WRITE(stdout, fmt::print(fg(fmt::rgb(255, 20, 30)), FMT_STRING("rgb(255,20,30)")),
"\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
EXPECT_WRITE( EXPECT_WRITE(
stdout, stdout,
fmt::print(fg(fmt::color::blue) | bg(fmt::color::red), FMT_STRING("two color")), fmt::print(fg(fmt::rgb(255, 20, 30)), FMT_STRING("rgb(255,20,30)")),
"\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m"); "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m");
EXPECT_WRITE(stdout,
fmt::print(fg(fmt::color::blue) | bg(fmt::color::red),
FMT_STRING("two color")),
"\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m");
EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::bold, FMT_STRING("bold")), EXPECT_WRITE(stdout, fmt::print(fmt::emphasis::bold, FMT_STRING("bold")),
"\x1b[1mbold\x1b[0m"); "\x1b[1mbold\x1b[0m");
EXPECT_WRITE( EXPECT_WRITE(stdout,
stdout, fmt::print(fg(fmt::color::blue) | fmt::emphasis::bold,
fmt::print(fg(fmt::color::blue) | fmt::emphasis::bold, FMT_STRING("blue/bold")), FMT_STRING("blue/bold")),
"\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m"); "\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m");
EXPECT_WRITE(stdout, fmt::print(fmt::text_style(), FMT_STRING("hi")), "hi"); EXPECT_WRITE(stdout, fmt::print(fmt::text_style(), FMT_STRING("hi")), "hi");
EXPECT_WRITE(stdout, fmt::print(fg(fmt::terminal_color::red), FMT_STRING("tred")), EXPECT_WRITE(stdout,
fmt::print(fg(fmt::terminal_color::red), FMT_STRING("tred")),
"\x1b[31mtred\x1b[0m"); "\x1b[31mtred\x1b[0m");
EXPECT_WRITE(stdout, fmt::print(bg(fmt::terminal_color::cyan), FMT_STRING("tcyan")), EXPECT_WRITE(stdout,
fmt::print(bg(fmt::terminal_color::cyan), FMT_STRING("tcyan")),
"\x1b[46mtcyan\x1b[0m"); "\x1b[46mtcyan\x1b[0m");
EXPECT_WRITE(stdout, EXPECT_WRITE(stdout,
fmt::print(bg(fmt::terminal_color::bright_magenta), FMT_STRING("tbmagenta")), fmt::print(bg(fmt::terminal_color::bright_magenta),
FMT_STRING("tbmagenta")),
"\x1b[105mtbmagenta\x1b[0m"); "\x1b[105mtbmagenta\x1b[0m");
} }
TEST(ColorsTest, Format) { TEST(ColorsTest, Format) {
EXPECT_EQ("\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m", fmt::format(fg(fmt::rgb(255, 20, 30)), FMT_STRING("rgb(255,20,30)")));
EXPECT_EQ("\x1b[38;2;000;000;255mblue\x1b[0m", fmt::format(fg(fmt::color::blue), FMT_STRING("blue")));
EXPECT_EQ( EXPECT_EQ(
"\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m", "\x1b[38;2;255;020;030mrgb(255,20,30)\x1b[0m",
fmt::format(fg(fmt::color::blue) | bg(fmt::color::red), FMT_STRING("two color"))); fmt::format(fg(fmt::rgb(255, 20, 30)), FMT_STRING("rgb(255,20,30)")));
EXPECT_EQ("\x1b[1mbold\x1b[0m", fmt::format(fmt::emphasis::bold, FMT_STRING("bold"))); EXPECT_EQ("\x1b[38;2;000;000;255mblue\x1b[0m",
EXPECT_EQ( fmt::format(fg(fmt::color::blue), FMT_STRING("blue")));
"\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m", EXPECT_EQ("\x1b[38;2;000;000;255m\x1b[48;2;255;000;000mtwo color\x1b[0m",
fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold, FMT_STRING("blue/bold"))); fmt::format(fg(fmt::color::blue) | bg(fmt::color::red),
FMT_STRING("two color")));
EXPECT_EQ("\x1b[1mbold\x1b[0m",
fmt::format(fmt::emphasis::bold, FMT_STRING("bold")));
EXPECT_EQ("\x1b[1m\x1b[38;2;000;000;255mblue/bold\x1b[0m",
fmt::format(fg(fmt::color::blue) | fmt::emphasis::bold,
FMT_STRING("blue/bold")));
EXPECT_EQ("hi", fmt::format(fmt::text_style(), FMT_STRING("hi"))); EXPECT_EQ("hi", fmt::format(fmt::text_style(), FMT_STRING("hi")));
EXPECT_EQ("\x1b[31mtred\x1b[0m", EXPECT_EQ("\x1b[31mtred\x1b[0m",
fmt::format(fg(fmt::terminal_color::red), FMT_STRING("tred"))); fmt::format(fg(fmt::terminal_color::red), FMT_STRING("tred")));
EXPECT_EQ("\x1b[46mtcyan\x1b[0m", EXPECT_EQ("\x1b[46mtcyan\x1b[0m",
fmt::format(bg(fmt::terminal_color::cyan), FMT_STRING("tcyan"))); fmt::format(bg(fmt::terminal_color::cyan), FMT_STRING("tcyan")));
EXPECT_EQ("\x1b[105mtbmagenta\x1b[0m", EXPECT_EQ("\x1b[105mtbmagenta\x1b[0m",
fmt::format(bg(fmt::terminal_color::bright_magenta), FMT_STRING("tbmagenta"))); fmt::format(bg(fmt::terminal_color::bright_magenta),
FMT_STRING("tbmagenta")));
} }
TEST(ColorsTest, FormatToOutAcceptsTextStyle) { TEST(ColorsTest, FormatToOutAcceptsTextStyle) {
fmt::text_style ts = fg(fmt::rgb(255, 20, 30)); fmt::text_style ts = fg(fmt::rgb(255, 20, 30));
std::string out; std::string out;
fmt::format_to(std::back_inserter(out), ts, FMT_STRING("rgb(255,20,30){}{}{}"), 1, 2, 3); fmt::format_to(std::back_inserter(out), ts,
FMT_STRING("rgb(255,20,30){}{}{}"), 1, 2, 3);
EXPECT_EQ(fmt::to_string(out), EXPECT_EQ(fmt::to_string(out),
"\x1b[38;2;255;020;030mrgb(255,20,30)123\x1b[0m"); "\x1b[38;2;255;020;030mrgb(255,20,30)123\x1b[0m");
@ -389,9 +411,6 @@ TEST(ColorsTest, FormatToOutAcceptsTextStyle) {
// //
// For the license information refer to format.h. // For the license information refer to format.h.
#define FMT_STRING_ALIAS 1
#include "fmt/format.h"
struct test {}; struct test {};
// Test that there is no issues with specializations when fmt/ostream.h is // Test that there is no issues with specializations when fmt/ostream.h is
@ -405,10 +424,6 @@ template <> struct formatter<test> : formatter<int> {
}; };
} // namespace fmt } // namespace fmt
#include <sstream>
#include "fmt/ostream.h"
struct EmptyTest {}; struct EmptyTest {};
static std::ostream& operator<<(std::ostream& os, EmptyTest) { static std::ostream& operator<<(std::ostream& os, EmptyTest) {
return os << ""; return os << "";
@ -429,7 +444,8 @@ TEST(OStreamTest, Print) {
TEST(OStreamTest, Join) { TEST(OStreamTest, Join) {
int v[3] = {1, 2, 3}; int v[3] = {1, 2, 3};
EXPECT_EQ("1, 2, 3", fmt::format(FMT_STRING("{}"), fmt::join(v, v + 3, ", "))); EXPECT_EQ("1, 2, 3",
fmt::format(FMT_STRING("{}"), fmt::join(v, v + 3, ", ")));
} }
namespace fmt_test { namespace fmt_test {
@ -480,18 +496,10 @@ TEST(OStreamTest, ToString) {
EXPECT_EQ("ABC", fmt::to_string(fmt_test::ABC())); EXPECT_EQ("ABC", fmt::to_string(fmt_test::ABC()));
} }
#include "fmt/ranges.h"
// Check if 'if constexpr' is supported. // Check if 'if constexpr' is supported.
#if (__cplusplus > 201402L) || \ #if (__cplusplus > 201402L) || \
(defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910) (defined(_MSVC_LANG) && _MSVC_LANG > 201402L && _MSC_VER >= 1910)
# include <array>
# include <map>
# include <string>
# include <vector>
TEST(RangesTest, FormatArray) { TEST(RangesTest, FormatArray) {
int32_t ia[] = {1, 2, 3, 5, 7, 11}; int32_t ia[] = {1, 2, 3, 5, 7, 11};
auto iaf = fmt::format(FMT_STRING("{}"), ia); auto iaf = fmt::format(FMT_STRING("{}"), ia);
@ -518,7 +526,8 @@ TEST(RangesTest, FormatVector2) {
TEST(RangesTest, FormatMap) { TEST(RangesTest, FormatMap) {
std::map<std::string, int32_t> simap{{"one", 1}, {"two", 2}}; std::map<std::string, int32_t> simap{{"one", 1}, {"two", 2}};
EXPECT_EQ("{(\"one\", 1), (\"two\", 2)}", fmt::format(FMT_STRING("{}"), simap)); EXPECT_EQ("{(\"one\", 1), (\"two\", 2)}",
fmt::format(FMT_STRING("{}"), simap));
} }
TEST(RangesTest, FormatPair) { TEST(RangesTest, FormatPair) {
@ -529,7 +538,8 @@ TEST(RangesTest, FormatPair) {
TEST(RangesTest, FormatTuple) { TEST(RangesTest, FormatTuple) {
std::tuple<int64_t, float, std::string, char> t{42, 1.5f, "this is tuple", std::tuple<int64_t, float, std::string, char> t{42, 1.5f, "this is tuple",
'i'}; 'i'};
EXPECT_EQ("(42, 1.5, \"this is tuple\", 'i')", fmt::format(FMT_STRING("{}"), t)); EXPECT_EQ("(42, 1.5, \"this is tuple\", 'i')",
fmt::format(FMT_STRING("{}"), t));
EXPECT_EQ("()", fmt::format(FMT_STRING("{}"), std::tuple<>())); EXPECT_EQ("()", fmt::format(FMT_STRING("{}"), std::tuple<>()));
} }
@ -553,9 +563,10 @@ TEST(RangesTest, JoinTuple) {
} }
TEST(RangesTest, JoinInitializerList) { TEST(RangesTest, JoinInitializerList) {
EXPECT_EQ("1, 2, 3", fmt::format(FMT_STRING("{}"), fmt::join({1, 2, 3}, ", "))); EXPECT_EQ("1, 2, 3",
EXPECT_EQ("fmt rocks !", fmt::format(FMT_STRING("{}"), fmt::join({1, 2, 3}, ", ")));
fmt::format(FMT_STRING("{}"), fmt::join({"fmt", "rocks", "!"}, " "))); EXPECT_EQ("fmt rocks !", fmt::format(FMT_STRING("{}"),
fmt::join({"fmt", "rocks", "!"}, " ")));
} }
struct my_struct { struct my_struct {
@ -610,13 +621,6 @@ TEST(RangesTest, PathLike) {
// 201402L && _MSC_VER >= 1910) // 201402L && _MSC_VER >= 1910)
#ifdef FMT_USE_STRING_VIEW #ifdef FMT_USE_STRING_VIEW
struct string_like {
const char* begin();
const char* end();
explicit operator fmt::string_view() const { return "foo"; }
explicit operator std::string_view() const { return "foo"; }
};
TEST(RangesTest, FormatStringLike) { TEST(RangesTest, FormatStringLike) {
EXPECT_EQ("foo", fmt::format(FMT_STRING("{}"), string_like())); EXPECT_EQ("foo", fmt::format(FMT_STRING("{}"), string_like()));
} }
@ -636,8 +640,9 @@ struct zstring {
// TODO: Fix using zstrings with FMT_STRING // TODO: Fix using zstrings with FMT_STRING
TEST(RangesTest, JoinSentinel) { TEST(RangesTest, JoinSentinel) {
zstring hello{"hello"}; zstring hello{"hello"};
//EXPECT_EQ("{'h', 'e', 'l', 'l', 'o'}", fmt::format(FMT_STRING("{}"), hello)); // EXPECT_EQ("{'h', 'e', 'l', 'l', 'o'}", fmt::format(FMT_STRING("{}"),
//EXPECT_EQ("h_e_l_l_o", fmt::format(FMT_STRING("{}"), fmt::join(hello, "_"))); // hello)); EXPECT_EQ("h_e_l_l_o", fmt::format(FMT_STRING("{}"),
// fmt::join(hello, "_")));
} }
// A range that provides non-const only begin()/end() to test fmt::join handles // A range that provides non-const only begin()/end() to test fmt::join handles
@ -678,19 +683,22 @@ template <typename T> class noncopyable_range {
const_iterator end() const { return vec.end(); } const_iterator end() const { return vec.end(); }
}; };
//TODO: Fixme // TODO: Fixme
TEST(RangesTest, Range) { TEST(RangesTest, Range) {
noncopyable_range<int> w(3u, 0); noncopyable_range<int> w(3u, 0);
/*EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), w)); /*EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), w));
EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), noncopyable_range<int>(3u, 0))); EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"),
noncopyable_range<int>(3u, 0)));
non_const_only_range<int> x(3u, 0); non_const_only_range<int> x(3u, 0);
EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), x)); EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), x));
EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), non_const_only_range<int>(3u, 0))); EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"),
non_const_only_range<int>(3u, 0)));
std::vector<int> y(3u, 0); std::vector<int> y(3u, 0);
EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), y)); EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), y));
EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), std::vector<int>(3u, 0))); EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), std::vector<int>(3u,
0)));
const std::vector<int> z(3u, 0); const std::vector<int> z(3u, 0);
EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), z));*/ EXPECT_EQ("{0, 0, 0}", fmt::format(FMT_STRING("{}"), z));*/
@ -704,6 +712,3 @@ TEST(RangesTest, UnformattableRange) {
fmt::format_context>::value)); fmt::format_context>::value));
} }
#endif #endif