ProtocolImpl.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
///
/// \file
/// \author Gerald Fahrnholz
/// 
/// \brief
/// Implementation of class Protocol
/// 
////////////////////////////////////////////////////////////////////////////////

#pragma once

#include "TestToolBox/CommonSources/CommonDefinitions.h"
#include "TestToolBox/Protocol.h"
#include "TestToolBox/TestTime.h"
#include "TestToolBox/TestStream.h"

///\cond do not document


namespace TestToolBox
{

//************************************************************************
//
// Interface IProtocol
//
//************************************************************************

TTB_INLINE void Protocol::Write (
    std::string const & in_text)
{
    AutoLock o (this);
    Write(OutputLevel::eREGULAR, TS().GetMode(), in_text);

} // Protocol::Write


//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::Writeln (
    std::string const & in_text)
{
    AutoLock o (this);
    TS() << in_text.c_str() << std::endl;

} // Protocol::Writeln


//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::Write (
    OutputLevel::Enum   in_outputLevel,
    unsigned char       in_outputMode,
    std::string const & in_text)
{
    AutoLock o (this);
    unsigned char oldMode = AdjustOutputMode(in_outputLevel, in_outputMode);

    TS() << in_text.c_str();

    // Reset original settings for output streams
    TS().SetMode(oldMode);

} // Protocol::Write

//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::Writeln (
    OutputLevel::Enum   in_outputLevel,
    unsigned char       in_outputMode,
    std::string const & in_text)
{
    AutoLock o (this);
    unsigned char oldMode = AdjustOutputMode(in_outputLevel, in_outputMode);

    TS() << in_text.c_str() << std::endl;

    // Reset original settings for output streams
    TS().SetMode(oldMode);

} // Protocol::Write

//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::WriteFooter(unsigned char m)
{
    OutputLevel::Enum o = OutputLevel::eREGULAR;
    Writeln(o,m,S_SEPARATOR_LINE);
    Writeln(o,m,"");
    Writeln(o,m,"Test started    : " + TestTime::Get()->GetStartTimeDateStr());
    Writeln(o,m,"Test ended      : " + TestTime::Get()->GetStopTimeDateStr());
    Writeln(o,m,"Duration        :            " + TestTime::Get()->GetTestDurationStr());

    m_footerAlreadyWritten = true;

} // Protocol::WriteFooter


//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::SetMode (
    unsigned char in_newMode)
{
    TS().SetMode(in_newMode);
}

TTB_INLINE void Protocol::ResetMode (void)
{
    TS().ResetMode();
}

TTB_INLINE void Protocol::SetStreamActivation (
    unsigned char in_streamsToActivate)
{
    TS().SetStreamActivation(in_streamsToActivate);
}


//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::SwitchLogfiles (
        std::string const & in_postFixNewFileName,
        std::string const & in_msgClose,
        std::string const & in_msgOpen)
{
    //-----  Close current logfiles  -----

    OutputLevel::Enum o = OutputLevel::eREGULAR;
    unsigned char m = OutputMode::M_OUTFILE | OutputMode::M_RPTFILE;
    Writeln(o,m,in_msgClose);
    if (m_outF.rdbuf()->is_open())
    {
        if (!m_footerAlreadyWritten)
        {
            WriteFooter(m);
            m_footerAlreadyWritten = false;
        }
         
        m_outF.flush();
        m_outF.close();

        m_rptF.flush();
        m_rptF.close();
    }


    //-----  Open new logfiles  -----

    TestTime::Get()->ResetStopTime();
    unsigned char allowedStreams = TS().GetStreamActivation();

    std::string outFileName =
          TheEnvironment()->GetOutputDir() + "\\" +
          TheEnvironment()->GetAppName() + in_postFixNewFileName + ".out";
    if (allowedStreams & M_OUTFILE)
    {
        m_outF.open (outFileName.c_str(), std::ios::out);
    }

    std::string rptFileName =
          TheEnvironment()->GetOutputDir() + "\\" +
          TheEnvironment()->GetAppName() + in_postFixNewFileName + ".rpt";
    if (allowedStreams & M_RPTFILE)
    {
        m_rptF.open (rptFileName.c_str(), std::ios::out);
    }

    Writeln(o,m,in_msgOpen);

} // Protocol::SwitchLogfiles


//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::SetOutputLevelForStdOut (
    OutputLevel::Enum in_outputLevel)
{
    AutoLock o (this);
    m_activeOutputLevelForStdOut = in_outputLevel;
}


//************************************************************************
//************************************************************************


