danny
/
spdlog
mirror of https://github.com/gabime/spdlog.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Fixed set_default_logger

Browse Source
pull/2143/head
gabime 4 years ago
parent ea3476cf1f
commit 55f41f367f
13 changed files with 52 additions and 254 deletions
Show Stats Download Patch File Download Diff File

1
include/spdlog/cfg/argv.h
Unescape Escape View File

@ -3,7 +3,6 @@
#pragma once #pragma once
#include <spdlog/cfg/helpers.h> #include <spdlog/cfg/helpers.h>
#include <spdlog/details/registry.h>
// //
// Init log levels using each argv entry that starts with "SPDLOG_LEVEL=" // Init log levels using each argv entry that starts with "SPDLOG_LEVEL="

17
include/spdlog/spdlog-inl.h
Unescape Escape View File

@ -8,6 +8,7 @@
#endif #endif
#include <spdlog/common.h> #include <spdlog/common.h>
#include <spdlog/sinks/stdout_color_sinks.h>
namespace spdlog { namespace spdlog {
@ -24,20 +25,22 @@ SPDLOG_INLINE void shutdown()
//details::registry::instance().shutdown(); //details::registry::instance().shutdown();
} }
SPDLOG_INLINE std::shared_ptr<spdlog::logger> default_logger()
SPDLOG_INLINE std::shared_ptr<spdlog::logger>& default_logger()
{ {
static std::shared_ptr<spdlog::logger> default_logger_ = std::make_shared<spdlog::logger>(""); static auto s_default_logger = stdout_color_mt("");
return default_logger_; return s_default_logger;
} }
SPDLOG_INLINE logger *default_logger_raw() SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> new_logger)
{ {
return default_logger().get(); //TODO remove this default_logger() = std::move(new_logger);
} }
SPDLOG_INLINE void set_default_logger(std::shared_ptr<spdlog::logger> default_logger) SPDLOG_INLINE logger *default_logger_raw()
{ {
default_logger = std::move(default_logger); return default_logger().get(); //TODO remove this
} }
} // namespace spdlog } // namespace spdlog

67
include/spdlog/spdlog.h
Unescape Escape View File

