mirror/fmt
1
0
Fork 0
mirror of https://github.com/fmtlib/fmt.git synced 2025-01-11 21:38:05 +00:00
Code Issues Packages Projects Releases Wiki Activity

More tests

Browse Source
This commit is contained in:
Victor Zverovich 2017-11-18 07:42:54 -08:00
parent e3eb5ea074
commit 39411504a5
3 changed files with 74 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

51
include/fmt/format.h
View File

@ -2192,32 +2192,32 @@ class specs_checker : public Handler {
constexpr void on_align(alignment align) { constexpr void on_align(alignment align) {
if (align == ALIGN_NUMERIC) if (align == ALIGN_NUMERIC)
require_numeric_argument('='); require_numeric_argument();
Handler::on_align(align); Handler::on_align(align);
} }
constexpr void on_plus() { constexpr void on_plus() {
check_sign('+'); check_sign();
Handler::on_plus(); Handler::on_plus();
} }
constexpr void on_minus() { constexpr void on_minus() {
check_sign('-'); check_sign();
Handler::on_minus(); Handler::on_minus();
} }
constexpr void on_space() { constexpr void on_space() {
check_sign(' '); check_sign();
Handler::on_space(); Handler::on_space();
} }
constexpr void on_hash() { constexpr void on_hash() {
require_numeric_argument('#'); require_numeric_argument();
Handler::on_hash(); Handler::on_hash();
} }
constexpr void on_zero() { constexpr void on_zero() {
require_numeric_argument('0'); require_numeric_argument();
Handler::on_zero(); Handler::on_zero();
} }
@ -2227,26 +2227,16 @@ class specs_checker : public Handler {
} }
private: private:
template <typename... Args> constexpr void require_numeric_argument() {
void report_error(string_view format_str, const Args &... args) { if (!is_numeric(arg_type_))
this->on_error(format(format_str, args...).c_str()); this->on_error("format specifier requires numeric argument");
} }
template <typename Char> constexpr void check_sign() {
constexpr void require_numeric_argument(Char spec) { require_numeric_argument();
if (!is_numeric(arg_type_)) {
report_error("format specifier '{}' requires numeric argument",
static_cast<char>(spec));
}
}
template <typename Char>
constexpr void check_sign(Char sign) {
require_numeric_argument(sign);
if (is_integral(arg_type_) && arg_type_ != INT && arg_type_ != LONG_LONG && if (is_integral(arg_type_) && arg_type_ != INT && arg_type_ != LONG_LONG &&
arg_type_ != CHAR) { arg_type_ != CHAR) {
report_error("format specifier '{}' requires signed argument", this->on_error("format specifier requires signed argument");
static_cast<char>(sign));
} }
} }
@ -2636,7 +2626,7 @@ class format_string_checker : public ErrorHandler {
constexpr const Char *on_format_specs(const Char *s) { constexpr const Char *on_format_specs(const Char *s) {
parse_context_type ctx(basic_string_view<Char>(s, end_ - s), *this); parse_context_type ctx(basic_string_view<Char>(s, end_ - s), *this);
return parse_funcs_[arg_index_](ctx); return arg_index_ < NUM_ARGS ? parse_funcs_[arg_index_](ctx) : s;
} }
private: private:
@ -3200,9 +3190,9 @@ void basic_writer<Char>::write_int(T value, const Spec& spec) {
unsigned_type abs_value; unsigned_type abs_value;
char prefix[4] = ""; char prefix[4] = "";
spec_handler(basic_writer<Char> &w, T value, const Spec& s) spec_handler(basic_writer<Char> &w, T val, const Spec& s)
: writer(w), spec(s), abs_value(static_cast<unsigned_type>(value)) { : writer(w), spec(s), abs_value(static_cast<unsigned_type>(val)) {
if (internal::is_negative(value)) { if (internal::is_negative(val)) {
prefix[0] = '-'; prefix[0] = '-';
++prefix_size; ++prefix_size;
abs_value = 0 - abs_value; abs_value = 0 - abs_value;
@ -3769,10 +3759,9 @@ struct formatter<
handler(handler_type(specs_, ctx), internal::get_type<T>()); handler(handler_type(specs_, ctx), internal::get_type<T>());
it = parse_format_specs(it, handler); it = parse_format_specs(it, handler);
if (std::is_integral<T>::value) { if (std::is_integral<T>::value) {
using type_checker = auto eh = ctx.error_handler();
internal::int_type_checker<decltype(ctx.error_handler())>;
handle_integral_type_spec( handle_integral_type_spec(
specs_.type(), type_checker(ctx.error_handler())); specs_.type(), internal::int_type_checker<decltype(eh)>(eh));
} }
return pointer_from(it); return pointer_from(it);
} }
@ -3887,9 +3876,9 @@ void vformat_to(basic_buffer<Char> &buffer, basic_string_view<Char> format_str,
using iterator = internal::null_terminating_iterator<Char>; using iterator = internal::null_terminating_iterator<Char>;
struct handler : internal::error_handler { struct handler : internal::error_handler {
handler(basic_buffer<Char> &b, basic_string_view<Char> format_str, handler(basic_buffer<Char> &b, basic_string_view<Char> str,
basic_args<Context> args) basic_args<Context> args)
: buffer(b), context(format_str, args) {} : buffer(b), context(str, args) {}
void on_text(iterator begin, iterator end) { void on_text(iterator begin, iterator end) {
buffer.append(pointer_from(begin), pointer_from(end)); buffer.append(pointer_from(begin), pointer_from(end));

76
test/format-test.cc
View File

@ -563,9 +563,9 @@ TEST(FormatterTest, NumericAlign) {
EXPECT_THROW_MSG(format("{0:=5}", 'c'), EXPECT_THROW_MSG(format("{0:=5}", 'c'),
format_error, "invalid format specifier for char"); format_error, "invalid format specifier for char");
EXPECT_THROW_MSG(format("{0:=5}", "abc"), EXPECT_THROW_MSG(format("{0:=5}", "abc"),
format_error, "format specifier '=' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)), EXPECT_THROW_MSG(format("{0:=8}", reinterpret_cast<void*>(0xface)),
format_error, "format specifier '=' requires numeric argument"); format_error, "format specifier requires numeric argument");
} }
TEST(FormatterTest, CenterAlign) { TEST(FormatterTest, CenterAlign) {
@ -609,13 +609,13 @@ TEST(FormatterTest, PlusSign) {
EXPECT_EQ("-42", format("{0:+}", -42)); EXPECT_EQ("-42", format("{0:+}", -42));
EXPECT_EQ("+42", format("{0:+}", 42)); EXPECT_EQ("+42", format("{0:+}", 42));
EXPECT_THROW_MSG(format("{0:+}", 42u), EXPECT_THROW_MSG(format("{0:+}", 42u),
format_error, "format specifier '+' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ("+42", format("{0:+}", 42l)); EXPECT_EQ("+42", format("{0:+}", 42l));
EXPECT_THROW_MSG(format("{0:+}", 42ul), EXPECT_THROW_MSG(format("{0:+}", 42ul),
format_error, "format specifier '+' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ("+42", format("{0:+}", 42ll)); EXPECT_EQ("+42", format("{0:+}", 42ll));
EXPECT_THROW_MSG(format("{0:+}", 42ull), EXPECT_THROW_MSG(format("{0:+}", 42ull),
format_error, "format specifier '+' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ("+42", format("{0:+}", 42.0)); EXPECT_EQ("+42", format("{0:+}", 42.0));
EXPECT_EQ("+42", format("{0:+}", 42.0l)); EXPECT_EQ("+42", format("{0:+}", 42.0l));
EXPECT_THROW_MSG(format("{0:+", 'c'), EXPECT_THROW_MSG(format("{0:+", 'c'),
@ -623,9 +623,9 @@ TEST(FormatterTest, PlusSign) {
EXPECT_THROW_MSG(format("{0:+}", 'c'), EXPECT_THROW_MSG(format("{0:+}", 'c'),
format_error, "invalid format specifier for char"); format_error, "invalid format specifier for char");
EXPECT_THROW_MSG(format("{0:+}", "abc"), EXPECT_THROW_MSG(format("{0:+}", "abc"),
format_error, "format specifier '+' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)), EXPECT_THROW_MSG(format("{0:+}", reinterpret_cast<void*>(0x42)),
format_error, "format specifier '+' requires numeric argument"); format_error, "format specifier requires numeric argument");
} }
TEST(FormatterTest, MinusSign) { TEST(FormatterTest, MinusSign) {
@ -633,13 +633,13 @@ TEST(FormatterTest, MinusSign) {
EXPECT_EQ("-42", format("{0:-}", -42)); EXPECT_EQ("-42", format("{0:-}", -42));
EXPECT_EQ("42", format("{0:-}", 42)); EXPECT_EQ("42", format("{0:-}", 42));
EXPECT_THROW_MSG(format("{0:-}", 42u), EXPECT_THROW_MSG(format("{0:-}", 42u),
format_error, "format specifier '-' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ("42", format("{0:-}", 42l)); EXPECT_EQ("42", format("{0:-}", 42l));
EXPECT_THROW_MSG(format("{0:-}", 42ul), EXPECT_THROW_MSG(format("{0:-}", 42ul),
format_error, "format specifier '-' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ("42", format("{0:-}", 42ll)); EXPECT_EQ("42", format("{0:-}", 42ll));
EXPECT_THROW_MSG(format("{0:-}", 42ull), EXPECT_THROW_MSG(format("{0:-}", 42ull),
format_error, "format specifier '-' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ("42", format("{0:-}", 42.0)); EXPECT_EQ("42", format("{0:-}", 42.0));
EXPECT_EQ("42", format("{0:-}", 42.0l)); EXPECT_EQ("42", format("{0:-}", 42.0l));
EXPECT_THROW_MSG(format("{0:-", 'c'), EXPECT_THROW_MSG(format("{0:-", 'c'),
@ -647,9 +647,9 @@ TEST(FormatterTest, MinusSign) {
EXPECT_THROW_MSG(format("{0:-}", 'c'), EXPECT_THROW_MSG(format("{0:-}", 'c'),
format_error, "invalid format specifier for char"); format_error, "invalid format specifier for char");
EXPECT_THROW_MSG(format("{0:-}", "abc"), EXPECT_THROW_MSG(format("{0:-}", "abc"),
format_error, "format specifier '-' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)), EXPECT_THROW_MSG(format("{0:-}", reinterpret_cast<void*>(0x42)),
format_error, "format specifier '-' requires numeric argument"); format_error, "format specifier requires numeric argument");
} }
TEST(FormatterTest, SpaceSign) { TEST(FormatterTest, SpaceSign) {
@ -657,13 +657,13 @@ TEST(FormatterTest, SpaceSign) {
EXPECT_EQ("-42", format("{0: }", -42)); EXPECT_EQ("-42", format("{0: }", -42));
EXPECT_EQ(" 42", format("{0: }", 42)); EXPECT_EQ(" 42", format("{0: }", 42));
EXPECT_THROW_MSG(format("{0: }", 42u), EXPECT_THROW_MSG(format("{0: }", 42u),
format_error, "format specifier ' ' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ(" 42", format("{0: }", 42l)); EXPECT_EQ(" 42", format("{0: }", 42l));
EXPECT_THROW_MSG(format("{0: }", 42ul), EXPECT_THROW_MSG(format("{0: }", 42ul),
format_error, "format specifier ' ' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ(" 42", format("{0: }", 42ll)); EXPECT_EQ(" 42", format("{0: }", 42ll));
EXPECT_THROW_MSG(format("{0: }", 42ull), EXPECT_THROW_MSG(format("{0: }", 42ull),
format_error, "format specifier ' ' requires signed argument"); format_error, "format specifier requires signed argument");
EXPECT_EQ(" 42", format("{0: }", 42.0)); EXPECT_EQ(" 42", format("{0: }", 42.0));
EXPECT_EQ(" 42", format("{0: }", 42.0l)); EXPECT_EQ(" 42", format("{0: }", 42.0l));
EXPECT_THROW_MSG(format("{0: ", 'c'), EXPECT_THROW_MSG(format("{0: ", 'c'),
@ -671,9 +671,9 @@ TEST(FormatterTest, SpaceSign) {
EXPECT_THROW_MSG(format("{0: }", 'c'), EXPECT_THROW_MSG(format("{0: }", 'c'),
format_error, "invalid format specifier for char"); format_error, "invalid format specifier for char");
EXPECT_THROW_MSG(format("{0: }", "abc"), EXPECT_THROW_MSG(format("{0: }", "abc"),
format_error, "format specifier ' ' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)), EXPECT_THROW_MSG(format("{0: }", reinterpret_cast<void*>(0x42)),
format_error, "format specifier ' ' requires numeric argument"); format_error, "format specifier requires numeric argument");
} }
TEST(FormatterTest, HashFlag) { TEST(FormatterTest, HashFlag) {
@ -716,9 +716,9 @@ TEST(FormatterTest, HashFlag) {
EXPECT_THROW_MSG(format("{0:#}", 'c'), EXPECT_THROW_MSG(format("{0:#}", 'c'),
format_error, "invalid format specifier for char"); format_error, "invalid format specifier for char");
EXPECT_THROW_MSG(format("{0:#}", "abc"), EXPECT_THROW_MSG(format("{0:#}", "abc"),
format_error, "format specifier '#' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)), EXPECT_THROW_MSG(format("{0:#}", reinterpret_cast<void*>(0x42)),
format_error, "format specifier '#' requires numeric argument"); format_error, "format specifier requires numeric argument");
} }
TEST(FormatterTest, ZeroFlag) { TEST(FormatterTest, ZeroFlag) {
@ -736,9 +736,9 @@ TEST(FormatterTest, ZeroFlag) {
EXPECT_THROW_MSG(format("{0:05}", 'c'), EXPECT_THROW_MSG(format("{0:05}", 'c'),
format_error, "invalid format specifier for char"); format_error, "invalid format specifier for char");
EXPECT_THROW_MSG(format("{0:05}", "abc"), EXPECT_THROW_MSG(format("{0:05}", "abc"),
format_error, "format specifier '0' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)), EXPECT_THROW_MSG(format("{0:05}", reinterpret_cast<void*>(0x42)),
format_error, "format specifier '0' requires numeric argument"); format_error, "format specifier requires numeric argument");
} }
TEST(FormatterTest, Width) { TEST(FormatterTest, Width) {
@ -1566,17 +1566,17 @@ TEST(FormatTest, DynamicFormatter) {
EXPECT_THROW_MSG(format("{:{0}}", num), EXPECT_THROW_MSG(format("{:{0}}", num),
format_error, "cannot switch from automatic to manual argument indexing"); format_error, "cannot switch from automatic to manual argument indexing");
EXPECT_THROW_MSG(format("{:=}", str), EXPECT_THROW_MSG(format("{:=}", str),
format_error, "format specifier '=' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{:+}", str), EXPECT_THROW_MSG(format("{:+}", str),
format_error, "format specifier '+' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{:-}", str), EXPECT_THROW_MSG(format("{:-}", str),
format_error, "format specifier '-' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{: }", str), EXPECT_THROW_MSG(format("{: }", str),
format_error, "format specifier ' ' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{:#}", str), EXPECT_THROW_MSG(format("{:#}", str),
format_error, "format specifier '#' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{:0}", str), EXPECT_THROW_MSG(format("{:0}", str),
format_error, "format specifier '=' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{:.2}", num), EXPECT_THROW_MSG(format("{:.2}", num),
format_error, "precision not allowed for this argument type"); format_error, "precision not allowed for this argument type");
} }
@ -1705,6 +1705,8 @@ struct test_context {
constexpr unsigned next_arg_index(const char *&) { return 33; } constexpr unsigned next_arg_index(const char *&) { return 33; }
void on_error(const char *) {} void on_error(const char *) {}
constexpr test_context error_handler() { return *this; }
}; };
constexpr fmt::format_specs parse_specs(const char *s) { constexpr fmt::format_specs parse_specs(const char *s) {
@ -1872,15 +1874,33 @@ TEST(FormatTest, FormatStringErrors) {
EXPECT_ERROR("{:{<}", "invalid fill character '{'", int); EXPECT_ERROR("{:{<}", "invalid fill character '{'", int);
EXPECT_ERROR("{:10000000000}", "number is too big", int); EXPECT_ERROR("{:10000000000}", "number is too big", int);
EXPECT_ERROR("{:.10000000000}", "number is too big", int); EXPECT_ERROR("{:.10000000000}", "number is too big", int);
EXPECT_ERROR("{:x}", "argument index out of range");
EXPECT_ERROR("{:=}", "format specifier requires numeric argument",
const char *);
#endif #endif
EXPECT_ERROR("{foo", "missing '}' in format string", int); EXPECT_ERROR("{foo", "missing '}' in format string", int);
EXPECT_ERROR("{10000000000}", "number is too big"); EXPECT_ERROR("{10000000000}", "number is too big");
EXPECT_ERROR("{0x}", "invalid format string"); EXPECT_ERROR("{0x}", "invalid format string");
EXPECT_ERROR("{-}", "invalid format string"); EXPECT_ERROR("{-}", "invalid format string");
EXPECT_ERROR("{1}", "argument index out of range", int);
EXPECT_ERROR("{:{0x}}", "invalid format string", int); EXPECT_ERROR("{:{0x}}", "invalid format string", int);
EXPECT_ERROR("{:{-}}", "invalid format string", int); EXPECT_ERROR("{:{-}}", "invalid format string", int);
EXPECT_ERROR("{:.{0x}}", "invalid format string", int); EXPECT_ERROR("{:.{0x}}", "invalid format string", int);
EXPECT_ERROR("{:.{-}}", "invalid format string", int); EXPECT_ERROR("{:.{-}}", "invalid format string", int);
EXPECT_ERROR("{:.x}", "missing precision specifier", int); EXPECT_ERROR("{:.x}", "missing precision specifier", int);
EXPECT_ERROR("{}", "argument index out of range");
EXPECT_ERROR("{1}", "argument index out of range", int);
EXPECT_ERROR("{:+}", "format specifier requires numeric argument",
const char *);
EXPECT_ERROR("{:-}", "format specifier requires numeric argument",
const char *);
EXPECT_ERROR("{:#}", "format specifier requires numeric argument",
const char *);
EXPECT_ERROR("{: }", "format specifier requires numeric argument",
const char *);
EXPECT_ERROR("{:0}", "format specifier requires numeric argument",
const char *);
EXPECT_ERROR("{:+}", "format specifier requires signed argument", unsigned);
EXPECT_ERROR("{:-}", "format specifier requires signed argument", unsigned);
EXPECT_ERROR("{: }", "format specifier requires signed argument", unsigned);
EXPECT_ERROR("{:.2}", "precision not allowed for this argument type", int);
} }

12
test/ostream-test.cc
View File

@ -85,19 +85,19 @@ TEST(OStreamTest, FormatSpecs) {
EXPECT_EQ("def ", format("{0:<5}", TestString("def"))); EXPECT_EQ("def ", format("{0:<5}", TestString("def")));
EXPECT_EQ(" def", format("{0:>5}", TestString("def"))); EXPECT_EQ(" def", format("{0:>5}", TestString("def")));
EXPECT_THROW_MSG(format("{0:=5}", TestString("def")), EXPECT_THROW_MSG(format("{0:=5}", TestString("def")),
format_error, "format specifier '=' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_EQ(" def ", format("{0:^5}", TestString("def"))); EXPECT_EQ(" def ", format("{0:^5}", TestString("def")));
EXPECT_EQ("def**", format("{0:*<5}", TestString("def"))); EXPECT_EQ("def**", format("{0:*<5}", TestString("def")));
EXPECT_THROW_MSG(format("{0:+}", TestString()), EXPECT_THROW_MSG(format("{0:+}", TestString()),
format_error, "format specifier '+' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:-}", TestString()), EXPECT_THROW_MSG(format("{0:-}", TestString()),
format_error, "format specifier '-' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0: }", TestString()), EXPECT_THROW_MSG(format("{0: }", TestString()),
format_error, "format specifier ' ' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:#}", TestString()), EXPECT_THROW_MSG(format("{0:#}", TestString()),
format_error, "format specifier '#' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_THROW_MSG(format("{0:05}", TestString()), EXPECT_THROW_MSG(format("{0:05}", TestString()),
format_error, "format specifier '0' requires numeric argument"); format_error, "format specifier requires numeric argument");
EXPECT_EQ("test ", format("{0:13}", TestString("test"))); EXPECT_EQ("test ", format("{0:13}", TestString("test")));
EXPECT_EQ("test ", format("{0:{1}}", TestString("test"), 13)); EXPECT_EQ("test ", format("{0:{1}}", TestString("test"), 13));
EXPECT_EQ("te", format("{0:.2}", TestString("test"))); EXPECT_EQ("te", format("{0:.2}", TestString("test")));