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

More fixes for https://github.com/cppformat/cppformat/issues/50.

Browse Source
This commit is contained in:
Victor Zverovich 2014-07-27 15:09:05 -07:00
parent 5d4803a567
commit 75b5eb4b9d
8 changed files with 35 additions and 35 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
format.cc
View File

@ -211,13 +211,13 @@ inline Arg::StringValue<wchar_t> ignore_incompatible_str(
Arg::StringValue<wchar_t> s) { return s; } Arg::StringValue<wchar_t> s) { return s; }
} // namespace } // namespace
int fmt::internal::SignBitNoInline(double value) { return SignBit(value); } int fmt::internal::signbit_noinline(double value) { return SignBit(value); }
void fmt::SystemError::init( void fmt::SystemError::init(
int error_code, StringRef format_str, const ArgList &args) { int error_code, StringRef format_str, const ArgList &args) {
error_code_ = error_code; error_code_ = error_code;
Writer w; Writer w;
internal::FormatSystemErrorMessage(w, error_code, format(format_str, args)); internal::format_system_error(w, error_code, format(format_str, args));
std::runtime_error &base = *this; std::runtime_error &base = *this;
base = std::runtime_error(w.str()); base = std::runtime_error(w.str());
} }
@ -326,7 +326,7 @@ void fmt::WindowsError::init(
int error_code, StringRef format_str, const ArgList &args) { int error_code, StringRef format_str, const ArgList &args) {
error_code_ = error_code; error_code_ = error_code;
Writer w; Writer w;
internal::FormatWinErrorMessage(w, error_code, format(format_str, args)); internal::format_windows_error(w, error_code, format(format_str, args));
std::runtime_error &base = *this; std::runtime_error &base = *this;
base = std::runtime_error(w.str()); base = std::runtime_error(w.str());
} }
@ -361,7 +361,7 @@ int fmt::internal::safe_strerror(
return result; return result;
} }
void fmt::internal::FormatSystemErrorMessage( void fmt::internal::format_system_error(
fmt::Writer &out, int error_code, fmt::StringRef message) { fmt::Writer &out, int error_code, fmt::StringRef message) {
Array<char, INLINE_BUFFER_SIZE> buffer; Array<char, INLINE_BUFFER_SIZE> buffer;
buffer.resize(INLINE_BUFFER_SIZE); buffer.resize(INLINE_BUFFER_SIZE);
@ -382,7 +382,7 @@ void fmt::internal::FormatSystemErrorMessage(
} }
#ifdef _WIN32 #ifdef _WIN32
void fmt::internal::FormatWinErrorMessage( void fmt::internal::format_windows_error(
fmt::Writer &out, int error_code, fmt::StringRef message) { fmt::Writer &out, int error_code, fmt::StringRef message) {
class String { class String {
private: private:
@ -1123,15 +1123,15 @@ void fmt::BasicFormatter<Char>::Format(
void fmt::ReportSystemError( void fmt::ReportSystemError(
int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) { int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
// FIXME: FormatSystemErrorMessage may throw // FIXME: format_system_error may throw
ReportError(internal::FormatSystemErrorMessage, error_code, message); ReportError(internal::format_system_error, error_code, message);
} }
#ifdef _WIN32 #ifdef _WIN32
void fmt::ReportWinError( void fmt::ReportWinError(
int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) { int error_code, fmt::StringRef message) FMT_NOEXCEPT(true) {
// FIXME: FormatWinErrorMessage may throw // FIXME: format_windows_error may throw
ReportError(internal::FormatWinErrorMessage, error_code, message); ReportError(internal::format_windows_error, error_code, message);
} }
#endif #endif

6
format.h
View File

@ -410,7 +410,7 @@ inline bool is_negative(T value) {
return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value); return SignChecker<std::numeric_limits<T>::is_signed>::is_negative(value);
} }
int SignBitNoInline(double value); int signbit_noinline(double value);
template <typename T> template <typename T>
struct IntTraits { struct IntTraits {
@ -537,11 +537,11 @@ class UTF16ToUTF8 {
int safe_strerror(int error_code, int safe_strerror(int error_code,
char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT(true); char *&buffer, std::size_t buffer_size) FMT_NOEXCEPT(true);
void FormatSystemErrorMessage( void format_system_error(
fmt::Writer &out, int error_code, fmt::StringRef message); fmt::Writer &out, int error_code, fmt::StringRef message);
#ifdef _WIN32 #ifdef _WIN32
void FormatWinErrorMessage( void format_windows_error(
fmt::Writer &out, int error_code, fmt::StringRef message); fmt::Writer &out, int error_code, fmt::StringRef message);
#endif #endif

2
test/format-test.cc
View File

@ -1229,7 +1229,7 @@ TEST(FormatterTest, FormatNaN) {
double nan = std::numeric_limits<double>::quiet_NaN(); double nan = std::numeric_limits<double>::quiet_NaN();
EXPECT_EQ("nan", format("{}", nan)); EXPECT_EQ("nan", format("{}", nan));
EXPECT_EQ("+nan", format("{:+}", nan)); EXPECT_EQ("+nan", format("{:+}", nan));
if (fmt::internal::SignBitNoInline(-nan)) if (fmt::internal::signbit_noinline(-nan))
EXPECT_EQ("-nan", format("{}", -nan)); EXPECT_EQ("-nan", format("{}", -nan));
else else
fmt::print("Warning: compiler doesn't handle negative NaN correctly"); fmt::print("Warning: compiler doesn't handle negative NaN correctly");

16
test/gtest-extra-test.cc
View File

@ -308,8 +308,8 @@ TEST(ExpectTest, EXPECT_SYSTEM_ERROR) {
"ThrowSystemError() throws an exception with a different message.\n" "ThrowSystemError() throws an exception with a different message.\n"
"Expected: {}\n" "Expected: {}\n"
" Actual: {}", " Actual: {}",
FormatSystemErrorMessage(EDOM, "other"), format_system_error(EDOM, "other"),
FormatSystemErrorMessage(EDOM, "test"))); format_system_error(EDOM, "test")));
} }
// Tests EXPECT_WRITE. // Tests EXPECT_WRITE.
@ -347,10 +347,10 @@ TEST(StreamingAssertionsTest, EXPECT_WRITE) {
<< "expected failure", "expected failure"); << "expected failure", "expected failure");
} }
TEST(UtilTest, FormatSystemErrorMessage) { TEST(UtilTest, FormatSystemError) {
fmt::Writer out; fmt::Writer out;
fmt::internal::FormatSystemErrorMessage(out, EDOM, "test message"); fmt::internal::format_system_error(out, EDOM, "test message");
EXPECT_EQ(out.str(), FormatSystemErrorMessage(EDOM, "test message")); EXPECT_EQ(out.str(), format_system_error(EDOM, "test message"));
} }
#if FMT_USE_FILE_DESCRIPTORS #if FMT_USE_FILE_DESCRIPTORS
@ -500,7 +500,7 @@ TEST(BufferedFileTest, CloseErrorInDtor) {
// redirection. // redirection.
FMT_POSIX(close(f->fileno())); FMT_POSIX(close(f->fileno()));
SUPPRESS_ASSERT(delete f); SUPPRESS_ASSERT(delete f);
}, FormatSystemErrorMessage(EBADF, "cannot close file") + "\n"); }, format_system_error(EBADF, "cannot close file") + "\n");
} }
TEST(BufferedFileTest, Close) { TEST(BufferedFileTest, Close) {
@ -624,7 +624,7 @@ TEST(FileTest, CloseErrorInDtor) {
// redirection. // redirection.
FMT_POSIX(close(f->descriptor())); FMT_POSIX(close(f->descriptor()));
SUPPRESS_ASSERT(delete f); SUPPRESS_ASSERT(delete f);
}, FormatSystemErrorMessage(EBADF, "cannot close file") + "\n"); }, format_system_error(EBADF, "cannot close file") + "\n");
} }
TEST(FileTest, Close) { TEST(FileTest, Close) {
@ -825,7 +825,7 @@ TEST(OutputRedirectTest, ErrorInDtor) {
// redirection. // redirection.
FMT_POSIX(close(write_fd)); FMT_POSIX(close(write_fd));
SUPPRESS_ASSERT(delete redir); SUPPRESS_ASSERT(delete redir);
}, FormatSystemErrorMessage(EBADF, "cannot flush stream")); }, format_system_error(EBADF, "cannot flush stream"));
write_copy.dup2(write_fd); // "undo" close or dtor of BufferedFile will fail write_copy.dup2(write_fd); // "undo" close or dtor of BufferedFile will fail
} }

