mirrors/spdlog
1
0
Fork 0
mirror of https://github.com/gabime/spdlog.git synced 2025-01-12 17:00:25 +08:00
Code Issues Actions 8 Packages Projects Releases Wiki Activity

clang-format

Browse Source
This commit is contained in:
gabime 2020-02-10 17:13:41 +02:00
parent ad4fb1cf84
commit 5370443ece
8 changed files with 211 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
include/spdlog/details/os-inl.h
View File

@ -150,7 +150,7 @@ SPDLOG_INLINE bool fopen_s(FILE **fp, const filename_t &filename, const filename
#if defined(SPDLOG_PREVENT_CHILD_FD) #if defined(SPDLOG_PREVENT_CHILD_FD)
const int mode_flag = mode == SPDLOG_FILENAME_T("ab") ? O_APPEND : O_TRUNC; 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)); 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; return false;
} }

2
include/spdlog/logger.h
View File

@ -144,7 +144,7 @@ public:
template<class T, typename std::enable_if<std::is_convertible<const T &, spdlog::string_view_t>::value, T>::type * = nullptr> template<class T, typename std::enable_if<std::is_convertible<const T &, spdlog::string_view_t>::value, T>::type * = nullptr>
void log(source_loc loc, level::level_enum lvl, const T &msg) 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) void log(source_loc loc, level::level_enum lvl, string_view_t msg)

3
include/spdlog/sinks/daily_file_sink.h
View File

@ -120,7 +120,8 @@ private:
filenames.emplace_back(filename); filenames.emplace_back(filename);
now -= std::chrono::hours(24); 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)); filenames_q_.push_back(std::move(*iter));
} }
} }

108
include/spdlog/sinks/win_eventlog_sink.h
View File