@ -36,6 +36,7 @@ inline std::shared_ptr<spdlog::logger> create(std::string logger_name, SinkArgs
} }
// stop any running threads started by spdlog for async logging // stop any running threads started by spdlog for async logging
// TODO remove this
SPDLOG_API void shutdown(); SPDLOG_API void shutdown();
// API for using default logger (stdout_color_mt), // API for using default logger (stdout_color_mt),
@ -53,156 +54,154 @@ SPDLOG_API void shutdown();
// set_default_logger() *should not* be used concurrently with the default API. // set_default_logger() *should not* be used concurrently with the default API.
// e.g do not call set_default_logger() from one thread while calling spdlog::info() from another. // e.g do not call set_default_logger() from one thread while calling spdlog::info() from another.
SPDLOG_API std::shared_ptr<spdlog::logger> default_logger(); SPDLOG_API std::shared_ptr<spdlog::logger> &default_logger();
SPDLOG_API spdlog::logger *default_logger_raw();
SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger); SPDLOG_API void set_default_logger(std::shared_ptr<spdlog::logger> default_logger);
template<typename... Args> template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args) inline void log(source_loc source, level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args) inline void log(level::level_enum lvl, fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(fmt::format_string<Args...> fmt, Args &&...args) inline void trace(fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->trace(fmt, std::forward<Args>(args)...); default_logger()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(fmt::format_string<Args...> fmt, Args &&...args) inline void debug(fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->debug(fmt, std::forward<Args>(args)...); default_logger()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(fmt::format_string<Args...> fmt, Args &&...args) inline void info(fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->info(fmt, std::forward<Args>(args)...); default_logger()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(fmt::format_string<Args...> fmt, Args &&...args) inline void warn(fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->warn(fmt, std::forward<Args>(args)...); default_logger()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(fmt::format_string<Args...> fmt, Args &&...args) inline void error(fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->error(fmt, std::forward<Args>(args)...); default_logger()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(fmt::format_string<Args...> fmt, Args &&...args) inline void critical(fmt::format_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->critical(fmt, std::forward<Args>(args)...); default_logger()->critical(fmt, std::forward<Args>(args)...);
} }
template<typename T> template<typename T>
inline void log(source_loc source, level::level_enum lvl, const T &msg) inline void log(source_loc source, level::level_enum lvl, const T &msg)
{ {
default_logger_raw()->log(source, lvl, msg); default_logger()->log(source, lvl, msg);
} }
template<typename T> template<typename T>
inline void log(level::level_enum lvl, const T &msg) inline void log(level::level_enum lvl, const T &msg)
{ {
default_logger_raw()->log(lvl, msg); default_logger()->log(lvl, msg);
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
template<typename... Args> template<typename... Args>
inline void log(source_loc source, level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args) inline void log(source_loc source, level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void log(level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args) inline void log(level::level_enum lvl, fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...); default_logger()->log(source_loc{}, lvl, fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void trace(fmt::wformat_string<Args...> fmt, Args &&...args) inline void trace(fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->trace(fmt, std::forward<Args>(args)...); default_logger()->trace(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void debug(fmt::wformat_string<Args...> fmt, Args &&...args) inline void debug(fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->debug(fmt, std::forward<Args>(args)...); default_logger()->debug(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void info(fmt::wformat_string<Args...> fmt, Args &&...args) inline void info(fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->info(fmt, std::forward<Args>(args)...); default_logger()->info(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void warn(fmt::wformat_string<Args...> fmt, Args &&...args) inline void warn(fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->warn(fmt, std::forward<Args>(args)...); default_logger()->warn(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void error(fmt::wformat_string<Args...> fmt, Args &&...args) inline void error(fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->error(fmt, std::forward<Args>(args)...); default_logger()->error(fmt, std::forward<Args>(args)...);
} }
template<typename... Args> template<typename... Args>
inline void critical(fmt::wformat_string<Args...> fmt, Args &&...args) inline void critical(fmt::wformat_string<Args...> fmt, Args &&...args)
{ {
default_logger_raw()->critical(fmt, std::forward<Args>(args)...); default_logger()->critical(fmt, std::forward<Args>(args)...);
} }
#endif #endif
template<typename T> template<typename T>
inline void trace(const T &msg) inline void trace(const T &msg)
{ {
default_logger_raw()->trace(msg); default_logger()->trace(msg);
} }
template<typename T> template<typename T>
inline void debug(const T &msg) inline void debug(const T &msg)
{ {
default_logger_raw()->debug(msg); default_logger()->debug(msg);
} }
template<typename T> template<typename T>
inline void info(const T &msg) inline void info(const T &msg)
{ {
default_logger_raw()->info(msg); default_logger()->info(msg);
} }
template<typename T> template<typename T>
inline void warn(const T &msg) inline void warn(const T &msg)
{ {
default_logger_raw()->warn(msg); default_logger()->warn(msg);
} }
template<typename T> template<typename T>
inline void error(const T &msg) inline void error(const T &msg)
{ {
default_logger_raw()->error(msg); default_logger()->error(msg);
} }
template<typename T> template<typename T>
inline void critical(const T &msg) inline void critical(const T &msg)
{ {
default_logger_raw()->critical(msg); default_logger()->critical(msg);
} }
} // namespace spdlog } // namespace spdlog
@ -224,7 +223,7 @@ inline void critical(const T &msg)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_TRACE
# define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__) # define SPDLOG_LOGGER_TRACE(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::trace, __VA_ARGS__)
# define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger_raw(), __VA_ARGS__) # define SPDLOG_TRACE(...) SPDLOG_LOGGER_TRACE(spdlog::default_logger(), __VA_ARGS__)
#else #else
# define SPDLOG_LOGGER_TRACE(logger, ...) (void)0 # define SPDLOG_LOGGER_TRACE(logger, ...) (void)0
# define SPDLOG_TRACE(...) (void)0 # define SPDLOG_TRACE(...) (void)0
@ -232,7 +231,7 @@ inline void critical(const T &msg)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_DEBUG
# define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__) # define SPDLOG_LOGGER_DEBUG(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::debug, __VA_ARGS__)
# define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger_raw(), __VA_ARGS__) # define SPDLOG_DEBUG(...) SPDLOG_LOGGER_DEBUG(spdlog::default_logger(), __VA_ARGS__)
#else #else
# define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0 # define SPDLOG_LOGGER_DEBUG(logger, ...) (void)0
# define SPDLOG_DEBUG(...) (void)0 # define SPDLOG_DEBUG(...) (void)0
@ -240,7 +239,7 @@ inline void critical(const T &msg)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_INFO
# define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__) # define SPDLOG_LOGGER_INFO(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::info, __VA_ARGS__)
# define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger_raw(), __VA_ARGS__) # define SPDLOG_INFO(...) SPDLOG_LOGGER_INFO(spdlog::default_logger(), __VA_ARGS__)
#else #else
# define SPDLOG_LOGGER_INFO(logger, ...) (void)0 # define SPDLOG_LOGGER_INFO(logger, ...) (void)0
# define SPDLOG_INFO(...) (void)0 # define SPDLOG_INFO(...) (void)0
@ -248,7 +247,7 @@ inline void critical(const T &msg)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_WARN
# define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__) # define SPDLOG_LOGGER_WARN(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::warn, __VA_ARGS__)
# define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger_raw(), __VA_ARGS__) # define SPDLOG_WARN(...) SPDLOG_LOGGER_WARN(spdlog::default_logger(), __VA_ARGS__)
#else #else
# define SPDLOG_LOGGER_WARN(logger, ...) (void)0 # define SPDLOG_LOGGER_WARN(logger, ...) (void)0
# define SPDLOG_WARN(...) (void)0 # define SPDLOG_WARN(...) (void)0
@ -256,7 +255,7 @@ inline void critical(const T &msg)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_ERROR
# define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__) # define SPDLOG_LOGGER_ERROR(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::err, __VA_ARGS__)
# define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger_raw(), __VA_ARGS__) # define SPDLOG_ERROR(...) SPDLOG_LOGGER_ERROR(spdlog::default_logger(), __VA_ARGS__)
#else #else
# define SPDLOG_LOGGER_ERROR(logger, ...) (void)0 # define SPDLOG_LOGGER_ERROR(logger, ...) (void)0
# define SPDLOG_ERROR(...) (void)0 # define SPDLOG_ERROR(...) (void)0
@ -264,7 +263,7 @@ inline void critical(const T &msg)
#if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL #if SPDLOG_ACTIVE_LEVEL <= SPDLOG_LEVEL_CRITICAL
# define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__) # define SPDLOG_LOGGER_CRITICAL(logger, ...) SPDLOG_LOGGER_CALL(logger, spdlog::level::critical, __VA_ARGS__)
# define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger_raw(), __VA_ARGS__) # define SPDLOG_CRITICAL(...) SPDLOG_LOGGER_CRITICAL(spdlog::default_logger(), __VA_ARGS__)
#else #else
# define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0 # define SPDLOG_LOGGER_CRITICAL(logger, ...) (void)0
# define SPDLOG_CRITICAL(...) (void)0 # define SPDLOG_CRITICAL(...) (void)0

4
tests/CMakeLists.txt
Unescape Escape View File

@ -21,7 +21,6 @@ set(SPDLOG_UTESTS_SOURCES
test_eventlog.cpp test_eventlog.cpp
test_pattern_formatter.cpp test_pattern_formatter.cpp
test_async.cpp test_async.cpp
test_registry.cpp
test_macros.cpp test_macros.cpp
utils.cpp utils.cpp
main.cpp main.cpp
@ -29,9 +28,8 @@ set(SPDLOG_UTESTS_SOURCES
test_dup_filter.cpp test_dup_filter.cpp
test_fmt_helper.cpp test_fmt_helper.cpp
test_stdout_api.cpp test_stdout_api.cpp
test_backtrace.cpp
test_create_dir.cpp test_create_dir.cpp
test_cfg.cpp # test_cfg.cpp TODO
test_time_point.cpp test_time_point.cpp
test_stopwatch.cpp) test_stopwatch.cpp)

4
tests/test_async.cpp
Unescape Escape View File

@ -59,7 +59,6 @@ TEST_CASE("discard policy using factory ", "[async]")
} }
REQUIRE(test_sink->msg_counter() < messages); REQUIRE(test_sink->msg_counter() < messages);
spdlog::drop_all();
} }
TEST_CASE("flush", "[async]") TEST_CASE("flush", "[async]")
@ -82,6 +81,8 @@ TEST_CASE("flush", "[async]")
REQUIRE(test_sink->flush_counter() == 1); REQUIRE(test_sink->flush_counter() == 1);
} }
/*
* TODO
TEST_CASE("async periodic flush", "[async]") TEST_CASE("async periodic flush", "[async]")
{ {
@ -94,6 +95,7 @@ TEST_CASE("async periodic flush", "[async]")
spdlog::flush_every(std::chrono::seconds(0)); spdlog::flush_every(std::chrono::seconds(0));
spdlog::drop_all(); spdlog::drop_all();
} }
*/
TEST_CASE("tp->wait_empty() ", "[async]") TEST_CASE("tp->wait_empty() ", "[async]")
{ {

65
tests/test_backtrace.cpp
Unescape Escape View File

@ -1,65 +0,0 @@
#include "includes.h"
#include "test_sink.h"
#include "spdlog/async.h"
TEST_CASE("bactrace1", "[bactrace]")
{
using spdlog::sinks::test_sink_st;
auto test_sink = std::make_shared<test_sink_st>();
size_t backtrace_size = 5;
spdlog::logger logger("test-backtrace", test_sink);
logger.set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
logger.enable_backtrace(backtrace_size);
logger.info("info message");
for (int i = 0; i < 100; i++)
logger.debug("debug message {}", i);
REQUIRE(test_sink->lines().size() == 1);
REQUIRE(test_sink->lines()[0] == "info message");
logger.dump_backtrace();
REQUIRE(test_sink->lines().size() == backtrace_size + 3);
REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************");
REQUIRE(test_sink->lines()[2] == "debug message 95");
REQUIRE(test_sink->lines()[3] == "debug message 96");
REQUIRE(test_sink->lines()[4] == "debug message 97");
REQUIRE(test_sink->lines()[5] == "debug message 98");
REQUIRE(test_sink->lines()[6] == "debug message 99");
REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************");
}
TEST_CASE("bactrace-async", "[bactrace]")
{
using spdlog::sinks::test_sink_mt;
auto test_sink = std::make_shared<test_sink_mt>();
using spdlog::details::os::sleep_for_millis;
size_t backtrace_size = 5;
spdlog::init_thread_pool(120, 1);
auto logger = std::make_shared<spdlog::async_logger>("test-bactrace-async", test_sink, spdlog::thread_pool());
logger->set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
logger->enable_backtrace(backtrace_size);
logger->info("info message");
for (int i = 0; i < 100; i++)
logger->debug("debug message {}", i);
sleep_for_millis(100);
REQUIRE(test_sink->lines().size() == 1);
REQUIRE(test_sink->lines()[0] == "info message");
logger->dump_backtrace();
sleep_for_millis(100); // give time for the async dump to complete
REQUIRE(test_sink->lines().size() == backtrace_size + 3);
REQUIRE(test_sink->lines()[1] == "****************** Backtrace Start ******************");
REQUIRE(test_sink->lines()[2] == "debug message 95");
REQUIRE(test_sink->lines()[3] == "debug message 96");
REQUIRE(test_sink->lines()[4] == "debug message 97");
REQUIRE(test_sink->lines()[5] == "debug message 98");
REQUIRE(test_sink->lines()[6] == "debug message 99");
REQUIRE(test_sink->lines()[7] == "****************** Backtrace End ********************");
}

4
tests/test_errors.cpp
Unescape Escape View File

@ -56,7 +56,6 @@ TEST_CASE("custom_error_handler", "[errors]]")
TEST_CASE("default_error_handler2", "[errors]]") TEST_CASE("default_error_handler2", "[errors]]")
{ {
spdlog::drop_all();
auto logger = spdlog::create<failing_sink>("failed_logger"); auto logger = spdlog::create<failing_sink>("failed_logger");
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex); REQUIRE_THROWS_AS(logger->info("Some message"), custom_ex);
@ -64,7 +63,6 @@ TEST_CASE("default_error_handler2", "[errors]]")
TEST_CASE("flush_error_handler", "[errors]]") TEST_CASE("flush_error_handler", "[errors]]")
{ {
spdlog::drop_all();
auto logger = spdlog::create<failing_sink>("failed_logger"); auto logger = spdlog::create<failing_sink>("failed_logger");
logger->set_error_handler([=](const std::string &) { throw custom_ex(); }); logger->set_error_handler([=](const std::string &) { throw custom_ex(); });
REQUIRE_THROWS_AS(logger->flush(), custom_ex); REQUIRE_THROWS_AS(logger->flush(), custom_ex);
@ -90,7 +88,6 @@ TEST_CASE("async_error_handler", "[errors]]")
logger->info("Good message #1"); logger->info("Good message #1");
logger->info(fmt::runtime("Bad format msg {} {}"), "xxx"); logger->info(fmt::runtime("Bad format msg {} {}"), "xxx");
logger->info("Good message #2"); logger->info("Good message #2");
spdlog::drop("logger"); // force logger to drain the queue and shutdown
} }
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);
require_message_count(SIMPLE_ASYNC_LOG, 2); require_message_count(SIMPLE_ASYNC_LOG, 2);
@ -113,7 +110,6 @@ TEST_CASE("async_error_handler2", "[errors]]")
ofs << err_msg; ofs << err_msg;
}); });
logger->info("Hello failure"); logger->info("Hello failure");
spdlog::drop("failed_logger"); // force logger to drain the queue and shutdown
} }
spdlog::init_thread_pool(128, 1); spdlog::init_thread_pool(128, 1);

3
tests/test_file_logging.cpp
Unescape Escape View File

@ -73,9 +73,6 @@ TEST_CASE("rotating_file_logger2", "[rotating_logger]]")
{ {
logger->info("Test message {}", i); logger->info("Test message {}", i);
} }
// drop causes the logger destructor to be called, which is required so the
// next logger can rename the first output file.
spdlog::drop(logger->name());
} }
auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true); auto logger = spdlog::rotating_logger_mt("logger", basename, max_size, 2, true);

14
tests/test_misc.cpp
Unescape Escape View File

@ -79,6 +79,7 @@ TEST_CASE("to_level_enum", "[convert_to_level_enum]")
REQUIRE(spdlog::level::from_str("null") == spdlog::level::off); REQUIRE(spdlog::level::from_str("null") == spdlog::level::off);
} }
/*
TEST_CASE("periodic flush", "[periodic_flush]") TEST_CASE("periodic flush", "[periodic_flush]")
{ {
using spdlog::sinks::test_sink_mt; using spdlog::sinks::test_sink_mt;
@ -91,7 +92,7 @@ TEST_CASE("periodic flush", "[periodic_flush]")
spdlog::flush_every(std::chrono::seconds(0)); spdlog::flush_every(std::chrono::seconds(0));
spdlog::drop_all(); spdlog::drop_all();
} }
*/
TEST_CASE("clone-logger", "[clone]") TEST_CASE("clone-logger", "[clone]")
{ {
using spdlog::sinks::test_sink_mt; using spdlog::sinks::test_sink_mt;
@ -110,8 +111,6 @@ TEST_CASE("clone-logger", "[clone]")
REQUIRE(test_sink->lines().size() == 2); REQUIRE(test_sink->lines().size() == 2);
REQUIRE(test_sink->lines()[0] == "Some message 1"); REQUIRE(test_sink->lines()[0] == "Some message 1");
REQUIRE(test_sink->lines()[1] == "Some message 2"); REQUIRE(test_sink->lines()[1] == "Some message 2");
spdlog::drop_all();
} }
TEST_CASE("clone async", "[clone]") TEST_CASE("clone async", "[clone]")
@ -136,8 +135,6 @@ TEST_CASE("clone async", "[clone]")
REQUIRE(test_sink->lines().size() == 2); REQUIRE(test_sink->lines().size() == 2);
REQUIRE(test_sink->lines()[0] == "Some message 1"); REQUIRE(test_sink->lines()[0] == "Some message 1");
REQUIRE(test_sink->lines()[1] == "Some message 2"); REQUIRE(test_sink->lines()[1] == "Some message 2");
spdlog::drop_all();
} }
TEST_CASE("to_hex", "[to_hex]") TEST_CASE("to_hex", "[to_hex]")
@ -236,7 +233,7 @@ TEST_CASE("default logger API", "[default logger]")
auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss); auto oss_sink = std::make_shared<spdlog::sinks::ostream_sink_mt>(oss);
spdlog::set_default_logger(std::make_shared<spdlog::logger>("oss", oss_sink)); spdlog::set_default_logger(std::make_shared<spdlog::logger>("oss", oss_sink));
spdlog::set_formatter(make_unique<spdlog::pattern_formatter>("*** %v")); spdlog::default_logger()->set_formatter(make_unique<spdlog::pattern_formatter>("*** %v"));
spdlog::default_logger()->set_level(spdlog::level::trace); spdlog::default_logger()->set_level(spdlog::level::trace);
spdlog::trace("hello trace"); spdlog::trace("hello trace");
@ -263,9 +260,8 @@ TEST_CASE("default logger API", "[default logger]")
REQUIRE(oss.str() == "*** some string" + std::string(spdlog::details::os::default_eol)); REQUIRE(oss.str() == "*** some string" + std::string(spdlog::details::os::default_eol));
oss.str(""); oss.str("");
spdlog::set_level(spdlog::level::info); spdlog::default_logger()->set_level(spdlog::level::info);
spdlog::debug("should not be logged"); spdlog::debug("should not be logged");
REQUIRE(oss.str().empty()); REQUIRE(oss.str().empty());
spdlog::drop_all(); spdlog::default_logger()->set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
spdlog::set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
} }

