diff --git a/lib/include/bofstd/basic_loggerfactory.h b/lib/include/bofstd/basic_loggerfactory.h index 61aed2e..cec749a 100644 --- a/lib/include/bofstd/basic_loggerfactory.h +++ b/lib/include/bofstd/basic_loggerfactory.h @@ -16,19 +16,19 @@ #pragma once #include #include +#include +#include #include -#include +#include -BEGIN_HWFWLOG_NAMESPACE() -class BasicLogger : public HWFWLOG::ILogger +BEGIN_BOF_NAMESPACE() +class BasicLogger : public BOF::IBofLogger { public: - BasicLogger(const uint32_t _ChannelIndex_U32, const std::string &_rChannelName_S) - : HWFWLOG::ILogger() + BasicLogger(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) : BOF::IBofLogger() { - mChannelIndex_U32 = _ChannelIndex_U32; - mChannelName_S = _rChannelName_S; - Configure(false, ""); + mChannelName_S = _rLibNamePrefix_S + _rLoggerChannelName_S; + Configure(false, ""); } virtual ~BasicLogger() { @@ -57,7 +57,7 @@ class BasicLogger : public HWFWLOG::ILogger t = std::time(nullptr); std::strftime(pDateTime_c, sizeof(pDateTime_c), "%Y-%m-%d %H:%M:%S", std::localtime(&t)); - sprintf(pHeader_c, "%s: %zd Channel[%d][%s]->", pDateTime_c, DeltaInuS, mChannelIndex_U32, mChannelName_S.c_str()); + sprintf(pHeader_c, "%s: %zd [%s]->", pDateTime_c, DeltaInuS, mChannelName_S.c_str()); if (mOutputOnScreen_B) { printf("%s%s", pHeader_c, pLog_c); @@ -69,8 +69,9 @@ class BasicLogger : public HWFWLOG::ILogger } } } - void Configure(bool _OutputOnScreen_B, const std::string &_rLogFileSubDir_S) + bool Configure(bool _OutputOnScreen_B, const std::string &_rLogFileSubDir_S) { + bool Rts_B = true; char pLogFile_c[512]; mOutputOnScreen_B = _OutputOnScreen_B; @@ -80,82 +81,91 @@ class BasicLogger : public HWFWLOG::ILogger } else { - sprintf(pLogFile_c, "%s/%s_%03d.log", _rLogFileSubDir_S.c_str(), mChannelName_S.c_str(), mChannelIndex_U32); + sprintf(pLogFile_c, "%s/%s.log", _rLogFileSubDir_S.c_str(), mChannelName_S.c_str()); mpLogFile_X = fopen(pLogFile_c, "w+"); + if (mpLogFile_X == nullptr) + { + Rts_B = false; + } } + return Rts_B; } private: - uint32_t mChannelIndex_U32 = 0; std::string mChannelName_S; - const std::chrono::time_point mLogEpoch=std::chrono::high_resolution_clock::now(); + const std::chrono::time_point mLogEpoch = std::chrono::high_resolution_clock::now(); bool mOutputOnScreen_B = false; FILE *mpLogFile_X = nullptr; }; -class BasicLoggerFactory : public HWFWLOG::ILoggerFactory +class BasicLoggerFactory : public BOF::ILoggerFactory { public: - BasicLoggerFactory(bool _OutputOnScreen_B, const std::string &_rLogFileSubDir_S) - : mOutputOnScreen_B(_OutputOnScreen_B), mLogFileSubDir_S(_rLogFileSubDir_S) + BasicLoggerFactory(bool _OutputOnScreen_B, const std::string &_rLogFileSubDir_S) : mOutputOnScreen_B(_OutputOnScreen_B), mLogFileSubDir_S(_rLogFileSubDir_S) { } virtual ~BasicLoggerFactory() = default; - std::shared_ptr V_Create(const uint32_t _ChannelIndex_U32, const uint32_t _MaxChannelIndex_U32, const std::string &_rChannelName_S) override + std::string BuildChannelName(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) + { + return _rLibNamePrefix_S + _rLoggerChannelName_S; + } + std::shared_ptr V_Create(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) override { std::shared_ptr psRts = nullptr; - uint32_t i_U32; + std::string ChannelName_S; - if (_ChannelIndex_U32 < _MaxChannelIndex_U32) + std::lock_guard Lock(mLoggerCollectionMtx); + if (V_GetLogger(_rLibNamePrefix_S, _rLoggerChannelName_S) == nullptr) { - if (mLoggerCollection.size() != _MaxChannelIndex_U32) + psRts = std::make_shared(_rLibNamePrefix_S, _rLoggerChannelName_S); + if (psRts) { - mLoggerCollection.clear(); - for (i_U32 = 0; i_U32 < _MaxChannelIndex_U32; i_U32++) + if (psRts->Configure(mOutputOnScreen_B, mLogFileSubDir_S)) { - mLoggerCollection.push_back(nullptr); + ChannelName_S = BuildChannelName(_rLibNamePrefix_S, _rLoggerChannelName_S); + mLoggerCollection[ChannelName_S] = psRts; + } + else + { + psRts = nullptr; } - } - psRts = std::make_shared(_ChannelIndex_U32, _rChannelName_S); - if (psRts) - { - psRts->Configure(mOutputOnScreen_B, mLogFileSubDir_S); - mLoggerCollection[_ChannelIndex_U32] = psRts; } } return psRts; } - bool V_SetLogSeverityLevel(const uint32_t _ChannelIndex_U32, HWFWLOG::ILogger::LogSeverity _SeverityLevel_E) override + std::shared_ptr V_GetLogger(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) override { - bool Rts_B = false; - - if (_ChannelIndex_U32 < mLoggerCollection.size()) + std::shared_ptr psRts = nullptr; + std::string ChannelName_S; + // no mutex as it is used by V_Create and V_Destroy + ChannelName_S = BuildChannelName(_rLibNamePrefix_S, _rLoggerChannelName_S); + auto It = mLoggerCollection.find(ChannelName_S); + if (It != mLoggerCollection.end()) { - if (mLoggerCollection[_ChannelIndex_U32]) - { - Rts_B = mLoggerCollection[_ChannelIndex_U32]->SetLogSeverityLevel(_SeverityLevel_E); - } + psRts = It->second; } - return Rts_B; + return psRts; } - HWFWLOG::ILogger::LogSeverity V_GetLogSeverityLevel(const uint32_t _ChannelIndex_U32) const override + bool V_Destroy(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) override { - HWFWLOG::ILogger::LogSeverity Rts_E = HWFWLOG::ILogger::LogSeverity::LOG_SEVERITY_MAX; + bool Rts_B = false; + std::string ChannelName_S; - if (_ChannelIndex_U32 < mLoggerCollection.size()) + std::lock_guard Lock(mLoggerCollectionMtx); + if (V_GetLogger(_rLibNamePrefix_S, _rLoggerChannelName_S) != nullptr) { - if (mLoggerCollection[_ChannelIndex_U32]) - { - Rts_E = mLoggerCollection[_ChannelIndex_U32]->GetLogSeverityLevel(); - } + ChannelName_S = BuildChannelName(_rLibNamePrefix_S, _rLoggerChannelName_S); + mLoggerCollection.erase(ChannelName_S); + Rts_B = true; } - return Rts_E; + return Rts_B; } private: - std::vector> mLoggerCollection; + std::mutex mLoggerCollectionMtx; + std::map> mLoggerCollection; bool mOutputOnScreen_B; const std::string mLogFileSubDir_S; }; -END_HWFWLOG_NAMESPACE() +END_BOF_NAMESPACE() diff --git a/lib/include/bofstd/ibofloggerfactory.h b/lib/include/bofstd/ibofloggerfactory.h index dfe1a8b..53bb9f0 100644 --- a/lib/include/bofstd/ibofloggerfactory.h +++ b/lib/include/bofstd/ibofloggerfactory.h @@ -6,7 +6,7 @@ * IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A PARTICULAR * PURPOSE. * - * This module define the different logger interfaces + * This module define the a logger factory to manage logger instance * * Author: Bernard HARMEL: b.harmel@evs.com * @@ -14,11 +14,14 @@ * V 1.00 Feb 19 2024 BHA : Initial release */ #pragma once -#include #include +#include +#include +#include -BEGIN_BOF_NAMESPACE() +#include "bofstd/bofstd.h" +BEGIN_BOF_NAMESPACE() class IBofLogger { public: @@ -58,270 +61,43 @@ class IBofLogger LogSeverity mLogSeverityLevel_E = LogSeverity::LOG_SEVERITY_MAX; }; -class IBofLoggerFactory +class ILoggerFactory { public: - virtual ~IBofLoggerFactory() = default; - virtual std::shared_ptr V_Create(const uint32_t _ChannelIndex_U32, const uint32_t _MaxChannelIndex_U32, const std::string &_rChannelName_S) = 0; - virtual bool V_SetLogSeverityLevel(const uint32_t _ChannelIndex_U32, IBofLogger::LogSeverity _SeverityLevel_E) = 0; - virtual IBofLogger::LogSeverity V_GetLogSeverityLevel(const uint32_t _ChannelIndex_U32) const = 0; -}; - -struct BOF_LOGGER_FACTORY_STORAGE -{ - uint32_t NbMaxChannel_U32; - std::vector> LoggerCollection; - BOF_LOGGER_FACTORY_STORAGE(uint32_t _NbMaxChannel_U32) - { - NbMaxChannel_U32 = _NbMaxChannel_U32; - Reset(); - } - void Reset() - { - uint32_t i_U32; - LoggerCollection.clear(); - LoggerCollection.reserve(NbMaxChannel_U32); - for (i_U32 = 0; i_U32 < NbMaxChannel_U32; i_U32++) - { - LoggerCollection.push_back(nullptr); - } - } + ILoggerFactory() = default; + virtual ~ILoggerFactory() = default; + virtual std::shared_ptr V_Create(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) = 0; + virtual std::shared_ptr V_GetLogger(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) = 0; + virtual bool V_Destroy(const std::string &_rLibNamePrefix_S, const std::string &_rLoggerChannelName_S) = 0; }; -// #define MY_LOGGER TheBhaLogger -// BOF_LOGGER_DEFINE_STORAGE(MY_LOGGER, LOGGER_CHANNEL_MAX); -//==>define BOF::BOF_LOGGER_FACTORY_STORAGE GL_LoggerStorage_TheBhaLogger(LOGGER_CHANNEL_MAX) -#define BOF_LOGGER_STORAGE_NAME(name) GL_LoggerStorage_##name -#define BOF_LOGGER_DEFINE_STORAGE(name, nbmaxchannel) BOF::BOF_LOGGER_FACTORY_STORAGE BOF_LOGGER_STORAGE_NAME(name)(nbmaxchannel) -#define BOF_LOGGER_FACTORY_ADD(name, logger, channel, sts) \ - if (channel < BOF_LOGGER_STORAGE_NAME(name).NbMaxChannel_U32) \ - { \ - BOF_LOGGER_STORAGE_NAME(name).LoggerCollection[channel] = logger; \ - sts = true; \ - } \ - else \ - { \ - sts = false; \ - } -#define BOF_LOGGER_FACTORY_GET(name, channel, logger) \ - if (channel < BOF_LOGGER_STORAGE_NAME(name).NbMaxChannel_U32) \ - { \ - logger = BOF_LOGGER_STORAGE_NAME(name).LoggerCollection[channel]; \ - } \ - else \ - { \ - logger = nullptr; \ - } -// The first if could be replaced by assert...???... -#define BOF_LOGGER_LOG(name, channel, level, format, ...) \ - if (channel < BOF_LOGGER_STORAGE_NAME(name).NbMaxChannel_U32) \ - { \ - if (BOF_LOGGER_STORAGE_NAME(name).LoggerCollection[channel]) \ - { \ - if (level <= BOF_LOGGER_STORAGE_NAME(name).LoggerCollection[channel]->GetLogSeverityLevel()) \ - { \ - BOF_LOGGER_STORAGE_NAME(name).LoggerCollection[channel]->V_Log(level, format, ##__VA_ARGS__); \ - BOF_LOGGER_STORAGE_NAME(name).LoggerCollection[channel]->mNbLogOut_U32++; \ - } \ - else \ - { \ - BOF_LOGGER_STORAGE_NAME(name).LoggerCollection[channel]->mNbLogRejected_U32++; \ - } \ - } \ +#define LOGGER_LOG(psLogger, level, format, ...) \ + if (psLogger) \ + { \ + if (level <= psLogger->GetLogSeverityLevel()) \ + { \ + psLogger->V_Log(level, format, ##__VA_ARGS__); \ + psLogger->mNbLogOut_U32++; \ + } \ + else \ + { \ + psLogger->mNbLogRejected_U32++; \ + } \ } -#ifdef BOF_LOGGER_FACTORY_DISABLE -#define BOF_LOG_FORCE(name, channel, format, ...) -#define BOF_LOG_ERROR(name, channel, format, ...) -#define BOF_LOG_WARNING(name, channel, format, ...) -#define BOF_LOG_INFO(name, channel, format, ...) -#define BOF_LOG_VERBOSE(name, channel, format, ...) -#define BOF_LOG_DEBUG(name, channel, format, ...) +#ifdef LOGGER_FACTORY_DISABLE_LOGGING +#define LOG_FORCE(psLogger, format, ...) +#define LOG_ERROR(psLogger, format, ...) +#define LOG_WARNING(psLogger, format, ...) +#define LOG_INFO(psLogger, format, ...) +#define LOG_VERBOSE(psLogger, format, ...) +#define LOG_DEBUG(psLogger, format, ...) #else -#define BOF_LOG_FORCE(name, channel, format, ...) BOF_LOGGER_LOG(name, channel, BOF::IBofLogger::LOG_SEVERITY_FORCE, format, ##__VA_ARGS__) -#define BOF_LOG_ERROR(name, channel, format, ...) BOF_LOGGER_LOG(name, channel, BOF::IBofLogger::LOG_SEVERITY_ERROR, format, ##__VA_ARGS__) -#define BOF_LOG_WARNING(name, channel, format, ...) BOF_LOGGER_LOG(name, channel, BOF::IBofLogger::LOG_SEVERITY_WARNING, format, ##__VA_ARGS__) -#define BOF_LOG_INFO(name, channel, format, ...) BOF_LOGGER_LOG(name, channel, BOF::IBofLogger::LOG_SEVERITY_INFO, format, ##__VA_ARGS__) -#define BOF_LOG_VERBOSE(name, channel, format, ...) BOF_LOGGER_LOG(name, channel, BOF::IBofLogger::LOG_SEVERITY_VERBOSE, format, ##__VA_ARGS__) -#define BOF_LOG_DEBUG(name, channel, format, ...) BOF_LOGGER_LOG(name, channel, BOF::IBofLogger::LOG_SEVERITY_DEBUG, format, ##__VA_ARGS__) +#define LOG_FORCE(psLogger, format, ...) LOGGER_LOG(psLogger, BOF::IBofLogger::LOG_SEVERITY_FORCE, format, ##__VA_ARGS__) +#define LOG_ERROR(psLogger, format, ...) LOGGER_LOG(psLogger, BOF::IBofLogger::LOG_SEVERITY_ERROR, format, ##__VA_ARGS__) +#define LOG_WARNING(psLogger, format, ...) LOGGER_LOG(psLogger, BOF::IBofLogger::LOG_SEVERITY_WARNING, format, ##__VA_ARGS__) +#define LOG_INFO(psLogger, format, ...) LOGGER_LOG(psLogger, BOF::IBofLogger::LOG_SEVERITY_INFO, format, ##__VA_ARGS__) +#define LOG_VERBOSE(psLogger, format, ...) LOGGER_LOG(psLogger, BOF::IBofLogger::LOG_SEVERITY_VERBOSE, format, ##__VA_ARGS__) +#define LOG_DEBUG(psLogger, format, ...) LOGGER_LOG(psLogger, BOF::IBofLogger::LOG_SEVERITY_DEBUG, format, ##__VA_ARGS__) #endif END_BOF_NAMESPACE() - -// Usage example: -#if 0 -//*********** In the app ****************************************************************************************** - -#include -#include -#include - -BEGIN_UCO_NAMESPACE() - -class Logger : public BOF::IBofLogger -{ -public: - Logger(const uint32_t _ChannelIndex_U32, const std::string &_rChannelName_S) - : BOF::IBofLogger() - { - char pLogFile_c[256]; - - mChannelIndex_U32 = _ChannelIndex_U32; - mChannelName_S = _rChannelName_S; - - sprintf(pLogFile_c, "%s_%03d.log", _rChannelName_S.c_str(), mChannelIndex_U32); - mpLogFile_X = fopen(pLogFile_c, "w+"); - } - virtual ~Logger() - { - if (mpLogFile_X) - { - fclose(mpLogFile_X); - mpLogFile_X = nullptr; - } - } - void V_Log(LogSeverity _SeverityLevel_E, const char *_pLogMessage_c, ...) override - { - char pLog_c[0x1000]; - va_list VaList_X; - - va_start(VaList_X, _pLogMessage_c); - vsnprintf(pLog_c, sizeof(pLog_c), _pLogMessage_c, VaList_X); - va_end(VaList_X); - - pLog_c[sizeof(pLog_c) - 1] = 0; - printf("Channel[%d][%s]->%s", mChannelIndex_U32, mChannelName_S.c_str(), pLog_c); - fwrite(pLog_c, strlen(pLog_c), 1, mpLogFile_X); - } - -private: - uint32_t mChannelIndex_U32 = 0; - std::string mChannelName_S; - FILE *mpLogFile_X = nullptr; -}; - -class LoggerFactory : public BOF::IBofLoggerFactory -{ -public: - LoggerFactory() = default; - virtual ~LoggerFactory() = default; - - std::shared_ptr V_Create(const uint32_t _ChannelIndex_U32, const uint32_t _MaxChannelIndex_U32, const std::string &_rChannelName_S) override - { - std::shared_ptr psRts = nullptr; - uint32_t i_U32; - - if (_ChannelIndex_U32 < _MaxChannelIndex_U32) - { - if (mLoggerCollection.size() != _MaxChannelIndex_U32) - { - mLoggerCollection.clear(); - for (i_U32 = 0; i_U32 < _MaxChannelIndex_U32; i_U32++) - { - mLoggerCollection.push_back(nullptr); - } - } - psRts = std::make_shared(_ChannelIndex_U32, _rChannelName_S); - mLoggerCollection[_ChannelIndex_U32] = psRts; - } - return psRts; - } - bool V_SetLogSeverityLevel(const uint32_t _ChannelIndex_U32, BOF::IBofLogger::LogSeverity _SeverityLevel_E) override - { - bool Rts_B = false; - - if (_ChannelIndex_U32 < mLoggerCollection.size()) - { - if (mLoggerCollection[_ChannelIndex_U32]) - { - Rts_B = mLoggerCollection[_ChannelIndex_U32]->SetLogSeverityLevel(_SeverityLevel_E); - } - } - return Rts_B; - } - BOF::IBofLogger::LogSeverity V_GetLogSeverityLevel(const uint32_t _ChannelIndex_U32) const override - { - BOF::IBofLogger::LogSeverity Rts_E = BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX; - - if (_ChannelIndex_U32 < mLoggerCollection.size()) - { - if (mLoggerCollection[_ChannelIndex_U32]) - { - Rts_E = mLoggerCollection[_ChannelIndex_U32]->GetLogSeverityLevel(); - } - } - return Rts_E; - } - -private: - std::vector> mLoggerCollection; -}; - -END_UCO_NAMESPACE() - -int main(int _Argc_i, char *_pArgv_c[]) -{ - int Rts_i = 0; - std::shared_ptr psLoggerFactory = std::make_shared(); - GLF::GlfInit(psLoggerFactory); - psLoggerFactory->V_SetLogSeverityLevel(GLF::LOGGER_CHANNEL_INIT, BOF::IBofLogger::LOG_SEVERITY_DEBUG); - psLoggerFactory->V_SetLogSeverityLevel(GLF::LOGGER_CHANNEL_CODEC, BOF::IBofLogger::LOG_SEVERITY_DEBUG); - psLoggerFactory->V_SetLogSeverityLevel(GLF::LOGGER_CHANNEL_DMA, BOF::IBofLogger::LOG_SEVERITY_DEBUG); - - GLF::GlfFct(); - - return Rts_i; -} -//*********** In the lib ****************************************************************************************** -//*** .h: -BEGIN_GLF_NAMESPACE() -enum LOGGER_CHANNEL : uint32_t -{ - LOGGER_CHANNEL_INIT = 0, - LOGGER_CHANNEL_CODEC, - LOGGER_CHANNEL_DMA, - LOGGER_CHANNEL_MAX -}; -#define MY_LOGGER TheBhaLogger -#define WLOG(channel, ...) BOF_LOG_WARNING(MY_LOGGER, channel, ##__VA_ARGS__); - -bool GlfInit(std::shared_ptr _psLoggerFactory); -void GlfFct(); - -END_GLF_NAMESPACE() - -//*** .cpp -BEGIN_GLF_NAMESPACE() - -BOF_LOGGER_DEFINE_STORAGE(MY_LOGGER, LOGGER_CHANNEL_MAX); - -bool GlfInit(std::shared_ptr _psLoggerFactory) -{ - bool Rts_B = false; - std::shared_ptr psLogger; - - if (_psLoggerFactory) - { - psLogger = _psLoggerFactory->V_Create(LOGGER_CHANNEL_INIT, LOGGER_CHANNEL_MAX, "INIT"); - BOF_LOGGER_FACTORY_ADD(MY_LOGGER, psLogger, LOGGER_CHANNEL_INIT, Rts_B); - - psLogger = _psLoggerFactory->V_Create(LOGGER_CHANNEL_CODEC, LOGGER_CHANNEL_MAX, "CODEC"); - BOF_LOGGER_FACTORY_ADD(MY_LOGGER, psLogger, LOGGER_CHANNEL_CODEC, Rts_B); - - psLogger = _psLoggerFactory->V_Create(LOGGER_CHANNEL_DMA, LOGGER_CHANNEL_MAX, "DMA"); - BOF_LOGGER_FACTORY_ADD(MY_LOGGER, psLogger, LOGGER_CHANNEL_DMA, Rts_B); - } - BOF_LOG_WARNING(MY_LOGGER, LOGGER_CHANNEL_INIT, "Log me Rts %d Ptr %p\n", Rts_B, psLogger.get()); - - return Rts_B; -} - -void GlfFct() -{ - int i = 1; - WLOG(LOGGER_CHANNEL_INIT, "Warning from init, i is %d\n", i++); - WLOG(LOGGER_CHANNEL_CODEC, "Warning from codec, i is %d\n", i++); - WLOG(LOGGER_CHANNEL_DMA, "Warning from dma, i is %d\n", i++); -} -END_GLF_NAMESPACE() - -#endif \ No newline at end of file diff --git a/tests/src/ut_logger.cpp b/tests/src/ut_logger.cpp index 118e66f..e36b9ba 100644 --- a/tests/src/ut_logger.cpp +++ b/tests/src/ut_logger.cpp @@ -19,12 +19,15 @@ * * V 1.00 Dec 26 2013 BHA : Initial release */ +#include + #include "bofstd/boffs.h" #include "bofstd/bofsocket.h" #include #include #include #include +#include #include "gtestrunner.h" @@ -275,293 +278,103 @@ TEST_F(Logger_Test, LoggerInit) } + //*** External lib code ********************************************************************* - -//*** External lib code ********************************************************************* -#define MY_UT_SINGLE_LOGGER MyExternalSingleChannelLibInit -BOF_LOGGER_DEFINE_STORAGE(MY_UT_SINGLE_LOGGER, 1); -/* -#define WUTLOG(channel, ...) BOF_LOG_WARNING(MY_LOGGER, channel, ##__VA_ARGS__); -#define MY_LOGGER TheBhaLogger -LOGGER_DEFINE_STORAGE(MY_LOGGER, LOGGER_CHANNEL_MAX); -*/ -constexpr uint32_t MAX_MULTI_CHANNEL = 3; -#define MY_UT_MULTI_LOGGER MyExternalMultipleChannelLibLogger -#define WUTLOG(channel, ...) BOF_LOG_WARNING(MY_UT_MULTI_LOGGER, channel, ##__VA_ARGS__); -BOF_LOGGER_DEFINE_STORAGE(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL); - -void MyExternalSingleChannelLibInit(std::shared_ptr _psLoggerFactory) -{ - uint32_t ChannelIndex_U32 = 0; - bool Sts_B; - std::shared_ptr psSingleChannelLogger; - - psSingleChannelLogger = _psLoggerFactory->V_Create(ChannelIndex_U32, 1, "SNG"); - EXPECT_FALSE(psSingleChannelLogger == nullptr); - BOF_LOGGER_FACTORY_ADD(MY_UT_SINGLE_LOGGER, psSingleChannelLogger, ChannelIndex_U32, Sts_B); - EXPECT_TRUE(Sts_B); - - ChannelIndex_U32++; - psSingleChannelLogger = _psLoggerFactory->V_Create(ChannelIndex_U32, 1, "SNG"); - EXPECT_TRUE(psSingleChannelLogger == nullptr); - BOF_LOGGER_FACTORY_ADD(MY_UT_SINGLE_LOGGER, psSingleChannelLogger, ChannelIndex_U32, Sts_B); - EXPECT_FALSE(Sts_B); -} -void MyExternalSingleChannelLibCode(std::shared_ptr _psLoggerFactory) -{ - uint32_t ChannelIndex_U32 = 0; - std::shared_ptr psLogger; - - BOF_LOGGER_FACTORY_GET(MY_UT_SINGLE_LOGGER, ChannelIndex_U32 + 1, psLogger); - EXPECT_TRUE(psLogger == nullptr); - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, ChannelIndex_U32 + 1, "! This will not be logged !\n"); - BOF_LOGGER_FACTORY_GET(MY_UT_SINGLE_LOGGER, ChannelIndex_U32 + 1, psLogger); - EXPECT_TRUE(psLogger == nullptr); - - BOF_LOGGER_FACTORY_GET(MY_UT_SINGLE_LOGGER, ChannelIndex_U32, psLogger); - EXPECT_FALSE(psLogger == nullptr); - EXPECT_EQ(psLogger->mNbLogOut_U32, 0); - EXPECT_EQ(psLogger->mNbLogRejected_U32, 0); - BOF_LOG_FORCE(MY_UT_SINGLE_LOGGER, ChannelIndex_U32, "This will be logged\n"); - EXPECT_EQ(psLogger->mNbLogOut_U32, 1); - EXPECT_EQ(psLogger->mNbLogRejected_U32, 0); - - BOF_LOG_INFO(MY_UT_SINGLE_LOGGER, ChannelIndex_U32, "! This will not be logged !\n"); - EXPECT_EQ(psLogger->mNbLogOut_U32, 1); - EXPECT_EQ(psLogger->mNbLogRejected_U32, 1); - - BOF_LOG_WARNING(MY_UT_SINGLE_LOGGER, ChannelIndex_U32, "This will be logged\n"); - EXPECT_EQ(psLogger->mNbLogOut_U32, 2); - EXPECT_EQ(psLogger->mNbLogRejected_U32, 1); - - BOF_LOG_ERROR(MY_UT_SINGLE_LOGGER, ChannelIndex_U32, "This will be logged\n"); - EXPECT_EQ(psLogger->mNbLogOut_U32, 3); - EXPECT_EQ(psLogger->mNbLogRejected_U32, 1); -} - -void MyExternalMultipleChannelLibInit(std::shared_ptr _psLoggerFactory) -{ - bool Sts_B; - std::shared_ptr psMultiChannelLogger; - - if (_psLoggerFactory) - { - psMultiChannelLogger = _psLoggerFactory->V_Create(MAX_MULTI_CHANNEL, MAX_MULTI_CHANNEL, "MLT"); - EXPECT_TRUE(psMultiChannelLogger == nullptr); - BOF_LOGGER_FACTORY_ADD(MY_UT_MULTI_LOGGER, psMultiChannelLogger, MAX_MULTI_CHANNEL, Sts_B); - EXPECT_FALSE(Sts_B); - - psMultiChannelLogger = _psLoggerFactory->V_Create(MAX_MULTI_CHANNEL - 1, MAX_MULTI_CHANNEL, "DMA"); - EXPECT_FALSE(psMultiChannelLogger == nullptr); - BOF_LOGGER_FACTORY_ADD(MY_UT_MULTI_LOGGER, psMultiChannelLogger, MAX_MULTI_CHANNEL - 1, Sts_B); - EXPECT_TRUE(Sts_B); - - psMultiChannelLogger = _psLoggerFactory->V_Create(0, MAX_MULTI_CHANNEL, "REC"); - EXPECT_FALSE(psMultiChannelLogger == nullptr); - BOF_LOGGER_FACTORY_ADD(MY_UT_MULTI_LOGGER, psMultiChannelLogger, 0, Sts_B); - EXPECT_TRUE(Sts_B); - - /* Let a nullptr in the collection - psMultiChannelLogger = _psLoggerFactory->V_Create(1, MAX_MULTI_CHANNEL, "PLY"); - EXPECT_FALSE(psMultiChannelLogger == nullptr); - BOF_LOGGER_FACTORY_ADD(MY_UT_MULTI_LOGGER, psMultiChannelLogger, 1, Sts_B); - EXPECT_TRUE(Sts_B); - */ - } -} -void MyExternalMultipleChannelLibCode(std::shared_ptr _psLoggerFactory) -{ - std::shared_ptr psMultiChannelLogger0, psMultiChannelLogger1, psMultiChannelLoggerLast; - - BOF_LOGGER_FACTORY_GET(MY_UT_MULTI_LOGGER, 0, psMultiChannelLogger0); - EXPECT_FALSE(psMultiChannelLogger0 == nullptr); - BOF_LOGGER_FACTORY_GET(MY_UT_MULTI_LOGGER, 1, psMultiChannelLogger1); - EXPECT_TRUE(psMultiChannelLogger1 == nullptr); - BOF_LOGGER_FACTORY_GET(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, psMultiChannelLoggerLast); - EXPECT_FALSE(psMultiChannelLoggerLast == nullptr); - - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL, "! This will not be logged !\n"); - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, 0, "This will be logged\n"); - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); // Let a nullptr in the collection - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "This will be logged\n"); - EXPECT_EQ(psMultiChannelLogger0->mNbLogOut_U32, 1); - EXPECT_EQ(psMultiChannelLogger0->mNbLogRejected_U32, 0); - EXPECT_EQ(psMultiChannelLoggerLast->mNbLogOut_U32, 1); - EXPECT_EQ(psMultiChannelLoggerLast->mNbLogRejected_U32, 0); - - BOF_LOG_INFO(MY_UT_MULTI_LOGGER, 0, "! This will not be logged !\n"); - BOF_LOG_WARNING(MY_UT_MULTI_LOGGER, 0, "This will be logged\n"); - BOF_LOG_ERROR(MY_UT_MULTI_LOGGER, 0, "This will be logged\n"); - EXPECT_EQ(psMultiChannelLogger0->mNbLogOut_U32, 3); - EXPECT_EQ(psMultiChannelLogger0->mNbLogRejected_U32, 1); - - BOF_LOG_INFO(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); // Let a nullptr in the collection - BOF_LOG_WARNING(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); - BOF_LOG_ERROR(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); - - BOF_LOG_VERBOSE(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "! This will not be logged !\n"); - BOF_LOG_INFO(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "This will be logged\n"); - BOF_LOG_ERROR(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "This will be logged\n"); - EXPECT_EQ(psMultiChannelLoggerLast->mNbLogOut_U32, 3); - EXPECT_EQ(psMultiChannelLoggerLast->mNbLogRejected_U32, 1); -} -void MyExternalMultipleNullptrChannelLibCode() + // Logger Channel Definition +enum UT_LOGGER_CHANNEL : uint32_t { - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL, "! This will not be logged !\n"); - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, 0, "! This will not be logged !\n"); - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); // Let a nullptr in the collection - BOF_LOG_FORCE(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "! This will not be logged !\n"); - - BOF_LOG_INFO(MY_UT_MULTI_LOGGER, 0, "! This will not be logged !\n"); - BOF_LOG_WARNING(MY_UT_MULTI_LOGGER, 0, "! This will not be logged !\n"); - BOF_LOG_ERROR(MY_UT_MULTI_LOGGER, 0, "! This will not be logged !\n"); - - BOF_LOG_INFO(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); // Let a nullptr in the collection - BOF_LOG_WARNING(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); - BOF_LOG_ERROR(MY_UT_MULTI_LOGGER, 1, "! This will not be logged !\n"); - - BOF_LOG_VERBOSE(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "! This will not be logged !\n"); - BOF_LOG_INFO(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "! This will not be logged !\n"); - BOF_LOG_ERROR(MY_UT_MULTI_LOGGER, MAX_MULTI_CHANNEL - 1, "! This will not be logged !\n"); -} + UT_LOGGER_CHANNEL_INIT = 0, + UT_LOGGER_CHANNEL_CODEC, + UT_LOGGER_CHANNEL_NULLPTR, + UT_LOGGER_CHANNEL_DMA, + UT_LOGGER_CHANNEL_MAX +}; +static std::array, UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_MAX> S_psLoggerCollection; -//*** Caller/User of the external lib ******************************************************** -class MyUtLogger : public BOF::IBofLogger +void MyLibInit(std::shared_ptr _psLoggerFactory) { -public: - MyUtLogger(const uint32_t _ChannelIndex_U32, const std::string &_rChannelName_S) - { - char pLogFile_c[256]; - - mChannelIndex_U32 = _ChannelIndex_U32; - mChannelName_S = _rChannelName_S; - - sprintf(pLogFile_c, "%s_%03d.log", _rChannelName_S.c_str(), mChannelIndex_U32); - mpLogFile_X = fopen(pLogFile_c, "w+"); - } - ~MyUtLogger() + for (auto &rpsLogger : S_psLoggerCollection) { - if (mpLogFile_X) - { - fclose(mpLogFile_X); - mpLogFile_X = nullptr; - } + rpsLogger = nullptr; } - void V_Log(LogSeverity _SeverityLevel_E, const char *_pLogMessage_c, ...) override + if (_psLoggerFactory) { - char pLog_c[0x1000]; - va_list VaList_X; - - va_start(VaList_X, _pLogMessage_c); - vsnprintf(pLog_c, sizeof(pLog_c), _pLogMessage_c, VaList_X); - va_end(VaList_X); - - pLog_c[sizeof(pLog_c) - 1] = 0; - printf("Sev %d Channel[%d][%s]->%s", _SeverityLevel_E, mChannelIndex_U32, mChannelName_S.c_str(), pLog_c); - fwrite(pLog_c, strlen(pLog_c), 1, mpLogFile_X); + S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT] = _psLoggerFactory->V_Create("MyLib_", "INIT"); + S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_CODEC] = _psLoggerFactory->V_Create("MyLib_", "CODEC"); + S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_NULLPTR] = nullptr; + S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_DMA] = _psLoggerFactory->V_Create("MyLib_", "DMA"); } - -private: - uint32_t mChannelIndex_U32 = 0; - std::string mChannelName_S; - FILE *mpLogFile_X = nullptr; -}; - -class MyUtLoggerFactory : public BOF::IBofLoggerFactory +} +void MyLibCode(bool _NullTestCase_B) { -public: - std::shared_ptr V_Create(const uint32_t _ChannelIndex_U32, const uint32_t _MaxChannelIndex_U32, const std::string &_rChannelName_S) override - { - std::shared_ptr psRts = nullptr; - uint32_t i_U32; - - if (_ChannelIndex_U32 < _MaxChannelIndex_U32) - { - if (mLoggerCollection.size() != _MaxChannelIndex_U32) - { - mLoggerCollection.clear(); - for (i_U32 = 0; i_U32 < _MaxChannelIndex_U32; i_U32++) - { - mLoggerCollection.push_back(nullptr); - } - } - psRts = std::make_shared(_ChannelIndex_U32, _rChannelName_S); - mLoggerCollection[_ChannelIndex_U32] = psRts; - } - return psRts; - } - bool V_SetLogSeverityLevel(const uint32_t _ChannelIndex_U32, BOF::IBofLogger::LogSeverity _SeverityLevel_E) override + LOG_FORCE(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT], "This will be logged\n"); + LOG_FORCE(S_psLoggerCollection[UT_LOGGER_CHANNEL_CODEC], "This will be logged\n"); + LOG_FORCE(S_psLoggerCollection[UT_LOGGER_CHANNEL_NULLPTR], "! This will not be logged !\n"); + LOG_VERBOSE(S_psLoggerCollection[UT_LOGGER_CHANNEL_DMA], "! This will not be logged !\n"); + LOG_FORCE(S_psLoggerCollection[UT_LOGGER_CHANNEL_DMA], "! This one yes !\n"); + LOG_INFO(S_psLoggerCollection[UT_LOGGER_CHANNEL_DMA], "! This one also !\n"); + if (!_NullTestCase_B) { - bool Rts_B = false; - - if (_ChannelIndex_U32 < mLoggerCollection.size()) - { - if (mLoggerCollection[_ChannelIndex_U32]) - { - Rts_B = mLoggerCollection[_ChannelIndex_U32]->SetLogSeverityLevel(_SeverityLevel_E); - } - } - return Rts_B; + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT]->mNbLogOut_U32, 1); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT]->mNbLogRejected_U32, 0); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_CODEC]->mNbLogOut_U32, 1); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_CODEC]->mNbLogRejected_U32, 0); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_DMA]->mNbLogOut_U32, 2); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_DMA]->mNbLogRejected_U32, 1); } - BOF::IBofLogger::LogSeverity V_GetLogSeverityLevel(const uint32_t _ChannelIndex_U32) const override + LOG_INFO(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT], "! This will not be logged !\n"); + LOG_WARNING(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT], "This will be logged\n"); + LOG_ERROR(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT], "This will be logged\n"); + if (!_NullTestCase_B) { - BOF::IBofLogger::LogSeverity Rts_E = BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX; - if (_ChannelIndex_U32 < mLoggerCollection.size()) - { - if (mLoggerCollection[_ChannelIndex_U32]) - { - Rts_E = mLoggerCollection[_ChannelIndex_U32]->GetLogSeverityLevel(); - } - } - return Rts_E; + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT]->mNbLogOut_U32, 3); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL_INIT]->mNbLogRejected_U32, 1); } - -private: - std::vector> mLoggerCollection; -}; -//*** Caller/User of the external lib ******************************************************** -//*** Unit Test ****************************************************************************** -TEST(ut_logger_ibofloggerfactory, InjectNullptr) -{ - MyExternalMultipleChannelLibInit(nullptr); - - MyExternalMultipleNullptrChannelLibCode(); } -TEST(ut_logger_ibofloggerfactory, SingleChannel) +TEST(ut_logger_ibofloggerfactory, MultipleChannel) { - std::shared_ptr psSingleChannelLogger = std::make_shared(); - MyExternalSingleChannelLibInit(psSingleChannelLogger); - - EXPECT_EQ(psSingleChannelLogger->V_GetLogSeverityLevel(0), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); - EXPECT_TRUE(psSingleChannelLogger->V_SetLogSeverityLevel(0, BOF::IBofLogger::LogSeverity::LOG_SEVERITY_WARNING)); - EXPECT_EQ(psSingleChannelLogger->V_GetLogSeverityLevel(0), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_WARNING); - - MyExternalSingleChannelLibCode(psSingleChannelLogger); + std::shared_ptr psLoggerFactory = std::make_shared(true, "."); + MyLibInit(psLoggerFactory); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT] != nullptr); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_CODEC] != nullptr); + EXPECT_FALSE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_NULLPTR] != nullptr); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_DMA] != nullptr); + + EXPECT_TRUE(psLoggerFactory->V_Create("MyLib_", "DMA") == nullptr); + EXPECT_TRUE(psLoggerFactory->V_Create("MyLib_", "DMA2") != nullptr); + EXPECT_TRUE(psLoggerFactory->V_Destroy("MyLib_", "DMA2")); + EXPECT_FALSE(psLoggerFactory->V_Destroy("MyLib_", "DMA3")); + + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT]->GetLogSeverityLevel(), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT]->SetLogSeverityLevel(BOF::IBofLogger::LogSeverity::LOG_SEVERITY_WARNING)); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT]->GetLogSeverityLevel(), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_WARNING); + + EXPECT_FALSE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT]->SetLogSeverityLevel(BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX)); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT]->GetLogSeverityLevel(), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_WARNING); + + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_CODEC]->GetLogSeverityLevel(), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_CODEC]->SetLogSeverityLevel(BOF::IBofLogger::LogSeverity::LOG_SEVERITY_FORCE)); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_CODEC]->GetLogSeverityLevel(), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_FORCE); + + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_DMA]->GetLogSeverityLevel(), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_DMA]->SetLogSeverityLevel(BOF::IBofLogger::LogSeverity::LOG_SEVERITY_INFO)); + EXPECT_EQ(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_DMA]->GetLogSeverityLevel(), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_INFO); + + MyLibCode(false); } -TEST(ut_logger_ibofloggerfactory, MultipleChannel) +TEST(ut_logger_ibofloggerfactory, nullptr) { - std::shared_ptr psMultipleChannelLogger = std::make_shared(); - MyExternalMultipleChannelLibInit(psMultipleChannelLogger); - - EXPECT_EQ(psMultipleChannelLogger->V_GetLogSeverityLevel(0), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); - EXPECT_TRUE(psMultipleChannelLogger->V_SetLogSeverityLevel(0, BOF::IBofLogger::LogSeverity::LOG_SEVERITY_WARNING)); - EXPECT_EQ(psMultipleChannelLogger->V_GetLogSeverityLevel(0), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_WARNING); + MyLibInit(nullptr); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_INIT] == nullptr); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_CODEC] == nullptr); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_NULLPTR] == nullptr); + EXPECT_TRUE(S_psLoggerCollection[UT_LOGGER_CHANNEL::UT_LOGGER_CHANNEL_DMA] == nullptr); - EXPECT_EQ(psMultipleChannelLogger->V_GetLogSeverityLevel(1), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); - EXPECT_FALSE(psMultipleChannelLogger->V_SetLogSeverityLevel(1, BOF::IBofLogger::LogSeverity::LOG_SEVERITY_FORCE)); - EXPECT_EQ(psMultipleChannelLogger->V_GetLogSeverityLevel(1), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); - - EXPECT_EQ(psMultipleChannelLogger->V_GetLogSeverityLevel(MAX_MULTI_CHANNEL - 1), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_MAX); - EXPECT_TRUE(psMultipleChannelLogger->V_SetLogSeverityLevel(MAX_MULTI_CHANNEL - 1, BOF::IBofLogger::LogSeverity::LOG_SEVERITY_INFO)); - EXPECT_EQ(psMultipleChannelLogger->V_GetLogSeverityLevel(MAX_MULTI_CHANNEL - 1), BOF::IBofLogger::LogSeverity::LOG_SEVERITY_INFO); - - - MyExternalMultipleChannelLibCode(psMultipleChannelLogger); + MyLibCode(true); } - #if 0 TEST_F(Logger_Test, LoggerFile) {