// Copyright (c) 2007-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:
// The declaration of the CTSY integration test suite base class.
// 
//

/**
 @internalTechnology
*/

#ifndef __CCTSYINTEGRATIONTESTSUITEBASE_H__
#define __CCTSYINTEGRATIONTESTSUITEBASE_H__

#include <test/testexecutestepbase.h>

#include <etelmm.h>
#include <etelpckt.h>

#include "tetelrequeststatus.h"
#include "rpsownnumbers.h"
#include "townnumbersmanager.h"
#include "rpsasciirqstdefs.h"

class CEtelSessionMgr;

/**
Test result allocation:

EInconclusive: (INCONCLUSIVE)
-	The test can't be run because the HW, LTSY, SIM or Network 
	doesn't support a require functionality or capability. 
	Example: Call waiting indicator test and the SIM doesn't 
	support call waiting.
-	The test setup can't be completed due to an expected error. 
	Example: the test setup requires to have a active call but 
	this call can't be connected because the network is too busy.
No actions require, the test is correct and may pass on others 
condition/configuration.

ETestSuiteError: (UNKNOWN)
-	The test setup can't be completed due to an unexpected error
	or leave. Example: the test setup requires to have a line 
	status change notification active but the call to activate 
	this notification returned an error.
There is a problem with the test setup that must be investigated.

EIgnore: (UNEXECUTED)
-	The test fails for a known reason, but it cannot be fixed in 
	the near future. Example: there is a known problem with the 
	baseband that makes the test fail.

EAbort: (ABORT)
-	Generated by TEF when a test timeout
*/

/*************************************************************************************
INSTRUCTIONS on good use of MACROS!

1) Only use CHECK_XXX macros between SET UP and SET UP END sections of doTestStepL.
2) Only use ASSERT_XXXX macros in procedure section of doTestStepL I.e. Between TEST START and TEST END.
3) Use ASSERT_EQUALS_XX where possible as this will automatically log out actual and expected values on failure.
4) Do not use ASSERT_TRUE for testing equality of simple types.  This is because on failure it will not data. Prefer ASSERT_EQUALS_XX instead.
5) Comparison of complex types (e.g. TMobileCallInfoV1) can either be compared on each field (so would use ASSERT_EQUALS_XX) or a comparator obect can be created
   and ASSERT_TRUE used.  E.g  ASSERT_TRUE(cmpObj.IsEqual(ELogError), _L("Failed kkk"));
6) If comparator object is used the IsEquals() should be passed ELogError to ensure data is logged on failure.
*************************************************************************************/



/**
description: ASSERT_EQUALS may be used to test equality of two values.  <result> argument may also be an expression returning a simple type.
usage: For testing equality of simple types, e.g. TInt, TBool, TReal, caps, enums.
exceptions: Not for use for testing equality of complex types e.g TMobileCallInfoV1.  Use ASSERT_TRUE with a TCmpBase derived comparator class
exceptions: Not for use for testing equality of descriptors.  See ASSERT_EQUALS_DES8 and ASSERT_EQUALS_DES16.
logging: when comparison fails macro will log out the actual and expected values that have been compared. 
		 E.g. "FAILURE: Got 0, Expected 3 : my error22."
example: ASSERT_EQUALS(RMobileCall::EMulticallNotSupported, RMobileCall::EMulticallNotSupported, _L("my error4."));
example: ASSERT_EQUALS(DoSomething(), 3, _L("my error22."));
example: ASSERT_EQUALS(-5, KErrNotSupported, _L("my error4."));

@param result. simple value to compare
@param expected. expected value to test against
@param msg. string to print out if comaprison fails.
*/
#define ASSERT_EQUALS(result, expected, msg)														\
    {																								\
    if(!assert_equals(Logger(),((TText8*)__FILE__), __LINE__, ESevrErr, result, expected, msg)) 	\
	    { 																							\
	    SetAssertResult();				 															\
        } 																							\
    }