4
test/gtest-extra.cc
View File

@ -91,8 +91,8 @@ std::string OutputRedirect::RestoreAndRead() {
#endif // FMT_USE_FILE_DESCRIPTORS #endif // FMT_USE_FILE_DESCRIPTORS
std::string FormatSystemErrorMessage(int error_code, fmt::StringRef message) { std::string format_system_error(int error_code, fmt::StringRef message) {
fmt::Writer out; fmt::Writer out;
fmt::internal::FormatSystemErrorMessage(out, error_code, message); fmt::internal::format_system_error(out, error_code, message);
return out.str(); return out.str();
} }

4
test/gtest-extra.h
View File

@ -81,11 +81,11 @@
FMT_TEST_THROW_(statement, expected_exception, \ FMT_TEST_THROW_(statement, expected_exception, \
expected_message, GTEST_NONFATAL_FAILURE_) expected_message, GTEST_NONFATAL_FAILURE_)
std::string FormatSystemErrorMessage(int error_code, fmt::StringRef message); std::string format_system_error(int error_code, fmt::StringRef message);
#define EXPECT_SYSTEM_ERROR(statement, error_code, message) \ #define EXPECT_SYSTEM_ERROR(statement, error_code, message) \
EXPECT_THROW_MSG(statement, fmt::SystemError, \ EXPECT_THROW_MSG(statement, fmt::SystemError, \
FormatSystemErrorMessage(error_code, message)) format_system_error(error_code, message))
#if FMT_USE_FILE_DESCRIPTORS #if FMT_USE_FILE_DESCRIPTORS

4
test/posix-test.cc
View File

@ -169,7 +169,7 @@ TEST(FileTest, CloseNoRetryInDtor) {
delete f; delete f;
saved_close_count = close_count; saved_close_count = close_count;
close_count = 0; close_count = 0;
}, FormatSystemErrorMessage(EINTR, "cannot close file") + "\n"); }, format_system_error(EINTR, "cannot close file") + "\n");
EXPECT_EQ(2, saved_close_count); EXPECT_EQ(2, saved_close_count);
} }
@ -299,7 +299,7 @@ TEST(BufferedFileTest, CloseNoRetryInDtor) {
delete f; delete f;
saved_fclose_count = fclose_count; saved_fclose_count = fclose_count;
fclose_count = 0; fclose_count = 0;
}, FormatSystemErrorMessage(EINTR, "cannot close file") + "\n"); }, format_system_error(EINTR, "cannot close file") + "\n");
EXPECT_EQ(2, saved_fclose_count); EXPECT_EQ(2, saved_fclose_count);
} }

