/** * @brief Simple example program */ int main () { // Configure the default severity Level of new Channel objects #ifndef NDEBUG Log::Manager::setDefaultLevel(Log::Log::eDebug); #else Log::Manager::setDefaultLevel(Log::Log::eNotice); #endif // Configure the Output objects Log::Config::Vector configList; Log::Config::addOutput(configList, "OutputConsole"); Log::Config::addOutput(configList, "OutputFile"); Log::Config::setOption(configList, "filename", "log.txt"); Log::Config::setOption(configList, "filename_old", "log.old.txt"); Log::Config::setOption(configList, "max_startup_size", "0"); Log::Config::setOption(configList, "max_size", "10000"); #ifdef WIN32 Log::Config::addOutput(configList, "OutputDebug"); #endif // Create a Logger object, using a "Main.Example" Channel Log::Logger logger("Main.Example"); logger.warning() << "NO logs before configure()"; try { // Configure the Log Manager (create the Output objects) Log::Manager::configure(configList); } catch (std::exception& e) { std::cerr << e.what(); } // Test outputs of various kind of variables, and some common stream manipulations. std::string str("string"); unsigned int ui = 123; double dbl = -0.023f; logger.debug() << "Variables ; '" << str << "', '" << ui << "', '" << dbl << "'"; logger.debug() << "Hexa = " << std::hex << 0x75af0 << " test"; logger.debug() << "Deci = " << std::right << std::setfill('0') << std::setw(8) << 76035 << " test"; logger.debug() << "sizeof(logger)=" << sizeof(logger); // Test outputs of various severity Level logger.debug() << "Debug."; logger.info() << "Info."; logger.notice() << "Notice."; logger.warning()<< "Warning."; logger.error() << "Error."; logger.critic() << "Critic."; // Modify the output Level of the underlying Channel, and test various severity Level again logger.setLevel(Log::Log::eWarning); logger.debug() << "NO Debug."; // NO more debug logs logger.info() << "NO Info."; // NO more info logs logger.notice() << "NO Notice."; // NO more notice logs logger.warning()<< "Warning."; logger.error() << "Error."; logger.critic() << "Critic."; // Reset Level of the "Main.example" channel by its name Log::Manager::get("Main.Example")->setLevel(Log::Log::eDebug); // Create other loggers, sharing the "Main.Example" Channel, and creating a new one Log::Logger logger2("Main.Example"); Log::Logger logger3("Main.Other"); logger.debug() << "First logger to the Channel"; logger2.debug() << "Second logger to the Channel"; logger3.debug() << "Third logger, other Channel"; // Modify the Level of the "Main.example" channel by its name Log::Manager::get("Main.Example")->setLevel(Log::Log::eInfo); logger.debug() << "first logger inhibited"; // NO more debug logs for this logger logger2.debug() << "second logger also disabled"; // NO more debug logs (sharing the same underlying channel) logger3.debug() << "third logger still active"; // Reset the Level of the "Main.example" channel by its name Log::Manager::get("Main.Example")->setLevel(Log::Log::eDebug); logger.debug() << "first logger re-activated"; logger2.debug() << "second logger also re-activated"; logger3.debug() << "third logger always active"; // Create an object using a Logger as member variable Tester tester; tester.constTest(); // Show how to get the current Channel configuration (to save it to a file, for instance) Log::Manager::get("Main.OtherChannel")->setLevel(Log::Log::eNotice); Log::Config::Ptr ChannelConfigPtr = Log::Manager::getChannelConfig(); // Show how to set the current Channel configuration (restored from a file, for instance) Log::Manager::setChannelConfig(ChannelConfigPtr); // Terminate the Log Manager (destroy the Output objects) Log::Manager::terminate(); logger.warning() << "NO more logs after terminate()"; return 0; }
CXXCAPI int unittestLogger(void) { Print printf(Platform::instance().output()); Print errorf(Platform::instance().error()); int errors = 0; printf("%s[%d]: begin\n", __FILE__, __LINE__); ::staticLogger.show(); printf("%s[%d]: level\n", __FILE__, __LINE__); errors += leveltest("%s[%d]", __FILE__, __LINE__); printf("%s[%d]: default\n", __FILE__, __LINE__); ssize_t rc; Logger logger1; logger1.show(); #define DESPERADO_LOGGER_TEST_1(_FUNCTION_) \ rc = logger1._FUNCTION_("%s[%d]: %s %s\n", \ __FILE__, __LINE__, "logger1", #_FUNCTION_); \ if (0 >= rc) { \ errorf("%s[%d]: (%d>%d)!\n", \ __FILE__, __LINE__, 0, rc); \ ++errors; \ } DESPERADO_LOGGER_TEST_1(finest) DESPERADO_LOGGER_TEST_1(finer) DESPERADO_LOGGER_TEST_1(fine) DESPERADO_LOGGER_TEST_1(trace) DESPERADO_LOGGER_TEST_1(debug) DESPERADO_LOGGER_TEST_1(information) DESPERADO_LOGGER_TEST_1(configuration) DESPERADO_LOGGER_TEST_1(notice) DESPERADO_LOGGER_TEST_1(warning) DESPERADO_LOGGER_TEST_1(error) DESPERADO_LOGGER_TEST_1(severe) DESPERADO_LOGGER_TEST_1(critical) DESPERADO_LOGGER_TEST_1(alert) DESPERADO_LOGGER_TEST_1(fatal) DESPERADO_LOGGER_TEST_1(emergency) DESPERADO_LOGGER_TEST_1(print) printf("%s[%d]: platform\n", __FILE__, __LINE__); Logger& logger2 = Platform::instance().logger(); logger2.show(); #define DESPERADO_LOGGER_TEST_2(_FUNCTION_) \ rc = logger2._FUNCTION_("%s[%d]: %s %s\n", \ __FILE__, __LINE__, "logger2", #_FUNCTION_); \ if (0 >= rc) { \ errorf("%s[%d]: (%d>%d)!\n", \ __FILE__, __LINE__, 0, rc); \ ++errors; \ } DESPERADO_LOGGER_TEST_2(finest) DESPERADO_LOGGER_TEST_2(finer) DESPERADO_LOGGER_TEST_2(fine) DESPERADO_LOGGER_TEST_2(trace) DESPERADO_LOGGER_TEST_2(debug) DESPERADO_LOGGER_TEST_2(information) DESPERADO_LOGGER_TEST_2(configuration) DESPERADO_LOGGER_TEST_2(notice) DESPERADO_LOGGER_TEST_2(warning) DESPERADO_LOGGER_TEST_2(error) DESPERADO_LOGGER_TEST_2(severe) DESPERADO_LOGGER_TEST_2(critical) DESPERADO_LOGGER_TEST_2(alert) DESPERADO_LOGGER_TEST_2(fatal) DESPERADO_LOGGER_TEST_2(emergency) DESPERADO_LOGGER_TEST_2(print) printf("%s[%d]: output\n", __FILE__, __LINE__); Logger logger3(Platform::instance().output()); logger3.show(); #define DESPERADO_LOGGER_TEST_3(_FUNCTION_) \ rc = logger2._FUNCTION_("%s[%d]: %s %s\n", \ __FILE__, __LINE__, "logger3", #_FUNCTION_); \ if (0 >= rc) { \ errorf("%s[%d]: (%d>%d)!\n", \ __FILE__, __LINE__, 0, rc); \ ++errors; \ } DESPERADO_LOGGER_TEST_3(finest) DESPERADO_LOGGER_TEST_3(finer) DESPERADO_LOGGER_TEST_3(fine) DESPERADO_LOGGER_TEST_3(trace) DESPERADO_LOGGER_TEST_3(debug) DESPERADO_LOGGER_TEST_3(information) DESPERADO_LOGGER_TEST_3(configuration) DESPERADO_LOGGER_TEST_3(notice) DESPERADO_LOGGER_TEST_3(warning) DESPERADO_LOGGER_TEST_3(error) DESPERADO_LOGGER_TEST_3(severe) DESPERADO_LOGGER_TEST_3(critical) DESPERADO_LOGGER_TEST_3(alert) DESPERADO_LOGGER_TEST_3(fatal) DESPERADO_LOGGER_TEST_3(emergency) DESPERADO_LOGGER_TEST_3(print) printf("%s[%d]: cxxcapi\n", __FILE__, __LINE__); Logger* logger4 = platform_logger(); logger4->show(); #define DESPERADO_LOGGER_TEST_4(_FUNCTION_) \ rc = logger_##_FUNCTION_(logger4, "%s[%d]: %s %s\n", \ __FILE__, __LINE__, "logger4", #_FUNCTION_); \ if (0 >= rc) { \ errorf("%s[%d]: (%d>%d)!\n", \ __FILE__, __LINE__, 0, rc); \ ++errors; \ } DESPERADO_LOGGER_TEST_4(finest) DESPERADO_LOGGER_TEST_4(finer) DESPERADO_LOGGER_TEST_4(fine) DESPERADO_LOGGER_TEST_4(trace) DESPERADO_LOGGER_TEST_4(debug) DESPERADO_LOGGER_TEST_4(information) DESPERADO_LOGGER_TEST_4(configuration) DESPERADO_LOGGER_TEST_4(notice) DESPERADO_LOGGER_TEST_4(warning) DESPERADO_LOGGER_TEST_4(error) DESPERADO_LOGGER_TEST_4(severe) DESPERADO_LOGGER_TEST_4(critical) DESPERADO_LOGGER_TEST_4(alert) DESPERADO_LOGGER_TEST_4(fatal) DESPERADO_LOGGER_TEST_4(emergency) DESPERADO_LOGGER_TEST_4(print) printf("%s[%d]: log\n", __FILE__, __LINE__); Logger logger5; logger5.show(); #define DESPERADO_LOGGER_TEST_5(_LEVEL_) \ rc = logger5.log(Logger::_LEVEL_, "%s[%d]: %s %s\n", \ __FILE__, __LINE__, "logger5", #_LEVEL_); \ if (0 >= rc) { \ errorf("%s[%d]: (%d>%d)!\n", \ __FILE__, __LINE__, 0, rc); \ ++errors; \ } DESPERADO_LOGGER_TEST_5(FINEST) DESPERADO_LOGGER_TEST_5(FINER) DESPERADO_LOGGER_TEST_5(FINE) DESPERADO_LOGGER_TEST_5(TRACE) DESPERADO_LOGGER_TEST_5(DEBUG) DESPERADO_LOGGER_TEST_5(INFORMATION) DESPERADO_LOGGER_TEST_5(CONFIGURATION) DESPERADO_LOGGER_TEST_5(NOTICE) DESPERADO_LOGGER_TEST_5(WARNING) DESPERADO_LOGGER_TEST_5(ERROR) DESPERADO_LOGGER_TEST_5(SEVERE) DESPERADO_LOGGER_TEST_5(CRITICAL) DESPERADO_LOGGER_TEST_5(ALERT) DESPERADO_LOGGER_TEST_5(FATAL) DESPERADO_LOGGER_TEST_5(EMERGENCY) DESPERADO_LOGGER_TEST_5(PRINT) Logger logger7; #define KERN_EMERG "<0>" #define KERN_ALERT "<1>" #define KERN_CRIT "<2>" #define KERN_ERR "<3>" #define KERN_WARNING "<4>" #define KERN_NOTICE "<5>" #define KERN_INFO "<6>" #define KERN_DEBUG "<7>" #define DESPERADO_LOGGER_TEST_7(_LEVEL_, _KERNEL_) { \ const char * message = _KERNEL_ #_KERNEL_; \ size_t level; \ logger7.level(message, std::strlen(message), level); \ if (static_cast<size_t>(Logger::_LEVEL_) != level) { \ errorf("%s[%d]: (%d!=%u)!\n", __FILE__, __LINE__, Logger::_LEVEL_, level); \ ++errors; \ } else { \ printf("%s[%d]: \"%s\" %u %s\n", __FILE__, __LINE__, message, level, Logger::labels[level]); \ } \ } DESPERADO_LOGGER_TEST_7(EMERGENCY, KERN_EMERG); DESPERADO_LOGGER_TEST_7(ALERT, KERN_ALERT); DESPERADO_LOGGER_TEST_7(CRITICAL, KERN_CRIT); DESPERADO_LOGGER_TEST_7(ERROR, KERN_ERR); DESPERADO_LOGGER_TEST_7(WARNING, KERN_WARNING); DESPERADO_LOGGER_TEST_7(NOTICE, KERN_NOTICE); DESPERADO_LOGGER_TEST_7(INFORMATION, KERN_INFO); DESPERADO_LOGGER_TEST_7(DEBUG, KERN_DEBUG); FileOutput file(stderr); Logger logger8; LogOutput output(file); Logger newlogger8(output); logger8 = newlogger8; logger8.show(); #define DESPERADO_LOGGER_TEST_8(_FUNCTION_) \ rc = logger8._FUNCTION_("%s[%d]: %s %s\n", \ __FILE__, __LINE__, "logger8", #_FUNCTION_); \ if (0 >= rc) { \ errorf("%s[%d]: (%d>%d)!\n", \ __FILE__, __LINE__, 0, rc); \ ++errors; \ } DESPERADO_LOGGER_TEST_8(finest) DESPERADO_LOGGER_TEST_8(finer) DESPERADO_LOGGER_TEST_8(fine) DESPERADO_LOGGER_TEST_8(trace) DESPERADO_LOGGER_TEST_8(debug) DESPERADO_LOGGER_TEST_8(information) DESPERADO_LOGGER_TEST_8(configuration) DESPERADO_LOGGER_TEST_8(notice) DESPERADO_LOGGER_TEST_8(warning) DESPERADO_LOGGER_TEST_8(error) DESPERADO_LOGGER_TEST_8(severe) DESPERADO_LOGGER_TEST_8(critical) DESPERADO_LOGGER_TEST_8(alert) DESPERADO_LOGGER_TEST_8(fatal) DESPERADO_LOGGER_TEST_8(emergency) DESPERADO_LOGGER_TEST_8(print) printf("%s[%d]: end errors=%d\n", __FILE__, __LINE__, errors); return errors; }