/**
description: ASSERT_EQUALS_DES8 may be used to test equality of two 8-bit descriptors.  <result> argument may also be an expression returning a 8-bit descriptor.
usage: For testing equality of 8-bit descriptors e.g. TDes8, TDesC8, TBuf8. 
exception: Not for use for testing equality of complex types e.g TMobileCallInfoV1.  Use ASSERT_TRUE with a TCmpBase derived comparator class
exception: Not for use for testing equality simple types.  See ASSERT_EQUALS.
exception: Not for use for testing equality of 16-bit descriptors.  See ASSERT_EQUALS_DES16.
logging: when comparison fails macro will log out the actual and expected values that have been compared. 
		 E.g. "FAILURE: Got bbbbbbbbbbbbbbbbbbbb, Expected cccccccccccccccccccc : my error44."
		 Logging will truncate logged strings to length KMaxLogCharLength.
example: ASSERT_EQUALS_DES8(buf1, buf2, _L("my error4."));

@param result. TDes8 value to compare
@param expected. expected value to test against
@param msg. string to print out if comaprison fails.
*/    		
#define ASSERT_EQUALS_DES8(result, expected, msg)																\
    {																											\
    if(!assert_equals_des8(Logger(),((TText8*)__FILE__), __LINE__, ESevrErr, result, expected, msg)) 	\
	    { 																										\
	    SetAssertResult();				 																		\
        }																										\
    }

    
/**
description: ASSERT_EQUALS_DES16 may be used to test equality of two 16-bit descriptors.  <result> argument may also be an expression returning a 16-bit descriptor.
usage: For testing equality of 16-bit descriptors e.g. TDes16, TDesC16, TBuf16. 
exception: Not for use for testing equality of complex types e.g TMobileCallInfoV1.  Use ASSERT_TRUE with a TCmpBase derived comparator class
exception: Not for use for testing equality simple types.  See ASSERT_EQUALS.
exception: Not for use for testing equality of 8-bit descriptors.  See ASSERT_EQUALS_DES8.
logging: when comparison fails macro will log out the actual and expected values that have been compared. 
		 E.g. "FAILURE: Got bbbbbbbbbbbbbbbbbbbb, Expected cccccccccccccccccccc : my error44."
		 Logging will truncate logged strings to length KMaxLogCharLength.
example: ASSERT_EQUALS_DES16(buf1, buf2, _L("my error4."));

@param result. TDes16 value to compare
@param expected. expected value to test against
@param msg. string to print out if comaprison fails.
*/ 
#define ASSERT_EQUALS_DES16(result, expected, msg)															\
    {																										\
    if(!assert_equals_des16(Logger(),((TText8*)__FILE__), __LINE__, ESevrErr, result, expected, msg)) 		\
	    { 																									\
	    SetAssertResult();																					\
	    }																									\
	}

/**
description: ASSERT_TRUE may be used to test for true statements.  <value> argument may also be an expression returning a bool.
			 This macro should be used for testing inequality statements holding true e.g. >,<,>=, <=
usage: For testing boolean true.  This macro should be used when checking for equality in TCmpBase and TCapsCmpBase derived classes for complex types.
exception: Not for use for testing equality of simple types or descriptor types. Use one of ASSERT_EQUALS_XXX macros.
logging: Does not log input values.  Will only log message below concatonated with <msg>
		 E.g. "FAILURE: Expected true : <msg>."
example: ASSERT_TRUE(5>3, _L("my error4."));
example: ASSERT_TRUE(cmpObj.IsEqual(ELogError), _L("Failed kkk"));

@param value. to check for boolean true.
@param msg. string to print out if check fails.
*/
_LIT(KAssertTrueText, "FAILURE: Expected true : %S");

#define ASSERT_TRUE(value, msg)														\
	{																				\
	TBool result = value;															\
	if (!result)																	\
	    {																			\
	    TPtrC m = (msg);															\
	    ERR_PRINTF2(KAssertTrueText, &m);											\
	    SetAssertResult();															\
	    }																			\
	}						


