/*

* 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:

*

*/

// INCLUDE FILES

#include <e32math.h>

#include <e32svr.h>

#include <StifTestModule.h>

#include "Test.h"

#include "StifTestEventInterface.h"

// EXTERNAL DATA STRUCTURES

//extern  ?external_data;

// EXTERNAL FUNCTION PROTOTYPES  

//extern ?external_function( ?arg_type,?arg_type );

// CONSTANTS

//const ?type ?constant_var = ?constant;

// MACROS

_LIT (KTooLongDesc, "CTestModuleTest::123456789012345678901234567890");

_LIT (KTooLongText, "123456789012345678901234567890123456789012345678901234567890123456789012345678901234567890");		// 90

_LIT (KAlmostTooLongText, "123456789012345678901234567890123456789012345678901234567890123456789012345678%d");	// 78+2

_LIT (KDesc, "TestModule");

_LIT (KStifMacro_1, "macro testing");

// LOCAL CONSTANTS AND MACROS

//const ?type ?constant_var = ?constant;

//#define ?macro_name ?macro_def

// MODULE DATA STRUCTURES

//enum ?declaration

//typedef ?declaration

// LOCAL FUNCTION PROTOTYPES

//?type ?function_name( ?arg_type, ?arg_type );

// FORWARD DECLARATIONS

//class ?FORWARD_CLASSNAME;

// ==================== LOCAL FUNCTIONS =======================================

/*

-------------------------------------------------------------------------------

    Function: <function name>

    Description: <one line description>

    <Description of the functionality 

    description continues and...

    continues>

    Parameters:	<arg1>: <in/out/inout>: <accepted values>: <Description>

    Return Values: <value_1: Description

		            value_n: Description line 1

			                 description line 2>

    Errors/Exceptions: <description how errors and exceptions are handled>

    Status: Draft

-------------------------------------------------------------------------------

*/

/*

<type function_name(

    <arg_type arg,>  

    <arg_type arg >)  	

    {

    // <comment>

    <code> 

    // <comment>

    <code>

    }

*/

/*

-------------------------------------------------------------------------------

    DESCRIPTION

    <This module contains the implementation of xxx class 

	member functions...>

-------------------------------------------------------------------------------

*/

// ================= MEMBER FUNCTIONS =========================================

/*

-------------------------------------------------------------------------------

    Class: CTestModuleTest

    Method: CTestModuleTest

    Description: Default constructor

    C++ default constructor can NOT contain any code, that

    might leave.

    Parameters:	None

    Return Values: None

    Errors/Exceptions: None

    Status: Draft

-------------------------------------------------------------------------------

*/

CTestModuleTest::CTestModuleTest()

    {

    return;

    }

/*

-------------------------------------------------------------------------------

    Class: CTestModuleTest

    Method: ConstructL

    Description: Symbian OS second phase constructor

    Symbian OS default constructor can leave.

    Parameters:	None

    Return Values: None

    Errors/Exceptions: <description how errors and exceptions are handled>

    Status: Draft

-------------------------------------------------------------------------------

*/

void CTestModuleTest::ConstructL()

    {

    return;

    }

/*

-------------------------------------------------------------------------------

    Class: CTestModuleTest

    Method: NewL

    Description: Two-phased constructor.

    Parameters:	None

    Return Values: CTestModuleTest*: new object

    Errors/Exceptions: <description how errors and exceptions are handled>

    Status: Draft

-------------------------------------------------------------------------------

*/

