/**
* Copyright (c) 2008-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:
*
*/



/**
 @file lcfsbucommondefinitions.h
 @internalTechnology
*/
#ifndef _LCF_SBU_COMMON_DEFINITIONS_H_
#define _LCF_SBU_COMMON_DEFINITIONS_H_


///////////////////////////////////////////////////////
//
// Constants
//
///////////////////////////////////////////////////////


#define DUMMY_REQUESTOR_TYPE_ACCEPTED1        (CRequestor::ERequestorService)
#define DUMMY_REQUESTOR_FORMAT_ACCEPTED1      (CRequestor::EFormatApplication)
#define DUMMY_REQUESTOR_NAME_ACCEPTED1        (_L("TestService"))

#define DUMMY_REQUESTOR_TYPE_ACCEPTED2        (CRequestor::ERequestorContact)
#define DUMMY_REQUESTOR_FORMAT_ACCEPTED2      (CRequestor::EFormatTelephone)
#define DUMMY_REQUESTOR_NAME_ACCEPTED2        (_L("+123121234567"))



const TInt KDefaultTestTimeout = 5*1000*1000;        //5 seconds should be more than enough.

//0.00001;
#define KErrorToleranceValue KMinTReal64    

_LIT(KNoClientFault, "Kill");


///////////////////////////////////////////////////////
//
// Other text
//
///////////////////////////////////////////////////////

// Indicate not yet implemented
_LIT(KNotImplemented, "Not yet implemented");

_LIT(KBadDiagVerifEventNum, "Wrong number of Verification events in Notifier");
_LIT(KBadDiagNotifEventNum, "Wrong number of Notification events in Notifier");

#define CHECK_EQUAL_(_expected, _actual) \
    ERROR(_expected != _actual, "Equal check failed")

#define CHECK(_condition) ERROR(!(_condition), "Check failed")


#define CHECK_REAL_EQUAL_TOL(aExpected, aActual, aTolerance) \
    FAIL(Math::IsNaN(aActual) || Math::IsNaN(aExpected), "One or two of compared values is NaN!") \
    CHECK(Abs(aActual - aExpected) < aTolerance)

#define CHECK_REAL_EQUAL(aExpected, aActual) \
    CHECK_REAL_EQUAL_TOL(aExpected, aActual, KErrorToleranceValue)

#define CHECK_PANIC(aCondition) \
    if (!(aCondition)) CheckPanic(__FILE__, __LINE__);

#define DO_PANIC_TEST_L(aThreadFunction, aExpectedExitCat, aExpectedExitReason, aTimeoutValue) \
    DO_PANIC_TEST_L_PTR(aThreadFunction, aExpectedExitCat, aExpectedExitReason, aTimeoutValue, NULL)

#define DO_PANIC_TEST_L_PTR(aThreadFunction, aExpectedExitCat, aExpectedExitReason, \
    aTimeoutValue, aAnyPtr) \
    { \
    TExitCategoryName exitName = TPtrC(aExpectedExitCat).Left(KMaxExitCategoryName); \
    DoPanicTestL(aThreadFunction, exitName, aExpectedExitReason, aTimeoutValue, aAnyPtr); \
    }

///////////////////////////////////////////////////////
//
// Here are macros for error logging 
// Those imply that are called from within of 
// TEF class's function (they use (INFO/ERR)PRINTF member)
//
///////////////////////////////////////////////////////

// LEAVES with _error_ if _condition_ is true
#define FAIL(condition, error)             \
    if (condition) {                        \
        errStr.Format(_L("%s (line %d)"), _S(error), __LINE__);    \
        ERR_PRINTF1(errStr);				\
		SetTestStepResult(EFail);           \
    }


// Must be included in the begining of function definitions
// in order to use following ("ERROR") macros
// (The string buffer needs to be defined once, otherwise,
// in case when a lot of errors are checked, stack may be
// overflown, and copilation will fail)
#define DECLARE_ERROR_STR                   TBuf<160> errStr;
#define DECLARE_MESSAGE_STR                 TBuf<160> message;

#define DECLARE_ERROR_LOGGING               DECLARE_ERROR_STR   DECLARE_MESSAGE_STR

#define START_ERROR_LOGGING                 iErrorCounter = 0;

// Logs a message, which is defined as "..." constant
#define LOG(msg)                            \
    {                                       \
        errStr.Format(_L("%s (line %d)"), _S(msg), __LINE__);    \
        INFO_PRINTF1(errStr);                  \
    }
#define LOG_DES(msg_des)                    \
    {                                       \
        errStr.Format(_L("%S (line %d)"), &msg_des, __LINE__);    \
        INFO_PRINTF1(errStr);                  \
    }

#define LOG_IIF(condition, msg1, msg2)      \
    if (condition) LOG(msg1) else LOG(msg2)

// Logs an error, which is defined as "..." constant
#define ERR(error)                          \
    {                                       \
        errStr.Format(_L("%s (line %d)"), _S(error), __LINE__);    \
        ERR_PRINTF1(errStr);             \
        SetTestStepResult(EFail);			\
    }
#define ERR_DES(error)                      \
    {                                       \
        errStr.Format(_L("%S (line %d)"), &error, __LINE__);    \
        ERR_PRINTF1(errStr);             \
        SetTestStepResult(EFail);			\
    }

// Logs an _error_ if _condition_ is true
#define ERROR(condition, error)             \
    if (condition) ERR(error)

// Logs an error, which defined as descriptor
#define ERROR_DES(condition, error_des)     \
    if (condition) ERR_DES(error_des)

#define ERROR_1(condition, msg_fmt_des, param1)  \
    message.Format(msg_fmt_des, param1);        \
    ERROR_DES(condition, message);

#define ERROR_2(condition, msg_fmt_des, param1, param2)  \
    message.Format(msg_fmt_des, param1, param2);        \
    ERROR_DES(condition, message);

#define ERROR_3(condition, msg_fmt_des, param1, param2, param3) \
    message.Format(msg_fmt_des, param1, param2, param3);        \
    ERROR_DES(condition, message);

#define IF_ERROR(error_code, msg)                               \
    { TInt32 _err = error_code;                                 \
    ERROR_2(_err != KErrNone, _L("%s (error=%d)"), _S(msg), _err); }

#define IF_ERROR_DES(error_code, msg_des)                       \
    { TInt32 _err = error_code;                                 \
    ERROR_2(_err != KErrNone, _L("%S (error=%d)"), &msg_des, _err); }

#define CHECK_EQUAL(_actual, _expected, _msg)                     \
    ERROR_3(_actual != _expected, _L("%s (actual=%d, expected=%d)"), _S(_msg), _actual, _expected);

#define CHECK_EQUAL_DES(_actual, _expected, _msg_des)           \
    ERROR_3(_actual != _expected, _L("%S (actual=%d, expected=%d)"), &_msg_des, _actual, _expected);


#endif // _LCF_SBU_COMMON_DEFINITIONS_H_