/**
description: ASSERT_BITS_SET may be used to test correct capbilities set in a bitmask.  
usage: For comparison of actual bitmask with expected bitmask. Comparison is based on matching wanted and unwanted bits.  All other bits are ignored.
logging: when check fails macro will logs out actual bit mask and wanted and unwanted bitmasks.
		 E.g. "FAILURE: Wrong bits set : Got 0x19 , required 0x10, unwanted 0x2 : <msg>"
example: ASSERT_BITS_SET(dynCaps, expectedCaps, unwantedCaps, _L("Wrong dynamic caps"))

@param value. bitmaks to check.
@param wantedBits. wanted bits in value mask
@param unwantedBits. Unwanted bits in value mask.
@param msg. string to print out if check fails.
*/

/**
 * Use this in the ASSERT_BITS_SET macro setting wantedBits to this value if
 * there are no wanted bits.
 */
const TUint KNoWantedBits = 0;
/**
 * Use this in the ASSERT_BITS_SET macro setting wantedBits to this value if
 * there are no unwanted bits.
 */
const TUint KNoUnwantedBits = 0;

_LIT(KAssertBitsSet, "FAILURE: Wrong bits set : Got 0x%x , required 0x%x, unwanted 0x%x : %S");

#define ASSERT_BITS_SET(value, wantedBits, unwantedBits, msg)						\
    {																				\
	if( (((value) & (wantedBits))  != (wantedBits)) ||								\
		(((value) & (unwantedBits)) != 0) )											\
		{																			\
		TPtrC m = (msg);															\
		ERR_PRINTF5(KAssertBitsSet, value, wantedBits, unwantedBits, &m);			\
		SetAssertResult();															\
		}																			\
    }

/**
 * Causes the test to leave if it has failed at this point.
 * When the test leaves, message msg is logged to the log file.
 * 
 * This macro should be used at a point in the test to cause
 * it to leave if there is no point in proceeding with the
 * test if it has already failed. Use sparingly!
 * 
 * Example: TEST_CHECK_POINT_L(_L("Could not dial a call."));
 */
_LIT(KTestCheckPointText, "TEST CHECK POINT FAILURE: %S");
#define TEST_CHECK_POINT_L(msg)					\
	{											\
	if (TestStepResult() != EPass)				\
		{										\
		TPtrC m = (msg);						\
		ERR_PRINTF2(KTestCheckPointText, &m);	\
		User::Leave(KErrGeneral);				\
		}										\
	};


// NOTE: These CHECK_XXX macros for test setup only, 
// to check a test pre-condidion. 
// To be used between SET UP and SET UP END in test step.

_LIT(KCheckText, "SET UP FAILURE: %S");

#define CHECK_TRUE_L(cond, msg)														\
    if(!(cond)) 																	\
	    { 																			\
		TPtrC m = (msg);															\
	    WARN_PRINTF2(KCheckText, &m); 												\
	    SetCheckResultL();															\
        } 		


#define CHECK_EQUALS_L(result, expected, msg)														\
    {																								\
    if(!assert_equals(Logger(),((TText8*)__FILE__), __LINE__, ESevrErr, result, expected, msg)) 		\
	    { 																							\
	    SetCheckResultL();				 															\
        } 																							\
    }


_LIT(KCheckBitsSetText, "SET UP FAILURE: Got 0x%x , required 0x%x, unwanted 0x%x : %S");

#define CHECK_BITS_SET_L(value, wantedBits, unwantedBits, msg)						\
    {																				\
	if ((((value) & wantedBits) != wantedBits) ||									\
		(((value) & unwantedBits) != 0))											\
		{																			\
		TPtrC m = (msg);															\
		WARN_PRINTF5(KCheckBitsSetText, value, wantedBits, unwantedBits, &m);		\
		SetCheckResultL();															\
		}																			\
    }	


/*
 * Debug logging macros.
 * 
 * These macros wrap around the regular INFO_PRINTFX macros defined in TestExecute
 * but allow logging to be turned on or off depending on whether
 * the ENABLE_DEBUG_LOGGING macro is defined in the mmp file. 
 */
