main.cpp

Go to the documentation of this file.

#include <Poco/SharedPtr.h>
#include <gtest/gtest.h>
#include <sstream>
#include <iostream>

#include "LoggerStream.hpp"
#include "RealLoggable.hpp"
#include "CustomMessage.hpp"

// list all messages need to functional objects
std::vector<std::pair<unsigned int, std::string> > messages =
{
    {0, "TEST START"},
    {1, "TEST DATA"},
    {2, "TEST MSG"},
    {3, "TEST STOP"}
};

Poco::SharedPtr<HCE::MessagesCollection> pMessagesCollection;
Poco::SharedPtr<HCE::CustomMessage> pCustomMessage;

class CustomMessageTest : public ::testing::Test
{
protected:
  static void SetUpTestCase(void)
  {
    pMessagesCollection = Poco::SharedPtr<HCE::MessagesCollection>(new HCE::MessagesCollection(messages));
    pCustomMessage = Poco::SharedPtr<HCE::CustomMessage>(new HCE::CustomMessage(*pMessagesCollection));
  }
  static void TearDownTestCase(void)
  {
    pMessagesCollection = nullptr;
    pCustomMessage = nullptr;
  }
};

TEST(LoggerStreamTest, defaultModeWriteToBuffer)
{
  HCE::LoggerStream logger;

  // default mode write to buffer
  logger << "test 1";
  ASSERT_EQ(logger.logMsg(), "test 1");

  logger << "TEST 2" << std::endl;
  ASSERT_EQ(logger.logMsg(), "TEST 2\n");
}

TEST(LoggerStreamTest, modeWriteToStream)
{
  HCE::LoggerStream logger;
  std::stringstream str;

  // below mode write to stream
  logger.setLogStream(str);   // turn on mode write to stream
  logger.log() << "TEST CONSOLE" << std::endl;
  ASSERT_EQ(str.str(), "TEST CONSOLE\n");

  logger.resetLogStream();          // turn off mode write to stream
  logger.log() << "THIS NEVER BEEN TO STREAM" << std::endl; // message will be write to buffer

  // again mode write to buffer
  logger.log() << "test 3" << std::endl;
  // output buffer content (include "THIS NEVER BEEN TO STREAM")
  ASSERT_EQ(logger.logMsg(), "THIS NEVER BEEN TO STREAM\ntest 3\n");
}

TEST(LoggerStreamTest, useEndlMamipulator)
{
  HCE::LoggerStream logger;
  HCE::tests::RealLoggable realLoggable; // some user implemented class (child of interface class Loggable)

  // below used HCE::endl manipulator
  logger << "test 4" << HCE::endl;
  ASSERT_EQ(logger.logMsg(), "test 4\n");

  logger.setLoggable(realLoggable); // bind to class describing need behavior
  logger << "test 5" << std::endl << "test 6" << HCE::endl;

  std::string msg = logger.logMsg();
  ASSERT_TRUE(msg.find("test 5")!=std::string::npos && msg.find("test 6")!=std::string::npos);

  logger.resetLoggable();   // unbind any classes describing need behavior
  logger << "test 7";
  ASSERT_EQ(logger.logMsg(), "test 7");
}

TEST_F(CustomMessageTest, defaultDelimiterTokens)
{
  HCE::CustomMessage& msg = *pCustomMessage;
  /* output messages with default delimiter tokens */
  ASSERT_EQ(msg(0), "TEST START. ");
  ASSERT_EQ(msg(1, 42), "TEST DATA: 42 ");
  ASSERT_EQ(msg(2, "USER MESSAGE"), "TEST MSG: USER MESSAGE ");
  ASSERT_EQ(msg(3), "TEST STOP. ");
}

TEST_F(CustomMessageTest, customDelimiterTokens)
{
  HCE::CustomMessage& msg = *pCustomMessage;
  /* set custom delimiter tokens */
  HCE::CustomMessage::MsgConst msgConst = { '*', ';', '-'};
  msg.setMsgConst(msgConst);

  /* output messages with custom delimiter tokens */
  ASSERT_EQ(msg(0), "TEST START;*");
  ASSERT_EQ(msg(1, 42), "TEST DATA-*42*");
  ASSERT_EQ(msg(2, "USER MESSAGE"), "TEST MSG-*USER MESSAGE*");
  ASSERT_EQ(msg(3), "TEST STOP;*");
}

int main (int argc, char** argv)
{
  testing::InitGoogleTest(&argc, argv);
  return RUN_ALL_TESTS();
}