16
test/util-test.cc
View File

@ -387,7 +387,7 @@ TEST(UtilTest, UTF8ToUTF16) {
template <typename Converter> template <typename Converter>
void CheckUTFConversionError(const char *message) { void CheckUTFConversionError(const char *message) {
fmt::Writer out; fmt::Writer out;
fmt::internal::FormatWinErrorMessage(out, ERROR_INVALID_PARAMETER, message); fmt::internal::format_windows_error(out, ERROR_INVALID_PARAMETER, message);
fmt::SystemError error(0, ""); fmt::SystemError error(0, "");
try { try {
Converter(0); Converter(0);
@ -471,20 +471,20 @@ void CheckThrowError(int error_code, FormatErrorMessage format) {
EXPECT_EQ(error_code, error.error_code()); EXPECT_EQ(error_code, error.error_code());
} }
TEST(UtilTest, FormatSystemErrorMessage) { TEST(UtilTest, FormatSystemError) {
fmt::Writer message; fmt::Writer message;
fmt::internal::FormatSystemErrorMessage(message, EDOM, "test"); fmt::internal::format_system_error(message, EDOM, "test");
EXPECT_EQ(fmt::format("test: {}", EXPECT_EQ(fmt::format("test: {}",
GetSystemErrorMessage(EDOM)), message.str()); GetSystemErrorMessage(EDOM)), message.str());
} }
TEST(UtilTest, ThrowSystemError) { TEST(UtilTest, ThrowSystemError) {
CheckThrowError<fmt::SystemError>(EDOM, fmt::internal::FormatSystemErrorMessage); CheckThrowError<fmt::SystemError>(EDOM, fmt::internal::format_system_error);
} }
TEST(UtilTest, ReportSystemError) { TEST(UtilTest, ReportSystemError) {
fmt::Writer out; fmt::Writer out;
fmt::internal::FormatSystemErrorMessage(out, EDOM, "test error"); fmt::internal::format_system_error(out, EDOM, "test error");
out << '\n'; out << '\n';
EXPECT_WRITE(stderr, fmt::ReportSystemError(EDOM, "test error"), out.str()); EXPECT_WRITE(stderr, fmt::ReportSystemError(EDOM, "test error"), out.str());
} }
@ -500,7 +500,7 @@ TEST(UtilTest, FormatWinErrorMessage) {
fmt::internal::UTF16ToUTF8 utf8_message(message); fmt::internal::UTF16ToUTF8 utf8_message(message);
LocalFree(message); LocalFree(message);
fmt::Writer actual_message; fmt::Writer actual_message;
fmt::internal::FormatWinErrorMessage( fmt::internal::format_windows_error(
actual_message, ERROR_FILE_EXISTS, "test"); actual_message, ERROR_FILE_EXISTS, "test");
EXPECT_EQ(fmt::format("test: {}", utf8_message.str()), EXPECT_EQ(fmt::format("test: {}", utf8_message.str()),
actual_message.str()); actual_message.str());
@ -508,12 +508,12 @@ TEST(UtilTest, FormatWinErrorMessage) {
TEST(UtilTest, ThrowWinError) { TEST(UtilTest, ThrowWinError) {
CheckThrowError<fmt::WindowsError>( CheckThrowError<fmt::WindowsError>(
ERROR_FILE_EXISTS, fmt::internal::FormatWinErrorMessage); ERROR_FILE_EXISTS, fmt::internal::format_windows_error);
} }
TEST(UtilTest, ReportWinError) { TEST(UtilTest, ReportWinError) {
fmt::Writer out; fmt::Writer out;
fmt::internal::FormatWinErrorMessage(out, ERROR_FILE_EXISTS, "test error"); fmt::internal::format_windows_error(out, ERROR_FILE_EXISTS, "test error");
out << '\n'; out << '\n';
EXPECT_WRITE(stderr, EXPECT_WRITE(stderr,
fmt::ReportWinError(ERROR_FILE_EXISTS, "test error"), out.str()); fmt::ReportWinError(ERROR_FILE_EXISTS, "test error"), out.str());