/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description: This file contains the header file of the
* CStifLogger.
*
*/
#ifndef STIFLOGGER_H
#define STIFLOGGER_H
// INCLUDES
#include <e32base.h>
// If using older STIF TF than STIF200414 there is no this definition.
// If is need to combile e.g. testmodule with older STIF TF there may use
// in the testmodule this flag to indicating which enum definition is used.
// Example:
// #ifdef __NEW_LOGGER_ENUMS_DEFS__
// logger->Log( CStifLogger::ERed, _L( "Logged text" ) );
// #else
// logger->Log( ERed, _L( "Logged text" ) );
// #endif
#define __NEW_LOGGER_ENUMS_DEFS__
// Maximum length of the data. Must be over 26 because HTML page initializing.
// Can be only max 254 length because rdebug prints max 256 length text and
// that includes line break(+2 character)
const TInt KMaxLogData = 254;
// This is for making partitions of the rdebug( minus 3 is for ' ->')
const TInt KMaxRDebug = KMaxLogData - 3;
// Maximum count of file type plus dot e.g. ".txt"
const TInt KMaxFileType = 10;
// Maximum length of the date and time logging
// Includes date, time, spaces(5) and end of line(2):
// e.g. "'06.Nov.2003 15:12:18.123 '...logged data...' '"
const TInt KMaxTimeStamp = 30;
// MACROS
// None
// DATA TYPES
// For 16 bit data size definition.
typedef TBuf<KMaxLogData> TLogInfo;
// For 8 bit data size definition.
typedef TBuf8<KMaxLogData> TLogInfo8;
// For file type size definition.
typedef TBuf<KMaxFileType> TFileType;
// For time stamp size definition.
typedef TBuf8<KMaxTimeStamp> TStifLoggerTimeStamp;
// For time stamp size definition.
typedef TBuf<KMaxTimeStamp> TStifLoggerTimeStamp8;
// FUNCTION PROTOTYPES
// None
// FORWARD DECLARATIONS
class COutput;
// Structs are defined at the end of this file.
struct TOverwritedSettings;
struct TLoggerSettings;
// CLASS DECLARATION
// DESCRIPTION
// CStifLogger is a STIF Test Framework StifLogger class.
// Class contains a file logging operations.
class CStifLogger
:public CBase
{
public: // Enumerations
// Different StifLogger presentations types.
enum TLoggerType
{
ETxt, // txt file logging
EData, // data file logging(e.g. web page downloading )
EHtml // html file logging
};
// Different StifLogger output modules.
enum TOutput
{
EFile, // File logging
ERDebug // RDebug logging
};
// Different style forms for text.
enum TStyle
{
ENoStyle = 0x00000, // No style parameter
EBold = 0x00001, // Bold
ECursive = 0x00002, // Cursive
EUnderline = 0x00004, // Underline
EBlue = 0x00008, // Blue
EGreen = 0x00010, // Green
ERed = 0x00020, // Red
EImportant = 0x00040, // Important (Line will starts a 'IMPORTANT' text)
EWarning = 0x00080, // Warning (Line will starts a 'WARNING' text)
EError = 0x00100 // Error (Line will starts a 'ERROR' text)
};
private: // Enumerations
public: // Constructors and destructor
/**
* Two-phased constructor.
*/
IMPORT_C static CStifLogger* NewL( const TDesC& aTestPath,
const TDesC& aTestFile,
// Default logger type is .txt
TLoggerType aLoggerType = ETxt,
// By default output is file
TOutput aOutput = EFile,
// By default overwrite is used
TBool aOverWrite = ETrue,
// By default time stamp is used
TBool aWithTimeStamp = ETrue,
// By default line break is used
TBool aWithLineBreak = ETrue,
// By default even ranking is not
// used
TBool aWithEventRanking = EFalse,
// By default thread id is added
// after the log file
TBool aThreadIdToLogFile = ETrue,
// By default log directory will
// not create
TBool aCreateLogDir = EFalse,
// Static logger implementation is
// not yet permanent, may change
TInt aStaticBufferSize = 0,
// By default files are not written
// in unicode format
TBool aUnicode = EFalse );
/**
* Destructor.
*/
virtual ~CStifLogger();
public: // New functions
/**
* C++ default constructor.
*/
CStifLogger();
/**
* Log a 16 bit information to some storage e.g. text file.
*/
IMPORT_C TInt Log( const TDesC& aLogInfo );
/**
* Log a 8 bit information to some storage e.g. text file.
*/
IMPORT_C TInt Log( const TDesC8& aLogInfo );
/**
* Log a 16 bit information to some storage e.g. text file. There is
* also parameter to styling text information e.g. text color.
*/
IMPORT_C TInt Log( TInt aStyle, const TDesC& aLogInfo );
/**
* Log a 8 bit information to some storage e.g. text file. There is
* also parameter to styling text information e.g. text color.
*/
IMPORT_C TInt Log( TInt aStyle, const TDesC8& aLogInfo );
/**
* Log a 16 bit information to some storage e.g. text file. In this log
* method may set several parameters.
*/
IMPORT_C TInt Log( TRefByValue<const TDesC> aLogInfo,... );
/**
* Log a 8 bit information to some storage e.g. text file. In this log
* method may set several parameters.
*/
IMPORT_C TInt Log( TRefByValue<const TDesC8> aLogInfo,... );
/**
* Log a 16 bit information to some storage e.g. text file. There is
* also parameter to styling text information e.g. text color.
*/
IMPORT_C TInt Log( TInt aStyle,
TRefByValue<const TDesC> aLogInfo,... );
/**
* Log a 8 bit information to some storage e.g. text file. There is
* also parameter to styling text information e.g. text color.
*/
IMPORT_C TInt Log( TInt aStyle,
TRefByValue<const TDesC8> aLogInfo,... );
/**
* Log a 16 bit delimiter. Default char is '#' and default
* repeat count is 60.
* This will be used if parameters are not given when calling
* this method.
*/
IMPORT_C TInt WriteDelimiter( const TDesC& aDelimiter = _L( "#"),
TInt aCount = 60 );
/**
* Log a 8 bit delimiter. 8 bit delimiter includes no default values.
* Delimiter may be '#' or 'XO' etc.
*/
IMPORT_C TInt WriteDelimiter( const TDesC8& aDelimiter, TInt aCount );
/**
* Used when is need to save file or data to storage e.g. web page.
* 16 bit.
*/
IMPORT_C TInt SaveData( TDesC& aData );
/**
* Used when is need to save file or data to storage e.g. web page.
* 8 bit.
*/
IMPORT_C TInt SaveData( TDesC8& aData );
/**
* Get creation result.
*/
IMPORT_C TInt CreationResult();
/**
* Get output type. Valid only if CreationResult returns KErrNone.
*/
IMPORT_C TOutput OutputType();
/**
* Pure virtual. Send style information and data to the output module.
* 16 bit.
*/
virtual TInt Send( TInt /*aStyle*/, const TDesC& /*aData*/ ) = 0;
/**
* Pure virtual. Send style information and data to the output module.
* 8 bit.
*/
virtual TInt Send( TInt /*aStyle*/, const TDesC8& /*aData*/ ) = 0;
/**
* Log 16 bit _LIT information to some storage e.g. text file.
*/
template<TInt S> TInt Log( const TLitC<S>& aLogInfo )
{
return Send( ENoStyle, (TDesC&)aLogInfo );
};
/**
* Log 8 bit _LIT information to some storage e.g. text file.
*/
template<TInt S> TInt Log( const TLitC8<S>& aLogInfo )
{
return Send( ENoStyle, (TDesC8&)aLogInfo );
};
/**
* Log 16 bit _LIT information to some storage e.g. text file. There is
* also parameter to styling text information e.g. text color.
*/
template<TInt S> TInt Log( TInt aStyle, const TLitC<S>& aLogInfo )
{
return Send( aStyle, (TDesC&)aLogInfo );
};
/**
* Log 8 bit _LIT information to some storage e.g. text file. There is
* also parameter to styling text information e.g. text color.
*/
template<TInt S> TInt Log( TInt aStyle, const TLitC8<S>& aLogInfo )
{
return Send( aStyle, (TDesC8&)aLogInfo );
};
public: // Functions from base classes
protected: // New functions
/**
* Two-phased constructor. TestEngine's and TestServer's are friend.
* For TestEngine's and TestServer's StifLogger creation.
*/
IMPORT_C static CStifLogger* NewL( const TDesC& aTestPath,
const TDesC& aTestFile,
TLoggerSettings& aLoggerSettings );
protected: // Functions from base classes
/**
* Local CStifLogger's method for StifLogger settings overwriting.
*/
static void OverwriteLoggerSettings( TLoggerSettings& aLoggerSettings,
TName& aTestPath,
TName& aTestFile,
TLoggerType& aLoggerType,
TOutput& aOutput,
TBool& aOverWrite,
TBool& aWithTimeStamp,
TBool& aWithLineBreak,
TBool& aWithEventRanking,
TBool& aThreadIdToLogFile,
TBool& aCreateLogDir,
TBool& aUnicode );
private:
public: // Data
protected: // Data
/**
* Output object.
*/
COutput* iOutput;
private: // Data
public: // Friend classes
protected: // Friend classes
private: // Friend classes
// TestEngine classes
friend class CTestEngineServer;
friend class CTestReport;
friend class CTestCaseController;
friend class CTestEngine;
// TestServer classes
friend class CTestModuleContainer;
friend class CTestServer;
friend class CTestThreadContainer;
friend class CTestThreadContainerRunner;
// UIEngine classes
friend class CUIEngine;
// SettingServer classes
friend class CSettingServer;
};
// Struct to indicate StifLogger's settings overwriting
struct TOverwritedSettings
{
TBool iCreateLogDir;
TBool iPath;
TBool iHwPath;
TBool iFormat;
TBool iHwFormat;
TBool iOutput;
TBool iHwOutput;
TBool iOverwrite;
TBool iTimeStamp;
TBool iLineBreak;
TBool iEventRanking;
TBool iThreadId;
TBool iUnicode;
TBool iAddTestCaseTitle;
};
// Struct to StifLogger overwrite settings
struct TLoggerSettings
{
TBool iCreateLogDirectories;
TName iEmulatorPath;
CStifLogger::TLoggerType iEmulatorFormat;
CStifLogger::TOutput iEmulatorOutput;
TName iHardwarePath;
CStifLogger::TLoggerType iHardwareFormat;
CStifLogger::TOutput iHardwareOutput;
TBool iOverwrite;
TBool iTimeStamp;
TBool iLineBreak;
TBool iEventRanking;
TBool iThreadId;
TBool iUnicode;
TBool iAddTestCaseTitle;
TOverwritedSettings iIsDefined;
};
#endif // STIFLOGGER_H
// End of File