#ifdef ENABLE_DEBUG_LOGGING

	#ifndef ENABLE_COMMS_DEBUG_UTIL_LOGGING // Route logging to TEF script
		#define DEBUG_PRINTF1(p1)				INFO_PRINTF1(p1)
		#define DEBUG_PRINTF2(p1, p2)			INFO_PRINTF2(p1, p2)
		#define DEBUG_PRINTF3(p1, p2, p3)		INFO_PRINTF3(p1, p2, p3)
		#define DEBUG_PRINTF4(p1, p2, p3, p4)	INFO_PRINTF4(p1, p2, p3, p4)
	#else // Route logging to CommsDebugUtil and to TEF log file

		#include <comms-infras/commsdebugutility.h>

		_LIT8(KTSYSubSystem, "tsy");
		_LIT8(KTSYCompnt, "ctsytest");

		#define DEBUG_PRINTF1(AAA)             { __FLOG_STATIC0(KTSYSubSystem, KTSYCompnt, (AAA)); INFO_PRINTF1(AAA); }
		#define DEBUG_PRINTF2(AAA,BBB)         { __FLOG_STATIC1(KTSYSubSystem, KTSYCompnt, (AAA), (BBB)); INFO_PRINTF2(AAA, BBB); }
		#define DEBUG_PRINTF3(AAA,BBB,CCC)     { __FLOG_STATIC2(KTSYSubSystem, KTSYCompnt, (AAA), (BBB), (CCC)); INFO_PRINTF3(AAA, BBB, CCC); }
		#define DEBUG_PRINTF4(AAA,BBB,CCC,DDD) { __FLOG_STATIC3(KTSYSubSystem, KTSYCompnt, (AAA), (BBB), (CCC), (DDD)); INFO_PRINTF4(AAA, BBB, CCC, DDD); }
		
		#define DEBUG_HEX_PRINTF2(AAA)	   {RFileLogger::HexDump(KTSYSubSystem, KTSYCompnt, (AAA)); }	

	#endif // ENABLE_COMMS_DEBUG_UTIL_LOGGING

#else
	#define DEBUG_PRINTF1(p1)		
	#define DEBUG_PRINTF2(p1, p2)	
	#define DEBUG_PRINTF3(p1, p2, p3)
	#define DEBUG_PRINTF4(p1, p2, p3, p4)
#endif // ENABLE_DEBUG_LOGGING


/**
test helper functions
*/

_LIT(KAssertErrorEqualsText,"FAILURE: Got %d, Expected %d : %S"); 
_LIT(KAssertErrorEqualsTextDes,"FAILURE: Got %S, Expected %S : %S");
const TInt KMaxLogCharLength = 20;

template<class T>
inline TBool assert_equals(CTestExecuteLogger& aLogger, const TText8* aFile, TInt aLine, TInt aSeverity, T aRes, T aExp, TPtrC aMsg)
	{
	if(aRes != aExp)
		{
		aLogger.LogExtra(aFile, aLine, aSeverity, KAssertErrorEqualsText, aRes, aExp, &aMsg);
		return EFalse;
		}
	return ETrue;
	}
	

TBool assert_equals_des16(CTestExecuteLogger& aLogger, const TText8* aFile, TInt aLine, 
	TInt aSeverity, const TDesC& aRes, const TDesC& aExp, const TDesC& aMsg);

TBool assert_equals_des8(CTestExecuteLogger& aLogger, const TText8* aFile, 
	TInt aLine, TInt aSeverity, const TDesC8& aRes, const TDesC8& aExp, const TDesC& aMsg);


// Time constants
const TInt KOneSecond = 1000000;

/**
 * Timeouts
 */
enum TTimeDuration
	{
	ETimeShort = 5*KOneSecond, 		// Simple LTSY transaction
	ETimeMedium = 20*KOneSecond,	// Simple SIM access
	ETimeLong = 60*KOneSecond,		// When sending something to the network
	ETimeVeryLong = 120*KOneSecond	// Multiple network transactions or SIM access
	};