116
tests/test_registry.cpp
Unescape Escape View File

@ -1,116 +0,0 @@
#include "includes.h"
static const char *const tested_logger_name = "null_logger";
static const char *const tested_logger_name2 = "null_logger2";
#ifndef SPDLOG_NO_EXCEPTIONS
TEST_CASE("register_drop", "[registry]")
{
spdlog::drop_all();
spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
REQUIRE(spdlog::get(tested_logger_name) != nullptr);
// Throw if registering existing name
REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name), spdlog::spdlog_ex);
}
TEST_CASE("explicit register", "[registry]")
{
spdlog::drop_all();
auto logger = std::make_shared<spdlog::logger>(tested_logger_name, std::make_shared<spdlog::sinks::null_sink_st>());
spdlog::register_logger(logger);
REQUIRE(spdlog::get(tested_logger_name) != nullptr);
// Throw if registering existing name
REQUIRE_THROWS_AS(spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name), spdlog::spdlog_ex);
}
#endif
TEST_CASE("apply_all", "[registry]")
{
spdlog::drop_all();
auto logger = std::make_shared<spdlog::logger>(tested_logger_name, std::make_shared<spdlog::sinks::null_sink_st>());
spdlog::register_logger(logger);
auto logger2 = std::make_shared<spdlog::logger>(tested_logger_name2, std::make_shared<spdlog::sinks::null_sink_st>());
spdlog::register_logger(logger2);
int counter = 0;
spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger>) { counter++; });
REQUIRE(counter == 2);
counter = 0;
spdlog::drop(tested_logger_name2);
spdlog::apply_all([&counter](std::shared_ptr<spdlog::logger> l) {
REQUIRE(l->name() == tested_logger_name);
counter++;
});
REQUIRE(counter == 1);
}
TEST_CASE("drop", "[registry]")
{
spdlog::drop_all();
spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
spdlog::drop(tested_logger_name);
REQUIRE_FALSE(spdlog::get(tested_logger_name));
}
TEST_CASE("drop-default", "[registry]")
{
spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));
spdlog::drop(tested_logger_name);
REQUIRE_FALSE(spdlog::default_logger());
REQUIRE_FALSE(spdlog::get(tested_logger_name));
}
TEST_CASE("drop_all", "[registry]")
{
spdlog::drop_all();
spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name2);
spdlog::drop_all();
REQUIRE_FALSE(spdlog::get(tested_logger_name));
REQUIRE_FALSE(spdlog::get(tested_logger_name2));
REQUIRE_FALSE(spdlog::default_logger());
}
TEST_CASE("drop non existing", "[registry]")
{
spdlog::drop_all();
spdlog::create<spdlog::sinks::null_sink_mt>(tested_logger_name);
spdlog::drop("some_name");
REQUIRE_FALSE(spdlog::get("some_name"));
REQUIRE(spdlog::get(tested_logger_name));
spdlog::drop_all();
}
TEST_CASE("default logger", "[registry]")
{
spdlog::drop_all();
spdlog::set_default_logger(spdlog::null_logger_st(tested_logger_name));
REQUIRE(spdlog::get(tested_logger_name) == spdlog::default_logger());
spdlog::drop_all();
}
TEST_CASE("set_default_logger(nullptr)", "[registry]")
{
spdlog::set_default_logger(nullptr);
REQUIRE_FALSE(spdlog::default_logger());
}
TEST_CASE("disable automatic registration", "[registry]")
{
// set some global parameters
spdlog::level::level_enum log_level = spdlog::level::level_enum::warn;
spdlog::set_level(log_level);
// but disable automatic registration
spdlog::set_automatic_registration(false);
auto logger1 = spdlog::create<spdlog::sinks::daily_file_sink_st>(tested_logger_name, SPDLOG_FILENAME_T("filename"), 11, 59);
auto logger2 = spdlog::create_async<spdlog::sinks::stdout_color_sink_mt>(tested_logger_name2);
// loggers should not be part of the registry
REQUIRE_FALSE(spdlog::get(tested_logger_name));
REQUIRE_FALSE(spdlog::get(tested_logger_name2));
// but make sure they are still initialized according to global defaults
REQUIRE(logger1->level() == log_level);
REQUIRE(logger2->level() == log_level);
spdlog::set_level(spdlog::level::info);
spdlog::set_automatic_registration(true);
}

