unit_tests/ut_logger.cpp

   1 /*
   2  * Copyright (c) 2014 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <cassert>
  18 #include <sstream>
  19 #include <string>
  20
  21 #include <boost/test/unit_test.hpp>
  22 #include <boost/date_time/posix_time/posix_time.hpp>
  23 #include <boost/algorithm/string/trim.hpp>
  24
  25 // Dirty hack used do get access for private class interiors
  26 // for test porpouses.
  27 #define private public
  28 #define protected public
  29
  30 #include "Logger.h"
  31 #include "AbstractLogger.h"
  32
  33 #define COLOR "\033[41m\033[37m"
  34
  35 BOOST_AUTO_TEST_SUITE(logger)
  36
  37 struct StubAbstractLogger: tizen_browser::logger::AbstractLogger {
  38         StubAbstractLogger() :
  39                         initialized(false) {
  40         }
  41         ~StubAbstractLogger() {
  42         }
  43         void init() {
  44                 ss.flush();
  45                 initialized = true;
  46         }
  47         void log(const std::string &timeStamp, const std::string &tag,
  48                         const std::string &msg, bool errorFlag = false) {
  49                 errorFlag = false;
  50                 std::string str = timeStamp + tag + msg;
  51                 ss << str << '\n';
  52         }
  53
  54         std::string getLog() {
  55                 std::string ret = ss.str();
  56                 ss.flush();
  57                 return ret;
  58         }
  59
  60         bool initialized;
  61         std::stringstream ss;
  62 };
  63
  64 // simple tests for inherited interface
  65 BOOST_AUTO_TEST_CASE(logger_abstract_logger) {
  66         std::stringstream ss;
  67         ss << boost::unit_test::framework::current_test_case().p_name;
  68
  69         StubAbstractLogger sl;
  70
  71         sl.init();
  72         BOOST_CHECK(sl.getLog().empty());
  73
  74         sl.log("a", "b", "c");
  75         BOOST_CHECK_EQUAL(sl.getLog().compare("abc\n"), 0);
  76 }
  77
  78 class StubLogger: public tizen_browser::logger::Logger {
  79 public:
  80         virtual ~StubLogger() {
  81         }
  82         static StubLogger& getInstance() {
  83                 static StubLogger instance;
  84                 return instance;
  85         }
  86
  87 private:
  88         StubLogger() { }
  89 };
  90
  91 BOOST_AUTO_TEST_CASE(logger_init) {
  92         std::stringstream ss;
  93         ss << boost::unit_test::framework::current_test_case().p_name;
  94
  95         // checks for support functions
  96         StubLogger::Logger::getInstance().setProjectName("bla");
  97         BOOST_CHECK_EQUAL(StubLogger::Logger::getInstance().m_projectName.compare("bla"), 0);
  98         BOOST_CHECK_EQUAL(StubLogger::Logger::getInstance().getProjectName(), "bla");
  99
 100         // checks for registering logger functionality
 101         StubAbstractLogger *l1 = new StubAbstractLogger;
 102         StubAbstractLogger *l2 = new StubAbstractLogger;
 103
 104         BOOST_CHECK_EQUAL(l1->initialized, false);
 105         BOOST_CHECK_EQUAL(l2->initialized, false);
 106
 107         StubLogger::getInstance().registerLogger(l1);
 108         StubLogger::getInstance().registerLogger(l2);
 109         StubLogger::getInstance().init();
 110
 111         BOOST_CHECK_EQUAL(l1->initialized, true);
 112         BOOST_CHECK_EQUAL(l2->initialized, true);
 113
 114         // checks for logging process
 115         std::string msg("Bla");
 116         StubLogger::getInstance().log(msg);
 117
 118         std::string checker = l1->getLog();
 119         checker.erase(checker.begin(), std::find(checker.begin(), checker.end(), ']') + 1);
 120         boost::algorithm::trim(checker);
 121         BOOST_CHECK_EQUAL(checker, msg);
 122
 123         checker = l2->getLog();
 124         checker.erase(checker.begin(), std::find(checker.begin(), checker.end(), ']') + 1);
 125         boost::algorithm::trim(checker);
 126         BOOST_CHECK_EQUAL(checker, msg);
 127 }
 128
 129 ///\todo p.chmielewski
 130 /*
 131 BOOST_AUTO_TEST_CASE(logger_levels_getting) {
 132     using tizen_browser::logger::Logger;
 133     using tizen_browser::logger::LoggerLevel;
 134
 135         std::string infoTag = Logger::getLevelTag(LoggerLevel::INFO);
 136         BOOST_CHECK_EQUAL(infoTag, "Info");
 137
 138         std::string warningTag = Logger::getLevelTag(LoggerLevel::WARN);
 139         BOOST_CHECK_EQUAL(warningTag, "Warning");
 140
 141         std::string errorTag = Logger::getLevelTag(LoggerLevel::ERROR);
 142         BOOST_CHECK_EQUAL(errorTag, "Error");
 143
 144         std::string fatalTag = Logger::getLevelTag(LoggerLevel::FATAL);
 145         BOOST_CHECK_EQUAL(fatalTag, "Fatal");
 146
 147         std::string debugTag = Logger::getLevelTag(LoggerLevel::DEBUG);
 148         BOOST_CHECK_EQUAL(debugTag, "Debug");
 149
 150         std::string noneTag = Logger::getLevelTag(LoggerLevel::NONE);
 151         BOOST_CHECK_EQUAL(noneTag, "");
 152 }
 153
 154 BOOST_AUTO_TEST_CASE(logger_levels_parsing) {
 155         using tizen_browser::logger::Logger;
 156         using tizen_browser::logger::LoggerLevel;
 157
 158         LoggerLevel loggerLevel;
 159
 160         loggerLevel = Logger::parseLoggerLevel("INFO");
 161         BOOST_CHECK_EQUAL(loggerLevel, LoggerLevel::INFO);
 162
 163         loggerLevel = Logger::parseLoggerLevel("WARN");
 164         BOOST_CHECK_EQUAL(loggerLevel, LoggerLevel::WARN);
 165
 166         loggerLevel = Logger::parseLoggerLevel("ERROR");
 167         BOOST_CHECK_EQUAL(loggerLevel, LoggerLevel::ERROR);
 168
 169         loggerLevel = Logger::parseLoggerLevel("FATAL");
 170         BOOST_CHECK_EQUAL(loggerLevel, LoggerLevel::FATAL);
 171
 172         loggerLevel = Logger::parseLoggerLevel("DEBUG");
 173         BOOST_CHECK_EQUAL(loggerLevel, LoggerLevel::DEBUG);
 174
 175         loggerLevel = Logger::parseLoggerLevel("NONE");
 176         BOOST_CHECK_EQUAL(loggerLevel, LoggerLevel::NONE);
 177 }
 178 */
 179 BOOST_AUTO_TEST_SUITE_END()