const TInt KTwentySeconds = 20*1000000;//deliberately not using KOneSecond in case it gets reduced to speed up tests.  Do not want to reduce time for user interaction.
class CRPSMaster;
class MRpsFunctorBase;
class CCTSYIntegrationTestSuiteStepBase : public CTestStep
/**
 * Base test step class from which all test steps inherit.
 */
	{
public:

	virtual ~CCTSYIntegrationTestSuiteStepBase();
	CCTSYIntegrationTestSuiteStepBase(CEtelSessionMgr& aEtelSessionMgr);

	virtual TVerdict doTestStepPreambleL(); 
	virtual TVerdict doTestStepPostambleL();

	void SetAssertResult();
	void SetCheckResultL();
	TInt WaitForRequestWithTimeOut(TEtelRequestBase& aRequestStatus,  TTimeDuration aTimeOut);
	
	void ConsolePrintL(const TDesC& aText );
	
	void DisplayUserInteractionPromptL(const TDesC& aText, TTimeDuration aTimeOut = ETimeMedium);
	
	inline void SetRpsHandle(CRPSMaster* aRPS) 
		{
		iRPS = aRPS;
		};
		
	inline void SetOwnNumbersManager(TOwnNumbersManager* aOwnNumbers)
		{
		iOwnNumbersCache.SetOwnNumbersManager(aOwnNumbers);
		};
		
	inline TBool UsingRps() const
		{
		// if the pointer to RPS is null, return false, else return true
		return ((iRPS==NULL)?EFalse:ETrue);
		}
	void GetRPSNumber(TEtelLine aLine, TPtrC& aNumber);
		
	//RPS dispatch requests
	TInt RPSDialNumberL(const TDesC& aNumToDial, TEtelLine aLine);
	TInt RPSRequestIncomingCallL(TEtelLine aLine);
	TInt RPSRequestIncomingCancelBeforeConnectL(TEtelLine aLine, TInt aDelay);
	TInt RPSRequestIncomingHangupAfterConnectL(TEtelLine aLine, TInt aDelay);
	TInt RPSAnswerNextCallThenHangupL(TEtelLine aLine, TInt aDelay);
	TInt RPSAnswerNextCallL(TEtelLine aLine);
	TInt RPSAnswerNextCallThenHoldL(TEtelLine aLine, TInt aDelay);
	TInt RPSIgnoreNextCallL(TEtelLine aLine);	
	TInt RPSHoldL(TEtelLine aLine, TInt aDelay);
	TInt RPSResumeL(TEtelLine aLine, TInt aDelay);
	TInt RPSHangupL(TEtelLine aLine, TInt aDelay);
	TInt RPSHangUpNextCallBeforeConnectL(TEtelLine aLine);
	TInt RPSEchoDataL(const TDesC& aDataToSend);
	TInt RPSRejectNextCallL(TEtelLine aLine);
	
	void AsyncExec(CThreadExec::MFunctor* aFunction);
	void SyncExec(CThreadExec::MFunctor* aFunction);
protected:
	void StartSetup();
	void StartTest();
	void StartCleanup();
	void RPSCleanupL();
	TInt ExecuteRemoteRequestL(MRpsFunctorBase& aRpsFunctor, const TDesC& aRpsCallMsg);
	TInt DoPauseL(const TDesC& aText, TTimeDuration aTimeout = ETimeMedium );
	TPtrC Number(TEtelLine aLine);

protected:
	CEtelSessionMgr& iEtelSessionMgr;

	TVerdict		iAssertResult;
	TVerdict		iCheckResult;
	CRPSMaster* iRPS;
	
	// Own Number Info
	TOwnNumbersCache iOwnNumbersCache;

	}; // class CCTSYIntegrationTestSuiteStepBase

#endif // __CCTSYINTEGRATIONTESTSUITEBASE_H__