diff --git a/bench/latency/g3log-crush.cpp b/bench/latency/g3log-crush.cpp index 47d6b197..417b014c 100644 --- a/bench/latency/g3log-crush.cpp +++ b/bench/latency/g3log-crush.cpp @@ -5,10 +5,10 @@ void CrusherLoop() { - size_t counter = 0; + size_t counter = 0; while (true) { - LOGF(INFO, "Some text to crush you machine. thread:"); + LOGF(INFO, "Some text to crush you machine. thread:"); if(++counter % 1000000 == 0) { std::cout << "Wrote " << counter << " entries" << std::endl; @@ -24,13 +24,13 @@ int main(int argc, char** argv) char c; std::cin >> c; if (toupper( c ) != 'Y') - return 0; - - auto worker = g3::LogWorker::createLogWorker(); + return 0; + + auto worker = g3::LogWorker::createLogWorker(); auto handle= worker->addDefaultLogger(argv[0], "g3log.txt"); - g3::initializeLogging(worker.get()); - CrusherLoop(); - + g3::initializeLogging(worker.get()); + CrusherLoop(); + return 0; } diff --git a/bench/spdlog-null-async.cpp b/bench/spdlog-null-async.cpp index 435d7eb5..3874371a 100644 --- a/bench/spdlog-null-async.cpp +++ b/bench/spdlog-null-async.cpp @@ -46,7 +46,7 @@ int main(int argc, char* argv[]) if (argc > 3) queue_size = atoi(argv[3]); - + cout << "\n*******************************************************************************\n"; cout << "async logging.. " << threads << " threads sharing same logger, " << format(howmany) << " messages " << endl; cout << "*******************************************************************************\n"; @@ -64,7 +64,7 @@ int main(int argc, char* argv[]) } std::cout << endl; std::cout << "Avg rate: " << format(total_rate/iters) << "/sec" <info("Welcome to spdlog!"); - console->error("Some error message with arg{}..", 1); + console->error("Some error message with arg{}..", 1); // Formatting examples console->warn("Easy padding in numbers like {:08d}", 12); @@ -33,11 +33,11 @@ int main(int, char*[]) console->info("Support for floats {:03.2f}", 1.23456); console->info("Positional args are {1} {0}..", "too", "supported"); console->info("{:<30}", "left aligned"); - + spd::get("console")->info("loggers can be retrieved from a global registry using the spdlog::get(logger_name) function"); - + // Create basic file logger (not rotated) auto my_logger = spd::basic_logger_mt("basic_logger", "logs/basic.txt"); my_logger->info("Some log message"); @@ -58,11 +58,11 @@ int main(int, char*[]) rotating_logger->info("This is another message with custom format"); - // Runtime log levels - spd::set_level(spd::level::info); //Set global log level to info - console->debug("This message shold not be displayed!"); - console->set_level(spd::level::debug); // Set specific logger's log level - console->debug("This message shold be displayed.."); + // Runtime log levels + spd::set_level(spd::level::info); //Set global log level to info + console->debug("This message shold not be displayed!"); + console->set_level(spd::level::debug); // Set specific logger's log level + console->debug("This message shold be displayed.."); // Compile time log levels // define SPDLOG_DEBUG_ON or SPDLOG_TRACE_ON diff --git a/include/spdlog/details/file_helper.h b/include/spdlog/details/file_helper.h index 2e6ce9d2..074d9b83 100644 --- a/include/spdlog/details/file_helper.h +++ b/include/spdlog/details/file_helper.h @@ -32,7 +32,7 @@ public: const int open_interval = 10; explicit file_helper() : - _fd(nullptr) + _fd(nullptr) {} file_helper(const file_helper&) = delete; @@ -89,7 +89,7 @@ public: size_t msg_size = msg.formatted.size(); auto data = msg.formatted.data(); if (std::fwrite(data, 1, msg_size, _fd) != msg_size) - throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno); + throw spdlog_ex("Failed writing to file " + os::filename_to_str(_filename), errno); } size_t size() @@ -112,7 +112,7 @@ public: private: FILE* _fd; - filename_t _filename; + filename_t _filename; }; } } diff --git a/include/spdlog/details/spdlog_impl.h b/include/spdlog/details/spdlog_impl.h index e1bbee2f..a8011db4 100644 --- a/include/spdlog/details/spdlog_impl.h +++ b/include/spdlog/details/spdlog_impl.h @@ -34,50 +34,50 @@ inline void spdlog::register_logger(std::shared_ptr logger) { - return details::registry::instance().register_logger(logger); + return details::registry::instance().register_logger(logger); } inline std::shared_ptr spdlog::get(const std::string& name) { - return details::registry::instance().get(name); + return details::registry::instance().get(name); } inline void spdlog::drop(const std::string &name) { - details::registry::instance().drop(name); + details::registry::instance().drop(name); } // Create multi/single threaded simple file logger inline std::shared_ptr spdlog::basic_logger_mt(const std::string& logger_name, const filename_t& filename, bool truncate) { - return create(logger_name, filename, truncate); + return create(logger_name, filename, truncate); } inline std::shared_ptr spdlog::basic_logger_st(const std::string& logger_name, const filename_t& filename, bool truncate) { - return create(logger_name, filename, truncate); + return create(logger_name, filename, truncate); } // Create multi/single threaded rotating file logger inline std::shared_ptr spdlog::rotating_logger_mt(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files) { - return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files); + return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files); } inline std::shared_ptr spdlog::rotating_logger_st(const std::string& logger_name, const filename_t& filename, size_t max_file_size, size_t max_files) { - return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files); + return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), max_file_size, max_files); } // Create file logger which creates new file at midnight): inline std::shared_ptr spdlog::daily_logger_mt(const std::string& logger_name, const filename_t& filename, int hour, int minute) { - return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute); + return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute); } inline std::shared_ptr spdlog::daily_logger_st(const std::string& logger_name, const filename_t& filename, int hour, int minute) { - return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute); + return create(logger_name, filename, SPDLOG_FILENAME_T("txt"), hour, minute); } @@ -85,78 +85,78 @@ inline std::shared_ptr spdlog::daily_logger_st(const std::string // stdout/stderr loggers // inline std::shared_ptr spdlog::stdout_logger_mt(const std::string& logger_name) -{ - return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_mt::instance()); +{ + return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_mt::instance()); } inline std::shared_ptr spdlog::stdout_logger_st(const std::string& logger_name) { - return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_st::instance()); + return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stdout_sink_st::instance()); } inline std::shared_ptr spdlog::stderr_logger_mt(const std::string& logger_name) { - return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_mt::instance()); + return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_mt::instance()); } inline std::shared_ptr spdlog::stderr_logger_st(const std::string& logger_name) { - return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance()); + return spdlog::details::registry::instance().create(logger_name, spdlog::sinks::stderr_sink_st::instance()); } // // stdout/stderr color loggers // -#ifdef _WIN32 +#ifdef _WIN32 inline std::shared_ptr spdlog::stdout_color_mt(const std::string& logger_name) { - auto sink = std::make_shared(); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(); + return spdlog::details::registry::instance().create(logger_name, sink); } inline std::shared_ptr spdlog::stdout_color_st(const std::string& logger_name) { - auto sink = std::make_shared(); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(); + return spdlog::details::registry::instance().create(logger_name, sink); } inline std::shared_ptr spdlog::stderr_color_mt(const std::string& logger_name) { - auto sink = std::make_shared(); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(); + return spdlog::details::registry::instance().create(logger_name, sink); } inline std::shared_ptr spdlog::stderr_color_st(const std::string& logger_name) { - auto sink = std::make_shared(); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(); + return spdlog::details::registry::instance().create(logger_name, sink); } #else //ansi terminal colors inline std::shared_ptr spdlog::stdout_color_mt(const std::string& logger_name) { - auto sink = std::make_shared(spdlog::sinks::stdout_sink_mt::instance()); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(spdlog::sinks::stdout_sink_mt::instance()); + return spdlog::details::registry::instance().create(logger_name, sink); } inline std::shared_ptr spdlog::stdout_color_st(const std::string& logger_name) { - auto sink = std::make_shared(spdlog::sinks::stdout_sink_st::instance()); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(spdlog::sinks::stdout_sink_st::instance()); + return spdlog::details::registry::instance().create(logger_name, sink); } inline std::shared_ptr spdlog::stderr_color_mt(const std::string& logger_name) { - auto sink = std::make_shared(spdlog::sinks::stderr_sink_mt::instance()); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(spdlog::sinks::stderr_sink_mt::instance()); + return spdlog::details::registry::instance().create(logger_name, sink); } inline std::shared_ptr spdlog::stderr_color_st(const std::string& logger_name) { - auto sink = std::make_shared(spdlog::sinks::stderr_sink_st::instance()); - return spdlog::details::registry::instance().create(logger_name, sink); + auto sink = std::make_shared(spdlog::sinks::stderr_sink_st::instance()); + return spdlog::details::registry::instance().create(logger_name, sink); } #endif @@ -164,82 +164,82 @@ inline std::shared_ptr spdlog::stderr_color_st(const std::string // Create syslog logger inline std::shared_ptr spdlog::syslog_logger(const std::string& logger_name, const std::string& syslog_ident, int syslog_option) { - return create(logger_name, syslog_ident, syslog_option); + return create(logger_name, syslog_ident, syslog_option); } #endif #ifdef __ANDROID__ inline std::shared_ptr spdlog::android_logger(const std::string& logger_name, const std::string& tag) { - return create(logger_name, tag); + return create(logger_name, tag); } #endif // Create and register a logger a single sink inline std::shared_ptr spdlog::create(const std::string& logger_name, const spdlog::sink_ptr& sink) { - return details::registry::instance().create(logger_name, sink); + return details::registry::instance().create(logger_name, sink); } //Create logger with multiple sinks inline std::shared_ptr spdlog::create(const std::string& logger_name, spdlog::sinks_init_list sinks) { - return details::registry::instance().create(logger_name, sinks); + return details::registry::instance().create(logger_name, sinks); } template inline std::shared_ptr spdlog::create(const std::string& logger_name, Args... args) { - sink_ptr sink = std::make_shared(args...); - return details::registry::instance().create(logger_name, { sink }); + sink_ptr sink = std::make_shared(args...); + return details::registry::instance().create(logger_name, { sink }); } template inline std::shared_ptr spdlog::create(const std::string& logger_name, const It& sinks_begin, const It& sinks_end) { - return details::registry::instance().create(logger_name, sinks_begin, sinks_end); + return details::registry::instance().create(logger_name, sinks_begin, sinks_end); } inline void spdlog::set_formatter(spdlog::formatter_ptr f) { - details::registry::instance().formatter(f); + details::registry::instance().formatter(f); } inline void spdlog::set_pattern(const std::string& format_string) { - return details::registry::instance().set_pattern(format_string); + return details::registry::instance().set_pattern(format_string); } inline void spdlog::set_level(level::level_enum log_level) { - return details::registry::instance().set_level(log_level); + return details::registry::instance().set_level(log_level); } inline void spdlog::set_error_handler(log_err_handler handler) { - return details::registry::instance().set_error_handler(handler); + return details::registry::instance().set_error_handler(handler); } inline void spdlog::set_async_mode(size_t queue_size, const async_overflow_policy overflow_policy, const std::function& worker_warmup_cb, const std::chrono::milliseconds& flush_interval_ms, const std::function& worker_teardown_cb) { - details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb); + details::registry::instance().set_async_mode(queue_size, overflow_policy, worker_warmup_cb, flush_interval_ms, worker_teardown_cb); } inline void spdlog::set_sync_mode() { - details::registry::instance().set_sync_mode(); + details::registry::instance().set_sync_mode(); } inline void spdlog::apply_all(std::function)> fun) { - details::registry::instance().apply_all(fun); + details::registry::instance().apply_all(fun); } inline void spdlog::drop_all() { - details::registry::instance().drop_all(); + details::registry::instance().drop_all(); } diff --git a/include/spdlog/sinks/file_sinks.h b/include/spdlog/sinks/file_sinks.h index 550a9bb4..d40499b6 100644 --- a/include/spdlog/sinks/file_sinks.h +++ b/include/spdlog/sinks/file_sinks.h @@ -37,21 +37,21 @@ public: { _file_helper.flush(); } - void set_force_flush(bool force_flush) - { - _force_flush = force_flush; - } + void set_force_flush(bool force_flush) + { + _force_flush = force_flush; + } protected: void _sink_it(const details::log_msg& msg) override { - _file_helper.write(msg); - if(_force_flush) - _file_helper.flush(); + _file_helper.write(msg); + if(_force_flush) + _file_helper.flush(); } private: details::file_helper _file_helper; - bool _force_flush; + bool _force_flush; }; typedef simple_file_sink simple_file_sink_mt; @@ -190,7 +190,7 @@ public: int rotation_minute) : _base_filename(base_filename), _extension(extension), _rotation_h(rotation_hour), - _rotation_m(rotation_minute) + _rotation_m(rotation_minute) { if (rotation_hour < 0 || rotation_hour > 23 || rotation_minute < 0 || rotation_minute > 59) throw spdlog_ex("daily_file_sink: Invalid rotation time in ctor"); diff --git a/include/spdlog/sinks/stdout_sinks.h b/include/spdlog/sinks/stdout_sinks.h index f1f5c812..c05f80dd 100644 --- a/include/spdlog/sinks/stdout_sinks.h +++ b/include/spdlog/sinks/stdout_sinks.h @@ -14,64 +14,64 @@ namespace spdlog { - namespace sinks - { +namespace sinks +{ - template - class stdout_sink: public base_sink - { - using MyType = stdout_sink; - public: - stdout_sink() - {} - static std::shared_ptr instance() - { - static std::shared_ptr instance = std::make_shared(); - return instance; - } +template +class stdout_sink: public base_sink +{ + using MyType = stdout_sink; +public: + stdout_sink() + {} + static std::shared_ptr instance() + { + static std::shared_ptr instance = std::make_shared(); + return instance; + } - void _sink_it(const details::log_msg& msg) override - { - fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stdout); - flush(); - } + void _sink_it(const details::log_msg& msg) override + { + fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stdout); + flush(); + } - void flush() override - { - fflush(stdout); - } - }; + void flush() override + { + fflush(stdout); + } +}; - typedef stdout_sink stdout_sink_st; - typedef stdout_sink stdout_sink_mt; +typedef stdout_sink stdout_sink_st; +typedef stdout_sink stdout_sink_mt; - template - class stderr_sink: public base_sink - { - using MyType = stderr_sink; - public: - stderr_sink() - {} - static std::shared_ptr instance() - { - static std::shared_ptr instance = std::make_shared(); - return instance; - } +template +class stderr_sink: public base_sink +{ + using MyType = stderr_sink; +public: + stderr_sink() + {} + static std::shared_ptr instance() + { + static std::shared_ptr instance = std::make_shared(); + return instance; + } - void _sink_it(const details::log_msg& msg) override - { - fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stderr); - flush(); - } + void _sink_it(const details::log_msg& msg) override + { + fwrite(msg.formatted.data(), sizeof(char), msg.formatted.size(), stderr); + flush(); + } - void flush() override - { - fflush(stderr); - } - }; + void flush() override + { + fflush(stderr); + } +}; - typedef stderr_sink stderr_sink_mt; - typedef stderr_sink stderr_sink_st; - } +typedef stderr_sink stderr_sink_mt; +typedef stderr_sink stderr_sink_st; +} } diff --git a/include/spdlog/sinks/wincolor_sink.h b/include/spdlog/sinks/wincolor_sink.h index a299c763..e73a1ae3 100644 --- a/include/spdlog/sinks/wincolor_sink.h +++ b/include/spdlog/sinks/wincolor_sink.h @@ -16,101 +16,101 @@ namespace spdlog { - namespace sinks - { - /* - * Windows color console sink. Uses WriteConsoleA to write to the console with colors - */ - template - class wincolor_sink: public base_sink - { - public: - const WORD BOLD = FOREGROUND_INTENSITY; - const WORD RED = FOREGROUND_RED; - const WORD CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE; - const WORD WHITE = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; - const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN; +namespace sinks +{ +/* + * Windows color console sink. Uses WriteConsoleA to write to the console with colors + */ +template +class wincolor_sink: public base_sink +{ +public: + const WORD BOLD = FOREGROUND_INTENSITY; + const WORD RED = FOREGROUND_RED; + const WORD CYAN = FOREGROUND_GREEN | FOREGROUND_BLUE; + const WORD WHITE = FOREGROUND_RED | FOREGROUND_GREEN | FOREGROUND_BLUE; + const WORD YELLOW = FOREGROUND_RED | FOREGROUND_GREEN; - wincolor_sink(HANDLE std_handle): out_handle_(std_handle) - { - colors_[level::trace] = CYAN; - colors_[level::debug] = CYAN; - colors_[level::info] = WHITE | BOLD; - colors_[level::warn] = YELLOW | BOLD; - colors_[level::err] = RED | BOLD; // red bold - colors_[level::critical] = BACKGROUND_RED | WHITE | BOLD; // white bold on red background - colors_[level::off] = 0; - } + wincolor_sink(HANDLE std_handle): out_handle_(std_handle) + { + colors_[level::trace] = CYAN; + colors_[level::debug] = CYAN; + colors_[level::info] = WHITE | BOLD; + colors_[level::warn] = YELLOW | BOLD; + colors_[level::err] = RED | BOLD; // red bold + colors_[level::critical] = BACKGROUND_RED | WHITE | BOLD; // white bold on red background + colors_[level::off] = 0; + } - virtual ~wincolor_sink() - { - flush(); - } + virtual ~wincolor_sink() + { + flush(); + } - wincolor_sink(const wincolor_sink& other) = delete; - wincolor_sink& operator=(const wincolor_sink& other) = delete; + wincolor_sink(const wincolor_sink& other) = delete; + wincolor_sink& operator=(const wincolor_sink& other) = delete; - virtual void _sink_it(const details::log_msg& msg) override - { - auto color = colors_[msg.level]; - auto orig_attribs = set_console_attribs(color); - WriteConsoleA(out_handle_, msg.formatted.data(), msg.formatted.size(), nullptr, nullptr); - SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors - } + virtual void _sink_it(const details::log_msg& msg) override + { + auto color = colors_[msg.level]; + auto orig_attribs = set_console_attribs(color); + WriteConsoleA(out_handle_, msg.formatted.data(), msg.formatted.size(), nullptr, nullptr); + SetConsoleTextAttribute(out_handle_, orig_attribs); //reset to orig colors + } - virtual void flush() override - { - // windows console always flushed? - } + virtual void flush() override + { + // windows console always flushed? + } - // change the color for the given level - void set_color(level::level_enum level, WORD color) - { - std::lock_guard lock(_mutex); - colors_[level] = color; - } + // change the color for the given level + void set_color(level::level_enum level, WORD color) + { + std::lock_guard lock(_mutex); + colors_[level] = color; + } - private: - HANDLE out_handle_; - std::map colors_; +private: + HANDLE out_handle_; + std::map colors_; - // set color and return the orig console attributes (for resetting later) - WORD set_console_attribs(WORD attribs) - { - CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; - GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info); - SetConsoleTextAttribute(out_handle_, attribs); - return orig_buffer_info.wAttributes; //return orig attribs - } - }; + // set color and return the orig console attributes (for resetting later) + WORD set_console_attribs(WORD attribs) + { + CONSOLE_SCREEN_BUFFER_INFO orig_buffer_info; + GetConsoleScreenBufferInfo(out_handle_, &orig_buffer_info); + SetConsoleTextAttribute(out_handle_, attribs); + return orig_buffer_info.wAttributes; //return orig attribs + } +}; - // - // windows color console to stdout - // - template - class wincolor_stdout_sink: public wincolor_sink - { - public: - wincolor_stdout_sink():wincolor_sink(GetStdHandle(STD_OUTPUT_HANDLE)) - {} - }; +// +// windows color console to stdout +// +template +class wincolor_stdout_sink: public wincolor_sink +{ +public: + wincolor_stdout_sink():wincolor_sink(GetStdHandle(STD_OUTPUT_HANDLE)) + {} +}; - typedef wincolor_stdout_sink wincolor_stdout_sink_mt; - typedef wincolor_stdout_sink wincolor_stdout_sink_st; +typedef wincolor_stdout_sink wincolor_stdout_sink_mt; +typedef wincolor_stdout_sink wincolor_stdout_sink_st; - // - // windows color console to stderr - // - template - class wincolor_stderr_sink: public wincolor_sink - { - public: - wincolor_stderr_sink():wincolor_sink(GetStdHandle(STD_ERROR_HANDLE)) - {} - }; - - typedef wincolor_stderr_sink wincolor_stderr_sink_mt; - typedef wincolor_stderr_sink wincolor_stderr_sink_st; +// +// windows color console to stderr +// +template +class wincolor_stderr_sink: public wincolor_sink +{ +public: + wincolor_stderr_sink():wincolor_sink(GetStdHandle(STD_ERROR_HANDLE)) + {} +}; - } -} \ No newline at end of file +typedef wincolor_stderr_sink wincolor_stderr_sink_mt; +typedef wincolor_stderr_sink wincolor_stderr_sink_st; + +} +} \ No newline at end of file diff --git a/tests/errors.cpp b/tests/errors.cpp index 04cd97c2..bcbb64ba 100644 --- a/tests/errors.cpp +++ b/tests/errors.cpp @@ -28,7 +28,7 @@ TEST_CASE("custom_error_handler", "[errors]]") prepare_logdir(); std::string filename = "logs/simple_log.txt"; auto logger = spdlog::create("logger", filename, true); - logger->flush_on(spdlog::level::info); + logger->flush_on(spdlog::level::info); logger->set_error_handler([=](const std::string& msg) { throw custom_ex(); diff --git a/tests/file_helper.cpp b/tests/file_helper.cpp index 599c233f..9a4ad603 100644 --- a/tests/file_helper.cpp +++ b/tests/file_helper.cpp @@ -12,7 +12,7 @@ static void write_with_helper(file_helper &helper, size_t howmany) log_msg msg; msg.formatted << std::string(howmany, '1'); helper.write(msg); - helper.flush(); + helper.flush(); } @@ -45,7 +45,7 @@ TEST_CASE("file_helper_exists", "[file_helper::file_exists()]]") { prepare_logdir(); REQUIRE(!file_helper::file_exists(target_filename)); - file_helper helper; + file_helper helper; helper.open(target_filename); REQUIRE(file_helper::file_exists(target_filename)); } @@ -65,7 +65,7 @@ TEST_CASE("file_helper_reopen2", "[file_helper::reopen(false)]]") { prepare_logdir(); size_t expected_size = 14; - file_helper helper; + file_helper helper; helper.open(target_filename); write_with_helper(helper, expected_size); REQUIRE(helper.size() == expected_size); diff --git a/tests/file_log.cpp b/tests/file_log.cpp index ab1d9432..6fa32fa2 100644 --- a/tests/file_log.cpp +++ b/tests/file_log.cpp @@ -23,21 +23,21 @@ TEST_CASE("simple_file_logger", "[simple_logger]]") TEST_CASE("flush_on", "[flush_on]]") { - prepare_logdir(); - std::string filename = "logs/simple_log.txt"; + prepare_logdir(); + std::string filename = "logs/simple_log.txt"; - auto logger = spdlog::create("logger", filename); - logger->set_pattern("%v"); - logger->set_level(spdlog::level::trace); - logger->flush_on(spdlog::level::info); - logger->trace("Should not be flushed"); - REQUIRE(count_lines(filename) == 0); + auto logger = spdlog::create("logger", filename); + logger->set_pattern("%v"); + logger->set_level(spdlog::level::trace); + logger->flush_on(spdlog::level::info); + logger->trace("Should not be flushed"); + REQUIRE(count_lines(filename) == 0); - logger->info("Test message {}", 1); - logger->info("Test message {}", 2); - logger->flush(); - REQUIRE(file_contents(filename) == std::string("Should not be flushed\nTest message 1\nTest message 2\n")); - REQUIRE(count_lines(filename) == 3); + logger->info("Test message {}", 1); + logger->info("Test message {}", 2); + logger->flush(); + REQUIRE(file_contents(filename) == std::string("Should not be flushed\nTest message 1\nTest message 2\n")); + REQUIRE(count_lines(filename) == 3); } TEST_CASE("rotating_file_logger1", "[rotating_logger]]") @@ -45,11 +45,11 @@ TEST_CASE("rotating_file_logger1", "[rotating_logger]]") prepare_logdir(); std::string basename = "logs/rotating_log"; auto logger = spdlog::rotating_logger_mt("logger", basename, 1024, 0); - + for (int i = 0; i < 10; ++i) logger->info("Test message {}", i); - logger->flush(); + logger->flush(); auto filename = basename + ".txt"; REQUIRE(count_lines(filename) == 10); } @@ -111,7 +111,7 @@ TEST_CASE("daily_logger with dateonly calculator", "[daily_logger_dateonly]]") auto logger = spdlog::create("logger", basename, "txt", 0, 0); for (int i = 0; i < 10; ++i) logger->info("Test message {}", i); - logger->flush(); + logger->flush(); auto filename = w.str(); REQUIRE(count_lines(filename) == 10); } @@ -144,8 +144,8 @@ TEST_CASE("daily_logger with custom calculator", "[daily_logger_custom]]") for (int i = 0; i < 10; ++i) logger->info("Test message {}", i); - logger->flush(); - auto filename = w.str(); + logger->flush(); + auto filename = w.str(); REQUIRE(count_lines(filename) == 10); }