@ -5,12 +5,12 @@
// 1. <log_name> should be replaced with your log name (e.g. your application name) // 1. <log_name> should be replaced with your log name (e.g. your application name)
// 2. <source_name> should be replaced with the specific source name and the key should be duplicated for // 2. <source_name> should be replaced with the specific source name and the key should be duplicated for
// each source used in the application // 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. // 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. // 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. // 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 win_eventlog {
namespace internal namespace internal {
{
/** Windows error */ /** Windows error */
struct win32_error : public spdlog_ex struct win32_error : public spdlog_ex
{ {
/** Formats an error report line: "user-message: error-code (system message)" */ /** 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; std::string system_message;
LPSTR format_message_result {}; LPSTR format_message_result{};
auto format_message_succeeded = ::FormatMessage( auto format_message_succeeded =
FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, nullptr, ::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); error_code, MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), (LPSTR)&format_message_result, 0, nullptr);
if (format_message_succeeded && format_message_result) 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); 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)) : spdlog_ex(format(func_name, error))
{} {}
}; };
@ -84,8 +83,7 @@ struct sid_t
std::vector<char> buffer_; std::vector<char> buffer_;
public: public:
sid_t() sid_t() {}
{}
/** creates a wrapped SID copy */ /** creates a wrapped SID copy */
static sid_t duplicate_sid(PSID psid) static sid_t duplicate_sid(PSID psid)
@ -95,7 +93,7 @@ public:
SPDLOG_THROW(spdlog_ex("sid_t::sid_t(): invalid SID received")); 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; sid_t result;
result.buffer_.resize(sid_length); result.buffer_.resize(sid_length);
@ -108,9 +106,9 @@ public:
} }
/** Retrieves pointer to the internal buffer contents as SID* */ /** 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 */ /** Get SID for the current user */
@ -119,11 +117,11 @@ public:
/* create and init RAII holder for process token */ /* create and init RAII holder for process token */
struct process_token_t struct process_token_t
{ {
HANDLE token_handle_= INVALID_HANDLE_VALUE; HANDLE token_handle_ = INVALID_HANDLE_VALUE;
explicit process_token_t(HANDLE process) explicit process_token_t(HANDLE process)
{ {
if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_)) if (!::OpenProcessToken(process, TOKEN_QUERY, &token_handle_))
{ {
SPDLOG_THROW(win32_error("OpenProcessToken")); 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 // Get the required size, this is expected to fail with ERROR_INSUFFICIENT_BUFFER and return the token size
DWORD tusize = 0; 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")); 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 // 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 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) switch (msg.level)
{ {
case level::trace: case level::trace:
case level::debug: case level::debug:
return EVENTLOG_SUCCESS; return EVENTLOG_SUCCESS;
case level::info: case level::info:
return EVENTLOG_INFORMATION_TYPE; return EVENTLOG_INFORMATION_TYPE;
case level::warn: case level::warn:
return EVENTLOG_WARNING_TYPE; return EVENTLOG_WARNING_TYPE;
case level::err: case level::err:
case level::critical: case level::critical:
case level::off: case level::off:
return EVENTLOG_ERROR_TYPE; return EVENTLOG_ERROR_TYPE;
default: default:
// should be unreachable // should be unreachable
SPDLOG_THROW(std::logic_error(fmt::format("Unsupported log level {}", msg.level))); 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 } // namespace internal
/* /*
* Windows Event Log sink * Windows Event Log sink
*/ */
template <typename Mutex> template<typename Mutex>
class win_eventlog_sink : public base_sink<Mutex> class win_eventlog_sink : public base_sink<Mutex>
{ {
private: private:
HANDLE hEventLog_ {NULL}; HANDLE hEventLog_{NULL};
internal::sid_t current_user_sid_; internal::sid_t current_user_sid_;
std::string source_; std::string source_;
WORD event_id_; WORD event_id_;
HANDLE event_log_handle() HANDLE event_log_handle()
{ {
@ -225,17 +222,9 @@ protected:
formatter_->format(msg, formatted); formatter_->format(msg, formatted);
formatted.push_back('\0'); formatted.push_back('\0');
LPCSTR lp_str = static_cast<LPCSTR>(formatted.data()); LPCSTR lp_str = static_cast<LPCSTR>(formatted.data());
auto succeeded = ::ReportEvent( auto succeeded = ::ReportEvent(event_log_handle(), eventlog::get_event_type(msg), eventlog::get_event_category(msg), event_id_,
event_log_handle(), current_user_sid_.as_sid(), 1, 0, &lp_str, nullptr);
eventlog::get_event_type(msg),
eventlog::get_event_category(msg),
event_id_,
current_user_sid_.as_sid(),
1,
0,
&lp_str,
nullptr);
if (!succeeded) if (!succeeded)
{ {
@ -246,9 +235,9 @@ protected:
void flush_() override {} void flush_() override {}
public: 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) : source_(source)
, event_id_ (event_id) , event_id_(event_id)
{ {
try try
{ {
@ -256,8 +245,8 @@ public:
} }
catch (...) catch (...)
{ {
// get_current_user_sid() is unlikely to fail and if it does, we can still proceed without // 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 // 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<details::null_mutex
} // namespace sinks } // namespace sinks
} // namespace spdlog } // namespace spdlog

265
src/fmt.cpp
View File

@ -9,174 +9,181 @@
#if !defined(SPDLOG_FMT_EXTERNAL) #if !defined(SPDLOG_FMT_EXTERNAL)
#include "spdlog/fmt/bundled/format-inl.h" #include "spdlog/fmt/bundled/format-inl.h"
FMT_BEGIN_NAMESPACE FMT_BEGIN_NAMESPACE
namespace internal { namespace internal {
template <typename T> template<typename T>
int format_float(char* buf, std::size_t size, const char* format, int precision, int format_float(char *buf, std::size_t size, const char *format, int precision, T value)
T value) { {
#ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION #ifdef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION
if (precision > 100000) if (precision > 100000)
throw std::runtime_error( throw std::runtime_error("fuzz mode - avoid large allocation inside snprintf");
"fuzz mode - avoid large allocation inside snprintf");
#endif #endif
// Suppress the warning about nonliteral format string. // Suppress the warning about nonliteral format string.
auto snprintf_ptr = FMT_SNPRINTF; auto snprintf_ptr = FMT_SNPRINTF;
return precision < 0 ? snprintf_ptr(buf, size, format, value) return precision < 0 ? snprintf_ptr(buf, size, format, value) : snprintf_ptr(buf, size, format, precision, value);
: snprintf_ptr(buf, size, format, precision, value); }
} struct sprintf_specs
struct sprintf_specs { {
int precision; int precision;
char type; char type;
bool alt : 1; bool alt : 1;
template <typename Char> template<typename Char>
constexpr sprintf_specs(basic_format_specs<Char> specs) constexpr sprintf_specs(basic_format_specs<Char> specs)
: precision(specs.precision), type(specs.type), alt(specs.alt) {} : 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. // This is deprecated and is kept only to preserve ABI compatibility.
template <typename Double> template<typename Double>
char* sprintf_format(Double value, internal::buffer<char>& buf, char *sprintf_format(Double value, internal::buffer<char> &buf, sprintf_specs specs)
sprintf_specs specs) { {
// Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail. // Buffer capacity must be non-zero, otherwise MSVC's vsnprintf_s will fail.
FMT_ASSERT(buf.capacity() != 0, "empty buffer"); FMT_ASSERT(buf.capacity() != 0, "empty buffer");
// Build format string. // Build format string.
enum { max_format_size = 10 }; // longest format: %#-*.*Lg enum
char format[max_format_size]; {
char* format_ptr = format; max_format_size = 10
*format_ptr++ = '%'; }; // longest format: %#-*.*Lg
if (specs.alt || !specs.type) *format_ptr++ = '#'; char format[max_format_size];
if (specs.precision >= 0) { char *format_ptr = format;
*format_ptr++ = '.'; *format_ptr++ = '%';
*format_ptr++ = '*'; if (specs.alt || !specs.type)
} *format_ptr++ = '#';
if (std::is_same<Double, long double>::value) *format_ptr++ = 'L'; if (specs.precision >= 0)
{
*format_ptr++ = '.';
*format_ptr++ = '*';
}
if (std::is_same<Double, long double>::value)
*format_ptr++ = 'L';
char type = specs.type; char type = specs.type;
if (type == '%') if (type == '%')
type = 'f'; type = 'f';
else if (type == 0 || type == 'n') else if (type == 0 || type == 'n')
type = 'g'; type = 'g';
#if FMT_MSC_VER #if FMT_MSC_VER
if (type == 'F') { if (type == 'F')
// MSVC's printf doesn't support 'F'. {
type = 'f'; // MSVC's printf doesn't support 'F'.
} type = 'f';
}
#endif #endif
*format_ptr++ = type; *format_ptr++ = type;
*format_ptr = '\0'; *format_ptr = '\0';
// Format using snprintf. // Format using snprintf.
char* start = nullptr; char *start = nullptr;
char* decimal_point_pos = nullptr; char *decimal_point_pos = nullptr;
for (;;) { for (;;)
std::size_t buffer_size = buf.capacity(); {
start = &buf[0]; std::size_t buffer_size = buf.capacity();
int result = start = &buf[0];
format_float(start, buffer_size, format, specs.precision, value); int result = format_float(start, buffer_size, format, specs.precision, value);
if (result >= 0) { if (result >= 0)
unsigned n = internal::to_unsigned(result); {
if (n < buf.capacity()) { unsigned n = internal::to_unsigned(result);
// Find the decimal point. if (n < buf.capacity())
auto p = buf.data(), end = p + n; {
if (*p == '+' || *p == '-') ++p; // Find the decimal point.
if (specs.type != 'a' && specs.type != 'A') { auto p = buf.data(), end = p + n;
while (p < end && *p >= '0' && *p <= '9') ++p; if (*p == '+' || *p == '-')
if (p < end && *p != 'e' && *p != 'E') { ++p;
decimal_point_pos = p; if (specs.type != 'a' && specs.type != 'A')
if (!specs.type) { {
// Keep only one trailing zero after the decimal point. while (p < end && *p >= '0' && *p <= '9')
++p; ++p;
if (*p == '0') ++p; if (p < end && *p != 'e' && *p != 'E')
while (p != end && *p >= '1' && *p <= '9') ++p; {
char* where = p; decimal_point_pos = p;
while (p != end && *p == '0') ++p; if (!specs.type)
if (p == end || *p < '0' || *p > '9') { {
if (p != end) std::memmove(where, p, to_unsigned(end - p)); // Keep only one trailing zero after the decimal point.
n -= static_cast<unsigned>(p - where); ++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<unsigned>(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<char>&, template FMT_API char *internal::sprintf_format(double, internal::buffer<char> &, sprintf_specs);
sprintf_specs); template FMT_API char *internal::sprintf_format(long double, internal::buffer<char> &, sprintf_specs);
template FMT_API char* internal::sprintf_format(long double,
internal::buffer<char>&,
sprintf_specs);
template struct FMT_API internal::basic_data<void>; template struct FMT_API internal::basic_data<void>;
// Workaround a bug in MSVC2013 that prevents instantiation of format_float. // Workaround a bug in MSVC2013 that prevents instantiation of format_float.
int (*instantiate_format_float)(double, int, internal::float_specs, int (*instantiate_format_float)(double, int, internal::float_specs, internal::buffer<char> &) = internal::format_float;
internal::buffer<char>&) =
internal::format_float;
#ifndef FMT_STATIC_THOUSANDS_SEPARATOR #ifndef FMT_STATIC_THOUSANDS_SEPARATOR
template FMT_API internal::locale_ref::locale_ref(const std::locale& loc); template FMT_API internal::locale_ref::locale_ref(const std::locale &loc);
template FMT_API std::locale internal::locale_ref::get<std::locale>() const; template FMT_API std::locale internal::locale_ref::get<std::locale>() const;
#endif #endif
// Explicit instantiations for char. // Explicit instantiations for char.
template FMT_API std::string internal::grouping_impl<char>(locale_ref); template FMT_API std::string internal::grouping_impl<char>(locale_ref);
template FMT_API char internal::thousands_sep_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 char internal::decimal_point_impl(locale_ref);
template FMT_API void internal::buffer<char>::append(const char*, const char*); template FMT_API void internal::buffer<char>::append(const char *, const char *);
template FMT_API void internal::arg_map<format_context>::init( template FMT_API void internal::arg_map<format_context>::init(const basic_format_args<format_context> &args);
const basic_format_args<format_context>& args);
template FMT_API std::string internal::vformat<char>( template FMT_API std::string internal::vformat<char>(string_view, basic_format_args<format_context>);
string_view, basic_format_args<format_context>);
template FMT_API format_context::iterator internal::vformat_to( template FMT_API format_context::iterator internal::vformat_to(internal::buffer<char> &, string_view, basic_format_args<format_context>);
internal::buffer<char>&, string_view, basic_format_args<format_context>);
template FMT_API int internal::snprintf_float(double, int, template FMT_API int internal::snprintf_float(double, int, internal::float_specs, internal::buffer<char> &);
internal::float_specs, template FMT_API int internal::snprintf_float(long double, int, internal::float_specs, internal::buffer<char> &);
internal::buffer<char>&); template FMT_API int internal::format_float(double, int, internal::float_specs, internal::buffer<char> &);
template FMT_API int internal::snprintf_float(long double, int, template FMT_API int internal::format_float(long double, int, internal::float_specs, internal::buffer<char> &);
internal::float_specs,
internal::buffer<char>&);
template FMT_API int internal::format_float(double, int, internal::float_specs,
internal::buffer<char>&);
template FMT_API int internal::format_float(long double, int,
internal::float_specs,
internal::buffer<char>&);
// Explicit instantiations for wchar_t. // Explicit instantiations for wchar_t.
template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref); template FMT_API std::string internal::grouping_impl<wchar_t>(locale_ref);
template FMT_API wchar_t internal::thousands_sep_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 wchar_t internal::decimal_point_impl(locale_ref);
template FMT_API void internal::buffer<wchar_t>::append(const wchar_t*, template FMT_API void internal::buffer<wchar_t>::append(const wchar_t *, const wchar_t *);
const wchar_t*);
template FMT_API std::wstring internal::vformat<wchar_t>( template FMT_API std::wstring internal::vformat<wchar_t>(wstring_view, basic_format_args<wformat_context>);
wstring_view, basic_format_args<wformat_context>);
FMT_END_NAMESPACE FMT_END_NAMESPACE
#endif #endif

28
tests/test_eventlog.cpp
View File

@ -7,7 +7,7 @@
static const LPCSTR TEST_SOURCE = "spdlog_test"; static const LPCSTR TEST_SOURCE = "spdlog_test";
static void test_single_print(std::function<void(std::string const&)> do_log, std::string const& expected_contents, WORD expected_ev_type) static void test_single_print(std::function<void(std::string const &)> do_log, std::string const &expected_contents, WORD expected_ev_type)
{ {
using namespace std::chrono; using namespace std::chrono;
do_log(expected_contents); do_log(expected_contents);
@ -24,26 +24,28 @@ static void test_single_print(std::function<void(std::string const&)> do_log, st
REQUIRE(CloseEventLog(handle_)); REQUIRE(CloseEventLog(handle_));
} }
} }
} event_log {::OpenEventLog(nullptr, TEST_SOURCE)}; } event_log{::OpenEventLog(nullptr, TEST_SOURCE)};
REQUIRE(event_log.handle_); REQUIRE(event_log.handle_);
DWORD read_bytes {}, size_needed{}; 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); auto ok =
REQUIRE(!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); REQUIRE(::GetLastError() == ERROR_INSUFFICIENT_BUFFER);
std::vector<char> record_buffer(size_needed); std::vector<char> record_buffer(size_needed);
PEVENTLOGRECORD record = (PEVENTLOGRECORD)record_buffer.data(); 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(ok);
REQUIRE(record->NumStrings == 1); REQUIRE(record->NumStrings == 1);
REQUIRE(record->EventType == expected_ev_type); REQUIRE(record->EventType == expected_ev_type);
REQUIRE(record->TimeGenerated == expected_time_generated); 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); 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_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.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.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.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.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.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.critical(msg); }, "my critical message", EVENTLOG_ERROR_TYPE);
} }
#endif //_WIN32 #endif //_WIN32

7
tests/test_file_logging.cpp
View File

@ -17,8 +17,7 @@ TEST_CASE("simple_file_logger", "[simple_logger]]")
logger->flush(); logger->flush();
require_message_count(filename, 2); require_message_count(filename, 2);
using spdlog::details::os::default_eol; using spdlog::details::os::default_eol;
REQUIRE(file_contents(filename) == fmt::format("Test message 1{}Test message 2{}", REQUIRE(file_contents(filename) == fmt::format("Test message 1{}Test message 2{}", default_eol, default_eol));
default_eol, default_eol));
} }
TEST_CASE("flush_on", "[flush_on]]") TEST_CASE("flush_on", "[flush_on]]")
@ -38,8 +37,8 @@ TEST_CASE("flush_on", "[flush_on]]")
require_message_count(filename, 3); require_message_count(filename, 3);
using spdlog::details::os::default_eol; using spdlog::details::os::default_eol;
REQUIRE(file_contents(filename) == fmt::format("Should not be flushed{}Test message 1{}Test message 2{}", REQUIRE(file_contents(filename) ==
default_eol, default_eol, default_eol)); 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]]") TEST_CASE("rotating_file_logger1", "[rotating_logger]]")

7
tests/utils.cpp
View File

@ -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) 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); REQUIRE(count_lines(filename) == 1);
} else { }
else
{
REQUIRE(count_lines(filename) == messages); REQUIRE(count_lines(filename) == messages);
} }
} }