9
tests/test_stdout_api.cpp
Unescape Escape View File

@ -10,7 +10,6 @@ TEST_CASE("stdout_st", "[stdout]")
l->set_formatter(make_unique<spdlog::pattern_formatter>("%v")); l->set_formatter(make_unique<spdlog::pattern_formatter>("%v"));
l->set_level(spdlog::level::trace); l->set_level(spdlog::level::trace);
l->trace("Test stdout_st"); l->trace("Test stdout_st");
spdlog::drop_all();
} }
TEST_CASE("stdout_mt", "[stdout]") TEST_CASE("stdout_mt", "[stdout]")
@ -19,7 +18,6 @@ TEST_CASE("stdout_mt", "[stdout]")
l->set_formatter(make_unique<spdlog::default_formatter>()); l->set_formatter(make_unique<spdlog::default_formatter>());
l->set_level(spdlog::level::debug); l->set_level(spdlog::level::debug);
l->debug("Test stdout_mt"); l->debug("Test stdout_mt");
spdlog::drop_all();
} }
TEST_CASE("stderr_st", "[stderr]") TEST_CASE("stderr_st", "[stderr]")
@ -27,7 +25,6 @@ TEST_CASE("stderr_st", "[stderr]")
auto l = spdlog::stderr_logger_st("test"); auto l = spdlog::stderr_logger_st("test");
l->set_formatter(make_unique<spdlog::default_formatter>()); l->set_formatter(make_unique<spdlog::default_formatter>());
l->info("Test stderr_st"); l->info("Test stderr_st");
spdlog::drop_all();
} }
TEST_CASE("stderr_mt", "[stderr]") TEST_CASE("stderr_mt", "[stderr]")
@ -38,7 +35,6 @@ TEST_CASE("stderr_mt", "[stderr]")
l->warn("Test stderr_mt"); l->warn("Test stderr_mt");
l->error("Test stderr_mt"); l->error("Test stderr_mt");
l->critical("Test stderr_mt"); l->critical("Test stderr_mt");
spdlog::drop_all();
} }
// color loggers // color loggers
@ -47,7 +43,6 @@ TEST_CASE("stdout_color_st", "[stdout]")
auto l = spdlog::stdout_color_st("test"); auto l = spdlog::stdout_color_st("test");
l->set_formatter(make_unique<spdlog::default_formatter>()); l->set_formatter(make_unique<spdlog::default_formatter>());
l->info("Test stdout_color_st"); l->info("Test stdout_color_st");
spdlog::drop_all();
} }
TEST_CASE("stdout_color_mt", "[stdout]") TEST_CASE("stdout_color_mt", "[stdout]")
@ -56,7 +51,6 @@ TEST_CASE("stdout_color_mt", "[stdout]")
l->set_formatter(make_unique<spdlog::default_formatter>()); l->set_formatter(make_unique<spdlog::default_formatter>());
l->set_level(spdlog::level::trace); l->set_level(spdlog::level::trace);
l->trace("Test stdout_color_mt"); l->trace("Test stdout_color_mt");
spdlog::drop_all();
} }
TEST_CASE("stderr_color_st", "[stderr]") TEST_CASE("stderr_color_st", "[stderr]")
@ -65,7 +59,6 @@ TEST_CASE("stderr_color_st", "[stderr]")
l->set_formatter(make_unique<spdlog::default_formatter>()); l->set_formatter(make_unique<spdlog::default_formatter>());
l->set_level(spdlog::level::debug); l->set_level(spdlog::level::debug);
l->debug("Test stderr_color_st"); l->debug("Test stderr_color_st");
spdlog::drop_all();
} }
TEST_CASE("stderr_color_mt", "[stderr]") TEST_CASE("stderr_color_mt", "[stderr]")
@ -76,7 +69,6 @@ TEST_CASE("stderr_color_mt", "[stderr]")
l->warn("Test stderr_color_mt"); l->warn("Test stderr_color_mt");
l->error("Test stderr_color_mt"); l->error("Test stderr_color_mt");
l->critical("Test stderr_color_mt"); l->critical("Test stderr_color_mt");
spdlog::drop_all();
} }
#ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT #ifdef SPDLOG_WCHAR_TO_UTF8_SUPPORT
@ -91,7 +83,6 @@ TEST_CASE("wchar_api", "[stdout]")
l->trace(L"Test wchar_api {}", std::wstring{L"wstring param"}); l->trace(L"Test wchar_api {}", std::wstring{L"wstring param"});
l->trace(std::wstring{L"Test wchar_api wstring"}); l->trace(std::wstring{L"Test wchar_api wstring"});
SPDLOG_LOGGER_DEBUG(l, L"Test SPDLOG_LOGGER_DEBUG {}", L"param"); SPDLOG_LOGGER_DEBUG(l, L"Test SPDLOG_LOGGER_DEBUG {}", L"param");
spdlog::drop_all();
} }
#endif #endif

1
tests/test_time_point.cpp
Unescape Escape View File

@ -32,5 +32,4 @@ TEST_CASE("time_point1", "[time_point log_msg]")
REQUIRE(lines[4] == lines[5]); REQUIRE(lines[4] == lines[5]);
REQUIRE(lines[6] == lines[7]); REQUIRE(lines[6] == lines[7]);
REQUIRE(lines[8] != lines[9]); REQUIRE(lines[8] != lines[9]);
spdlog::drop_all();
} }

1
tests/utils.cpp
Unescape Escape View File

@ -9,7 +9,6 @@
void prepare_logdir() void prepare_logdir()
{ {
spdlog::drop_all();
#ifdef _WIN32 #ifdef _WIN32
system("rmdir /S /Q test_logs"); system("rmdir /S /Q test_logs");
#else #else

Write Preview
Loading…
Cancel
Save