TTB_INLINE void Protocol::WriteHeader(void)
{
    std::string outFileName =
          TheEnvironment()->GetOutputDir() + "\\" +
          TheEnvironment()->GetAppName() + ".out";

    std::string rptFileName =
          TheEnvironment()->GetOutputDir() + "\\" +
          TheEnvironment()->GetAppName() + ".rpt";

    OutputLevel::Enum o = OutputLevel::eREGULAR;
    unsigned char m = M_ALL;
    Writeln(o,m,"Generic test protocol template / TestToolBox (TTB) 2010\n\n");
    Writeln(o,m,"                    T E S T   P R O T O C O L\n");
    Writeln(o,m,"Date              : " + TestTime::Get()->GetStartTimeDateStr());
    Writeln(o,m,"Test application  : " + TheEnvironment()->GetExeFileFullPath());
    Writeln(o,m,"Test protocol     : " + outFileName);
    Writeln(o,m,"Test report       : " + rptFileName);
    Writeln(o,m,"Source path       : " + TheEnvironment()->GetSourceDir());
    Writeln(o,m,"Command line args : " + TheEnvironment()->GetArgsStr());
    Writeln(o,m,"Run on computer   : " + Environment::GetNameOfComputer());
    Writeln(o,m,"Run by            : " + Environment::GetNameOfUser());
    Writeln(o,m,S_SEPARATOR_LINE);

} // Protocol::WriteHeader


//************************************************************************
//
// Public methods
//
//************************************************************************


TTB_INLINE Protocol::Protocol(
    unsigned int      in_allowedStreams,
    OutputLevel::Enum in_outputLevel)
    : m_footerAlreadyWritten       (false)
    , m_pTestStream                (0)
    , S_SEPARATOR_LINE             ("________________________________________________________________________________")
        , m_activeOutputLevelForStdOut (in_outputLevel)
{
    TRCF("Protocol::Protocol");

    std::string outFileName =
          TheEnvironment()->GetOutputDir() + "\\" +
          TheEnvironment()->GetAppName() + ".out";
    if (in_allowedStreams & M_OUTFILE)
    {
        m_outF.open (outFileName.c_str(), std::ios::out);
    }

    std::string rptFileName =
          TheEnvironment()->GetOutputDir() + "\\" +
          TheEnvironment()->GetAppName() + ".rpt";
    if (in_allowedStreams & M_RPTFILE)
    {
        m_rptF.open (rptFileName.c_str(), std::ios::out);
    }

    m_pTestStream = new TestStream(
            &m_outF, &m_rptF);

    TS().SetStreamActivation(in_allowedStreams);

    TRC(TL_PROD,"Opened protocol: %s", outFileName.c_str());

    WriteHeader();

} // Protocol::Protocol


//************************************************************************
//************************************************************************


TTB_INLINE Protocol::~Protocol()
{
    TRCF("Protocol::~Protocol");
    TRC(TL_DEBUG, "Destructor");

    if (m_outF.rdbuf()->is_open())
    {
        if (!m_footerAlreadyWritten)
        {
            WriteFooter();
        }
         
        m_outF.flush();
        m_outF.close();

        m_rptF.flush();
        m_rptF.close();
    }

    delete m_pTestStream;
    m_pTestStream = 0;

} // Protocol::~Protocol


//************************************************************************
//************************************************************************


TTB_INLINE TestStream& Protocol::TS (void)
{return *m_pTestStream;}


//************************************************************************
//************************************************************************


TTB_INLINE unsigned char Protocol::AdjustOutputMode(
    OutputLevel::Enum in_outputLevel,
    unsigned char     in_outputMode)
{
    unsigned char oldMode = TS().GetMode();
    unsigned char newMode = in_outputMode;
    if (in_outputLevel > m_activeOutputLevelForStdOut)
    {
        // disallow writing to stdout
        newMode = newMode & (~M_STDOUT);
    }
    // Within protocol file we usually want all output
    // up to regular level regardless what is specified at commandline,
    // but if verbous level is specified
    // at command line we want the extended output also within protocol file
    if (   in_outputLevel == OutputLevel::eVERBOUS
        && m_activeOutputLevelForStdOut < OutputLevel::eVERBOUS)
    {
        // disallow writing to protocol file
        newMode = newMode & (~M_OUTFILE);
    }
    TS().SetMode(newMode);

    return oldMode;

} // Protocol::AdjustOutputMode


//************************************************************************
//************************************************************************


}; // namespace TestToolBox

///\endcond

---