CTestModuleTest* CTestModuleTest::NewL()

    {

    CTestModuleTest* self = new (ELeave) CTestModuleTest();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

/*

-------------------------------------------------------------------------------

    Class: CTestModuleTest

    Method: ~CTestModuleTest

    Description: Destructor

    Parameters:	None

    Return Values: None

    Errors/Exceptions: None

    Status: Draft

-------------------------------------------------------------------------------

*/    

CTestModuleTest::~CTestModuleTest()

    {

    }

/*

-------------------------------------------------------------------------------

    Class: CTestModuleTest

    Method: Init

    Description: Initialization function

    Init is used to initialize the Test Module. 

    Parameters:	TName& aIniFile: in: <accepted values>:

                    Configuration file for the test module

    Return Values: KErrnone: No error

                    <value_1: Description

		            value_n: Description line 1

			                 description line 2>

    Errors/Exceptions: <description how errors and exceptions are handled>

    Status: Draft

-------------------------------------------------------------------------------

*/

TInt CTestModuleTest::InitL( TFileName& /* aIniFile */,

						    TBool /* aFirstTime*/ )

    {

//    TestModuleIf().Printf( 0, _L("CTestModuleTest::Init"), _L("Initializing"));

//    TestModuleIf().Printf( 0, _L("CTestModuleTest::Init"), _L("Done"));

    return KErrNone;

    }

/*

-------------------------------------------------------------------------------

    Class: CTestModuleTest

    Method: GetTestCases

    Description: Get test cases.

    GetTestCases is used to inquired test cases from the Test Module.

    Parameters:	const TName& aConfigFile: in: <accepted values>: 

                    Config file name descriptor

                CArrayPtrFlat<TTestCaseInfo>& aTestCases: out: 

                    <accepted values>: Array of TestCases 

    Return Values: KErrNone: No error

                   <value_1: Description

		            value_n: Description line 1

			                 description line 2>

    Errors/Exceptions: <description how errors and exceptions are handled>

    Status: Draft

-------------------------------------------------------------------------------

*/

TInt CTestModuleTest::GetTestCasesL( const TFileName& /* aConfigFile */, 

                                   RPointerArray<TTestCaseInfo>& aTestCases )

    {

	for ( TUint i = 0; i <KLastCase; i++)

		{

		TTestCaseInfo* tc = new ( ELeave ) TTestCaseInfo();    

		CleanupStack::PushL( tc );

		tc->iCaseNumber = i;

		tc->iTitle.Copy( CaseName(i) );

		aTestCases.Append( tc );

		CleanupStack::Pop( tc );

		}

    return KErrNone;

    }

/*

-------------------------------------------------------------------------------

    Class: CTestModuleTest

    Method: RunTestCase

    Description: Run a specified testcase.

    RunTestCase is used to run an individual test case specified 

    by aTestCase. Test cases that can be run are requested from 

    Test Module by GetTestCases method before calling RunTestCase.

    This method is synchronous and test case result is returned as 

    function return value (KErrNone = Passed).

    Parameters:	const TInt aCaseNumber: in: <accepted values>: Testcase number 

                const TDesC8& aConfig: in: <accepted values>: Configuration

    Return Values: KErrNone: Passed.

                    <value_1: Description

		            value_n: Description line 1

			                 description line 2>

    Errors/Exceptions: <description how errors and exceptions are handled>

    Status: Draft

-------------------------------------------------------------------------------

*/

TInt CTestModuleTest::RunTestCaseL( const TInt aCaseNumber, 

                                   const TFileName& aConfig,

								   TTestResult& aResult )

    {

    TInt execStatus = KErrNone;	

    TestModuleIf().Printf( 0, KDesc, _L("Enter"));

    TestModuleIf().Printf( 0, KDesc, 

            _L("Case number %i, aConfig: %S"), aCaseNumber, &aConfig );

	TEventIf event;            

    switch( aCaseNumber )

        {

		// A Passing case

		case KTestModuleCasePass:

		aResult.iResult = KErrNone;		

		break;

		// A failing case

		case KTestModuleCaseFail:

		aResult.iResult = KErrGeneral;		

		break;

		case KTestModuleOneLinePrint:        

        TestModuleIf().Printf( 0, KDesc,  _L("Simple print"));                

        aResult.iResult = KErrNone;        

        break;

		case KTestModuleSimplePrintParsing:        

        TestModuleIf().Printf( 0, KDesc,  _L("Simple print %d"), 0xdeaddead);                

        aResult.iResult = KErrNone;        

        break;

		case KTestModuleNegativePriorityPrint:        

        TestModuleIf().Printf( -1, KDesc,  _L("Simple print "));

        aResult.iResult = KErrNone;        

        break;

		case KTestModuleTooLongDescription:        

        TestModuleIf().Printf( 0, KTooLongDesc,  _L(""));

        aResult.iResult = KErrNone;        

        break;

		case KTestModuleTooLongText:        

        TestModuleIf().Printf( 0, KDesc,  KTooLongText);

        aResult.iResult = KErrNone;        

        break;

		case KTestModuleTooLongDescAndText:        

        TestModuleIf().Printf( 0, KTooLongDesc, KTooLongText);

        aResult.iResult = KErrNone;        

        break;

		case KTestModuleEmptyDescription:        

        TestModuleIf().Printf( 0, _L(""), _L("Something"));

        aResult.iResult = KErrNone;        

        break;

		case KTestmoduleEmptyText:        

        TestModuleIf().Printf( 0, KDesc, _L(""));

        aResult.iResult = KErrNone;        

        break;

		case KTestModuleEmptyDescriptionTwice:

        TestModuleIf().Printf( 0, _L(""), _L("Something"));

		TestModuleIf().Printf( 0, _L(""), _L("Something else"));

        aResult.iResult = KErrNone;        

        break;

		case KTestModulePrintParseOverflow:

		TestModuleIf().Printf( 0, KDesc, KAlmostTooLongText, 0xdeaddead );

		aResult.iResult = KErrNone;

		break;

		case KPrintQueueOverflow:

			{

			for (int i = 0; i < 100000;i++)

			{

			TestModuleIf().Printf( 0, KDesc, _L("") );

			}

		aResult.iResult = KErrNone;

		break;

			}

		case KPrintQueueOverflowWithLeave:

			{

			for (int i = 0; i < 100000;i++)

			{

			TestModuleIf().Printf( 0, KDesc, _L("") );

			}

			User::Leave(-1);

			aResult.iResult = KErrNone;

			break;

			}

		case KPrintQueueOverflowWithKill:

			{

			for (int i = 0; i < 100000;i++)

			{

			TestModuleIf().Printf( 0, KDesc, _L("") );

			}			       

			RThread t;

			t.Kill(-1);            

			aResult.iResult = KErrNone;

			break;

			}

        case KTestModulePrinting:

            {

            /* Simple print and wait loop */

            for( TInt i=0; i<10; i++)

                {

                TestModuleIf().Printf( 0, KDesc, 

                    _L("Complete in %i secs"), 10-i);

                User::After( 1000000 );

                }

            }

			aResult.iResult = KErrNone;

            break;

        case KTestModuleSleep:

            /* simple 10 sec sleeping */

            TestModuleIf().Printf( 0, KDesc, 

                _L("Sleep 10 secs"));

            User::After( 10000000 );

            break;

        case KTestModuleStateEventWait:

            {

            TestModuleIf().Printf( 0, KDesc, 

                _L("Request event"));

            event.Set( TEventIf::EReqEvent, 

                _L("TestModuleState1"), TEventIf::EState );

            User::LeaveIfError( TestModuleIf().Event( event ) );

            TestModuleIf().Printf( 0, KDesc, 

                _L("Wait event"));

            event.SetType( TEventIf::EWaitEvent );

            User::LeaveIfError( TestModuleIf().Event( event ) );

            TestModuleIf().Printf( 0, KDesc, 

                _L("Got event"));

            User::After( 3000000 );

            TestModuleIf().Printf( 0, KDesc, 

                _L("Release event"));

            event.SetType( TEventIf::ERelEvent );

            User::LeaveIfError( TestModuleIf().Event( event ) );

            }

			aResult.iResult = KErrNone;

            break;

        case KTestModuleStateEventSetAndUnset:

            {

            TestModuleIf().Printf( 0, KDesc, 

                _L("Set event"));

            event.Set( TEventIf::ESetEvent, 

                _L("TestModuleState1"), TEventIf::EState );

            User::LeaveIfError( TestModuleIf().Event( event ) );

            User::After( 4000000 );

            TestModuleIf().Printf( 0, KDesc, 

                _L("Unset event"));

            event.SetName( _L("TestModuleState1") );

            event.SetType( TEventIf::EUnsetEvent );

            User::LeaveIfError( TestModuleIf().Event( event ) );

            User::After( 200000 );

            }

			aResult.iResult = KErrNone;

            break;

        case KTestModuleEventWait:

            {

            TestModuleIf().Printf( 0, KDesc, 

                _L("Request event"));

            event.Set( TEventIf::EReqEvent, _L("TestModuleIndication1") );

            User::LeaveIfError( TestModuleIf().Event( event ) );

            TInt i = 1;

            FOREVER

                {

                TestModuleIf().Printf( 0, KDesc, 

                    _L("Wait event %i"), i);

                event.SetType( TEventIf::EWaitEvent );

                User::LeaveIfError( TestModuleIf().Event( event ) );

                TestModuleIf().Printf( 1, KDesc, 

                    _L("Got event %i"), i++);

                }

            TestModuleIf().Printf( 0, KDesc, 

                _L("Release event"));

            event.SetType( TEventIf::ERelEvent );

            User::LeaveIfError( TestModuleIf().Event( event ));

            }

			aResult.iResult = KErrNone;

            break;

        case KTestModuleEventSet:

            {

            event.Set( TEventIf::ESetEvent, _L("TestModuleIndication1") );