From 5370443ece4b7a42282a4e780921818af3e18daa Mon Sep 17 00:00:00 2001 From: gabime Date: Mon, 10 Feb 2020 17:13:41 +0200 Subject: [PATCH] clang-format --- include/spdlog/details/os-inl.h | 2 +- include/spdlog/logger.h | 2 +- include/spdlog/sinks/daily_file_sink.h | 3 +- include/spdlog/sinks/win_eventlog_sink.h | 108 ++++----- src/fmt.cpp | 265 ++++++++++++----------- tests/test_eventlog.cpp | 28 +-- tests/test_file_logging.cpp | 7 +- tests/utils.cpp | 7 +- 8 files changed, 211 insertions(+), 211 deletions(-) diff --git a/include/spdlog/details/os-inl.h b/include/spdlog/details/os-inl.h index ccc53ff2..e83c2ce4 100644 --- a/include/spdlog/details/os-inl.h +++ b/include/spdlog/details/os-inl.h @@ -150,7 +150,7 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename #if defined(SPDLOG_PREVENT_CHILD_FD) const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; const int fd = ::open((filename.c_str()), O_CREAT | O_WRONLY | O_CLOEXEC | mode_flag, mode_t(0644)); - if(fd == -1) + if (fd == -1) { return false; } diff --git a/include/spdlog/logger.h b/include/spdlog/logger.h index ed7d2361..b78d8544 100644 --- a/include/spdlog/logger.h +++ b/include/spdlog/logger.h @@ -144,7 +144,7 @@ public: template::value, T>::type * = nullptr> void log(source_loc loc, level::level_enum lvl, const T &msg) { - log(loc,lvl, string_view_t{msg}); + log(loc, lvl, string_view_t{msg}); } void log(source_loc loc, level::level_enum lvl, string_view_t msg) diff --git a/include/spdlog/sinks/daily_file_sink.h b/include/spdlog/sinks/daily_file_sink.h index f796f831..e122f10f 100644 --- a/include/spdlog/sinks/daily_file_sink.h +++ b/include/spdlog/sinks/daily_file_sink.h @@ -120,7 +120,8 @@ private: filenames.emplace_back(filename); now -= std::chrono::hours(24); } - for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) { + for (auto iter = filenames.rbegin(); iter != filenames.rend(); ++iter) + { filenames_q_.push_back(std::move(*iter)); } } diff --git a/include/spdlog/sinks/win_eventlog_sink.h b/include/spdlog/sinks/win_eventlog_sink.h index 51bfca9f..b594e0c9 100644 --- a/include/spdlog/sinks/win_eventlog_sink.h +++ b/include/spdlog/sinks/win_eventlog_sink.h @@ -5,12 +5,12 @@ // 1. should be replaced with your log name (e.g. your application name) // 2. should be replaced with the specific source name and the key should be duplicated for // each source used in the application -// +// // Since typically modifications of this kind require elevation, it's better to do it as a part of setup procedure. -// The snippet below uses mscoree.dll as the message file as it exists on most of the Windows systems anyway and +// The snippet below uses mscoree.dll as the message file as it exists on most of the Windows systems anyway and // happens to contain the needed resource. -// -// You can also specify a custom message file if needed. +// +// You can also specify a custom message file if needed. // Please refer to Event Log functions descriptions in MSDN for more details on custom message files. /*--------------------------------------------------------------------------------------- @@ -44,21 +44,20 @@ namespace sinks { namespace win_eventlog { -namespace internal -{ +namespace internal { /** Windows error */ struct win32_error : public spdlog_ex { /** Formats an error report line: "user-message: error-code (system message)" */ - static std::string format(std::string const& user_message, DWORD error_code = GetLastError()) + static std::string format(std::string const &user_message, DWORD error_code = GetLastError()) { std::string system_message; - LPSTR format_message_result {}; - auto format_message_succeeded = ::FormatMessage( - FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, - error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR) &format_message_result, 0, nullptr); + LPSTR format_message_result{}; + auto format_message_succeeded = + ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, + error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result, 0, nullptr); if (format_message_succeeded && format_message_result) { @@ -73,7 +72,7 @@ struct win32_error : public spdlog_ex return fmt::format("{}: {}{}", user_message, error_code, system_message); } - win32_error(std::string const& func_name, DWORD error = GetLastError()) + win32_error(std::string const &func_name, DWORD error = GetLastError()) : spdlog_ex(format(func_name, error)) {} }; @@ -84,8 +83,7 @@ struct sid_t std::vector buffer_; public: - sid_t() - {} + sid_t() {} /** creates a wrapped SID copy */ static sid_t duplicate_sid(PSID psid) @@ -95,7 +93,7 @@ public: SPDLOG_THROW(spdlog_ex("sid_t::sid_t(): invalid SID received")); } - auto const sid_length {::GetLengthSid(psid)}; + auto const sid_length{::GetLengthSid(psid)}; sid_t result; result.buffer_.resize(sid_length); @@ -108,9 +106,9 @@ public: } /** Retrieves pointer to the internal buffer contents as SID* */ - SID * as_sid() const + SID *as_sid() const { - return buffer_.empty() ? nullptr : (SID *) buffer_.data(); + return buffer_.empty() ? nullptr : (SID *)buffer_.data(); } /** Get SID for the current user */ @@ -119,11 +117,11 @@ public: /* create and init RAII holder for process token */ struct process_token_t { - HANDLE token_handle_= INVALID_HANDLE_VALUE; - explicit process_token_t(HANDLE process) + HANDLE token_handle_ = INVALID_HANDLE_VALUE; + explicit process_token_t(HANDLE process) { if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) - { + { SPDLOG_THROW(win32_error("OpenProcessToken")); } } @@ -137,7 +135,7 @@ public: // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return the token size DWORD tusize = 0; - if(::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize)) + if (::GetTokenInformation(current_process_token.token_handle_, TokenUser, NULL, 0, &tusize)) { SPDLOG_THROW(win32_error("GetTokenInformation should fail")); } @@ -150,57 +148,56 @@ public: } // create a wrapper of the SID data as stored in the user token - return sid_t::duplicate_sid(((TOKEN_USER*) buffer.data())->User.Sid); + return sid_t::duplicate_sid(((TOKEN_USER *)buffer.data())->User.Sid); } }; struct eventlog { - static WORD get_event_type(details::log_msg const& msg) + static WORD get_event_type(details::log_msg const &msg) { switch (msg.level) { - case level::trace: - case level::debug: - return EVENTLOG_SUCCESS; + case level::trace: + case level::debug: + return EVENTLOG_SUCCESS; - case level::info: - return EVENTLOG_INFORMATION_TYPE; + case level::info: + return EVENTLOG_INFORMATION_TYPE; - case level::warn: - return EVENTLOG_WARNING_TYPE; + case level::warn: + return EVENTLOG_WARNING_TYPE; - case level::err: - case level::critical: - case level::off: - return EVENTLOG_ERROR_TYPE; + case level::err: + case level::critical: + case level::off: + return EVENTLOG_ERROR_TYPE; - default: - // should be unreachable - SPDLOG_THROW(std::logic_error(fmt::format("Unsupported log level {}", msg.level))); + default: + // should be unreachable + SPDLOG_THROW(std::logic_error(fmt::format("Unsupported log level {}", msg.level))); } } - static WORD get_event_category(details::log_msg const& msg) + static WORD get_event_category(details::log_msg const &msg) { - return (WORD) msg.level; + return (WORD)msg.level; } }; } // namespace internal - /* * Windows Event Log sink */ -template +template class win_eventlog_sink : public base_sink { private: - HANDLE hEventLog_ {NULL}; + HANDLE hEventLog_{NULL}; internal::sid_t current_user_sid_; - std::string source_; - WORD event_id_; + std::string source_; + WORD event_id_; HANDLE event_log_handle() { @@ -225,17 +222,9 @@ protected: formatter_->format(msg, formatted); formatted.push_back('\0'); LPCSTR lp_str = static_cast(formatted.data()); - - auto succeeded = ::ReportEvent( - event_log_handle(), - eventlog::get_event_type(msg), - eventlog::get_event_category(msg), - event_id_, - current_user_sid_.as_sid(), - 1, - 0, - &lp_str, - nullptr); + + auto succeeded = ::ReportEvent(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_, + current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr); if (!succeeded) { @@ -246,9 +235,9 @@ protected: void flush_() override {} public: - win_eventlog_sink(std::string const& source, WORD event_id = 1000 /* according to mscoree.dll */) + win_eventlog_sink(std::string const &source, WORD event_id = 1000 /* according to mscoree.dll */) : source_(source) - , event_id_ (event_id) + , event_id_(event_id) { try { @@ -256,8 +245,8 @@ public: } catch (...) { - // get_current_user_sid() is unlikely to fail and if it does, we can still proceed without - // current_user_sid but in the event log the record will have no user name + // get_current_user_sid() is unlikely to fail and if it does, we can still proceed without + // current_user_sid but in the event log the record will have no user name } } @@ -275,4 +264,3 @@ using win_eventlog_sink_st = win_eventlog::win_eventlog_sink - int format_float(char* buf, std::size_t size, const char* format, int precision, - T value) { +template +int format_float(char *buf, std::size_t size, const char *format, int precision, T value) +{ #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION - if (precision > 100000) - throw std::runtime_error( - "fuzz mode - avoid large allocation inside snprintf"); + if (precision > 100000) + throw std::runtime_error("fuzz mode - avoid large allocation inside snprintf"); #endif - // Suppress the warning about nonliteral format string. - auto snprintf_ptr = FMT_SNPRINTF; - return precision < 0 ? snprintf_ptr(buf, size, format, value) - : snprintf_ptr(buf, size, format, precision, value); - } - struct sprintf_specs { - int precision; - char type; - bool alt : 1; + // Suppress the warning about nonliteral format string. + auto snprintf_ptr = FMT_SNPRINTF; + return precision < 0 ? snprintf_ptr(buf, size, format, value) : snprintf_ptr(buf, size, format, precision, value); +} +struct sprintf_specs +{ + int precision; + char type; + bool alt : 1; - template - constexpr sprintf_specs(basic_format_specs specs) - : precision(specs.precision), type(specs.type), alt(specs.alt) {} + template + constexpr sprintf_specs(basic_format_specs specs) + : precision(specs.precision) + , type(specs.type) + , alt(specs.alt) + {} - constexpr bool has_precision() const { return precision >= 0; } - }; + constexpr bool has_precision() const + { + return precision >= 0; + } +}; // This is deprecated and is kept only to preserve ABI compatibility. - template - char* sprintf_format(Double value, internal::buffer& buf, - sprintf_specs specs) { - // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. - FMT_ASSERT(buf.capacity() != 0, "empty buffer"); +template +char *sprintf_format(Double value, internal::buffer &buf, sprintf_specs specs) +{ + // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. + FMT_ASSERT(buf.capacity() != 0, "empty buffer"); - // Build format string. - enum { max_format_size = 10 }; // longest format: %#-*.*Lg - char format[max_format_size]; - char* format_ptr = format; - *format_ptr++ = '%'; - if (specs.alt || !specs.type) *format_ptr++ = '#'; - if (specs.precision >= 0) { - *format_ptr++ = '.'; - *format_ptr++ = '*'; - } - if (std::is_same::value) *format_ptr++ = 'L'; + // Build format string. + enum + { + max_format_size = 10 + }; // longest format: %#-*.*Lg + char format[max_format_size]; + char *format_ptr = format; + *format_ptr++ = '%'; + if (specs.alt || !specs.type) + *format_ptr++ = '#'; + if (specs.precision >= 0) + { + *format_ptr++ = '.'; + *format_ptr++ = '*'; + } + if (std::is_same::value) + *format_ptr++ = 'L'; - char type = specs.type; + char type = specs.type; - if (type == '%') - type = 'f'; - else if (type == 0 || type == 'n') - type = 'g'; + if (type == '%') + type = 'f'; + else if (type == 0 || type == 'n') + type = 'g'; #if FMT_MSC_VER - if (type == 'F') { - // MSVC's printf doesn't support 'F'. - type = 'f'; - } + if (type == 'F') + { + // MSVC's printf doesn't support 'F'. + type = 'f'; + } #endif - *format_ptr++ = type; - *format_ptr = '\0'; + *format_ptr++ = type; + *format_ptr = '\0'; - // Format using snprintf. - char* start = nullptr; - char* decimal_point_pos = nullptr; - for (;;) { - std::size_t buffer_size = buf.capacity(); - start = &buf[0]; - int result = - format_float(start, buffer_size, format, specs.precision, value); - if (result >= 0) { - unsigned n = internal::to_unsigned(result); - if (n < buf.capacity()) { - // Find the decimal point. - auto p = buf.data(), end = p + n; - if (*p == '+' || *p == '-') ++p; - if (specs.type != 'a' && specs.type != 'A') { - while (p < end && *p >= '0' && *p <= '9') ++p; - if (p < end && *p != 'e' && *p != 'E') { - decimal_point_pos = p; - if (!specs.type) { - // Keep only one trailing zero after the decimal point. - ++p; - if (*p == '0') ++p; - while (p != end && *p >= '1' && *p <= '9') ++p; - char* where = p; - while (p != end && *p == '0') ++p; - if (p == end || *p < '0' || *p > '9') { - if (p != end) std::memmove(where, p, to_unsigned(end - p)); - n -= static_cast(p - where); - } - } - } + // Format using snprintf. + char *start = nullptr; + char *decimal_point_pos = nullptr; + for (;;) + { + std::size_t buffer_size = buf.capacity(); + start = &buf[0]; + int result = format_float(start, buffer_size, format, specs.precision, value); + if (result >= 0) + { + unsigned n = internal::to_unsigned(result); + if (n < buf.capacity()) + { + // Find the decimal point. + auto p = buf.data(), end = p + n; + if (*p == '+' || *p == '-') + ++p; + if (specs.type != 'a' && specs.type != 'A') + { + while (p < end && *p >= '0' && *p <= '9') + ++p; + if (p < end && *p != 'e' && *p != 'E') + { + decimal_point_pos = p; + if (!specs.type) + { + // Keep only one trailing zero after the decimal point. + ++p; + if (*p == '0') + ++p; + while (p != end && *p >= '1' && *p <= '9') + ++p; + char *where = p; + while (p != end && *p == '0') + ++p; + if (p == end || *p < '0' || *p > '9') + { + if (p != end) + std::memmove(where, p, to_unsigned(end - p)); + n -= static_cast(p - where); } - buf.resize(n); - break; // The buffer is large enough - continue with formatting. } - buf.reserve(n + 1); - } else { - // If result is negative we ask to increase the capacity by at least 1, - // but as std::vector, the buffer grows exponentially. - buf.reserve(buf.capacity() + 1); } } - return decimal_point_pos; + buf.resize(n); + break; // The buffer is large enough - continue with formatting. } - } // namespace internal + buf.reserve(n + 1); + } + else + { + // If result is negative we ask to increase the capacity by at least 1, + // but as std::vector, the buffer grows exponentially. + buf.reserve(buf.capacity() + 1); + } + } + return decimal_point_pos; +} +} // namespace internal - template FMT_API char* internal::sprintf_format(double, internal::buffer&, - sprintf_specs); - template FMT_API char* internal::sprintf_format(long double, - internal::buffer&, - sprintf_specs); +template FMT_API char *internal::sprintf_format(double, internal::buffer &, sprintf_specs); +template FMT_API char *internal::sprintf_format(long double, internal::buffer &, sprintf_specs); - template struct FMT_API internal::basic_data; +template struct FMT_API internal::basic_data; // Workaround a bug in MSVC2013 that prevents instantiation of format_float. - int (*instantiate_format_float)(double, int, internal::float_specs, - internal::buffer&) = - internal::format_float; +int (*instantiate_format_float)(double, int, internal::float_specs, internal::buffer &) = internal::format_float; #ifndef FMT_STATIC_THOUSANDS_SEPARATOR - template FMT_API internal::locale_ref::locale_ref(const std::locale& loc); - template FMT_API std::locale internal::locale_ref::get() const; +template FMT_API internal::locale_ref::locale_ref(const std::locale &loc); +template FMT_API std::locale internal::locale_ref::get() const; #endif // Explicit instantiations for char. - template FMT_API std::string internal::grouping_impl(locale_ref); - template FMT_API char internal::thousands_sep_impl(locale_ref); - template FMT_API char internal::decimal_point_impl(locale_ref); +template FMT_API std::string internal::grouping_impl(locale_ref); +template FMT_API char internal::thousands_sep_impl(locale_ref); +template FMT_API char internal::decimal_point_impl(locale_ref); - template FMT_API void internal::buffer::append(const char*, const char*); +template FMT_API void internal::buffer::append(const char *, const char *); - template FMT_API void internal::arg_map::init( - const basic_format_args& args); +template FMT_API void internal::arg_map::init(const basic_format_args &args); - template FMT_API std::string internal::vformat( - string_view, basic_format_args); +template FMT_API std::string internal::vformat(string_view, basic_format_args); - template FMT_API format_context::iterator internal::vformat_to( - internal::buffer&, string_view, basic_format_args); +template FMT_API format_context::iterator internal::vformat_to(internal::buffer &, string_view, basic_format_args); - template FMT_API int internal::snprintf_float(double, int, - internal::float_specs, - internal::buffer&); - template FMT_API int internal::snprintf_float(long double, int, - internal::float_specs, - internal::buffer&); - template FMT_API int internal::format_float(double, int, internal::float_specs, - internal::buffer&); - template FMT_API int internal::format_float(long double, int, - internal::float_specs, - internal::buffer&); +template FMT_API int internal::snprintf_float(double, int, internal::float_specs, internal::buffer &); +template FMT_API int internal::snprintf_float(long double, int, internal::float_specs, internal::buffer &); +template FMT_API int internal::format_float(double, int, internal::float_specs, internal::buffer &); +template FMT_API int internal::format_float(long double, int, internal::float_specs, internal::buffer &); // Explicit instantiations for wchar_t. - template FMT_API std::string internal::grouping_impl(locale_ref); - template FMT_API wchar_t internal::thousands_sep_impl(locale_ref); - template FMT_API wchar_t internal::decimal_point_impl(locale_ref); +template FMT_API std::string internal::grouping_impl(locale_ref); +template FMT_API wchar_t internal::thousands_sep_impl(locale_ref); +template FMT_API wchar_t internal::decimal_point_impl(locale_ref); - template FMT_API void internal::buffer::append(const wchar_t*, - const wchar_t*); +template FMT_API void internal::buffer::append(const wchar_t *, const wchar_t *); - template FMT_API std::wstring internal::vformat( - wstring_view, basic_format_args); +template FMT_API std::wstring internal::vformat(wstring_view, basic_format_args); FMT_END_NAMESPACE - #endif diff --git a/tests/test_eventlog.cpp b/tests/test_eventlog.cpp index 114f2cb7..6aca3a9e 100644 --- a/tests/test_eventlog.cpp +++ b/tests/test_eventlog.cpp @@ -7,7 +7,7 @@ static const LPCSTR TEST_SOURCE = "spdlog_test"; -static void test_single_print(std::function do_log, std::string const& expected_contents, WORD expected_ev_type) +static void test_single_print(std::function do_log, std::string const &expected_contents, WORD expected_ev_type) { using namespace std::chrono; do_log(expected_contents); @@ -24,26 +24,28 @@ static void test_single_print(std::function do_log, st REQUIRE(CloseEventLog(handle_)); } } - } event_log {::OpenEventLog(nullptr, TEST_SOURCE)}; + } event_log{::OpenEventLog(nullptr, TEST_SOURCE)}; REQUIRE(event_log.handle_); - DWORD read_bytes {}, size_needed{}; - auto ok = ::ReadEventLog(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, &read_bytes, 0, &read_bytes, &size_needed); - REQUIRE(!ok); + DWORD read_bytes{}, size_needed{}; + auto ok = + ::ReadEventLog(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, &read_bytes, 0, &read_bytes, &size_needed); + REQUIRE(!ok); REQUIRE(::GetLastError() == ERROR_INSUFFICIENT_BUFFER); std::vector record_buffer(size_needed); PEVENTLOGRECORD record = (PEVENTLOGRECORD)record_buffer.data(); - ok = ::ReadEventLog(event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, record, size_needed, &read_bytes, &size_needed); + ok = ::ReadEventLog( + event_log.handle_, EVENTLOG_SEQUENTIAL_READ | EVENTLOG_BACKWARDS_READ, 0, record, size_needed, &read_bytes, &size_needed); REQUIRE(ok); REQUIRE(record->NumStrings == 1); REQUIRE(record->EventType == expected_ev_type); REQUIRE(record->TimeGenerated == expected_time_generated); - std::string message_in_log(((char*) record + record->StringOffset)); + std::string message_in_log(((char *)record + record->StringOffset)); REQUIRE(message_in_log == expected_contents + spdlog::details::os::default_eol); } @@ -58,12 +60,12 @@ TEST_CASE("eventlog", "[eventlog]") test_sink->set_pattern("%v"); - test_single_print([&test_logger] (std::string const& msg) { test_logger.trace(msg); }, "my trace message", EVENTLOG_SUCCESS); - test_single_print([&test_logger] (std::string const& msg) { test_logger.debug(msg); }, "my debug message", EVENTLOG_SUCCESS); - test_single_print([&test_logger] (std::string const& msg) { test_logger.info(msg); }, "my info message", EVENTLOG_INFORMATION_TYPE); - test_single_print([&test_logger] (std::string const& msg) { test_logger.warn(msg); }, "my warn message", EVENTLOG_WARNING_TYPE); - test_single_print([&test_logger] (std::string const& msg) { test_logger.error(msg); }, "my error message", EVENTLOG_ERROR_TYPE); - test_single_print([&test_logger] (std::string const& msg) { test_logger.critical(msg); }, "my critical message", EVENTLOG_ERROR_TYPE); + test_single_print([&test_logger](std::string const &msg) { test_logger.trace(msg); }, "my trace message", EVENTLOG_SUCCESS); + test_single_print([&test_logger](std::string const &msg) { test_logger.debug(msg); }, "my debug message", EVENTLOG_SUCCESS); + test_single_print([&test_logger](std::string const &msg) { test_logger.info(msg); }, "my info message", EVENTLOG_INFORMATION_TYPE); + test_single_print([&test_logger](std::string const &msg) { test_logger.warn(msg); }, "my warn message", EVENTLOG_WARNING_TYPE); + test_single_print([&test_logger](std::string const &msg) { test_logger.error(msg); }, "my error message", EVENTLOG_ERROR_TYPE); + test_single_print([&test_logger](std::string const &msg) { test_logger.critical(msg); }, "my critical message", EVENTLOG_ERROR_TYPE); } #endif //_WIN32 \ No newline at end of file diff --git a/tests/test_file_logging.cpp b/tests/test_file_logging.cpp index 0a1f3ffc..2c55ddba 100644 --- a/tests/test_file_logging.cpp +++ b/tests/test_file_logging.cpp @@ -17,8 +17,7 @@ TEST_CASE("simple_file_logger", "[simple_logger]]") logger->flush(); require_message_count(filename, 2); using spdlog::details::os::default_eol; - REQUIRE(file_contents(filename) == fmt::format("Test message 1{}Test message 2{}", - default_eol, default_eol)); + REQUIRE(file_contents(filename) == fmt::format("Test message 1{}Test message 2{}", default_eol, default_eol)); } TEST_CASE("flush_on", "[flush_on]]") @@ -38,8 +37,8 @@ TEST_CASE("flush_on", "[flush_on]]") require_message_count(filename, 3); using spdlog::details::os::default_eol; - REQUIRE(file_contents(filename) == fmt::format("Should not be flushed{}Test message 1{}Test message 2{}", - default_eol, default_eol, default_eol)); + REQUIRE(file_contents(filename) == + fmt::format("Should not be flushed{}Test message 1{}Test message 2{}", default_eol, default_eol, default_eol)); } TEST_CASE("rotating_file_logger1", "[rotating_logger]]") diff --git a/tests/utils.cpp b/tests/utils.cpp index 08c19c8a..7aeca2f8 100644 --- a/tests/utils.cpp +++ b/tests/utils.cpp @@ -46,9 +46,12 @@ std::size_t count_lines(const std::string &filename) void require_message_count(const std::string &filename, const std::size_t messages) { - if (strlen(spdlog::details::os::default_eol) == 0) { + if (strlen(spdlog::details::os::default_eol) == 0) + { REQUIRE(count_lines(filename) == 1); - } else { + } + else + { REQUIRE(count_lines(filename) == messages); } }