/*

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

*

*/

//  CLASS HEADER

#include "MT_GSFramework.h"

//  EXTERNAL INCLUDES

#include <EUnitMacros.h>

#include <EUnitDecorators.h>

//#include <..\..\..\..\GSFramework\src\GSParentContainer.cpp>

#include <APGCLI.H>	// RApaLsSession

#include "TestGSPlugin.h"

//  INTERNAL INCLUDES

const TUid KTestActiveViewId = {  0x10 };

const TUid KTestWhateverPubSubId = {  0x00 };

const TInt KTestWhateverPubSubKey = 0;

// CONSTRUCTION

MT_GSFramework* MT_GSFramework::NewL()

    {

    MT_GSFramework* self = MT_GSFramework::NewLC();

    CleanupStack::Pop();

    return self;

    }

MT_GSFramework* MT_GSFramework::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

MT_GSFramework::~MT_GSFramework()

    {

    }

// Default constructor

MT_GSFramework::MT_GSFramework()

    {

    }

// Second phase construct

void MT_GSFramework::ConstructL()

    {

    // The ConstructL from the base class CEUnitTestSuiteClass must be called.

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

void MT_GSFramework::SetupNone()

    {

    }

void MT_GSFramework::TeardownNone()

    {

    }

////////////////// CGSTabHelper test cases //////////////////////////////////

void MT_GSFramework::SetupTabHelperL(  )

    {

    iCGSTabHelper = CGSTabHelper::NewL();

    iPlugins = 	new (ELeave) CArrayPtrFlat<CGSPluginInterface>(2);

    iTabbedViews = 	new (ELeave) CArrayPtrFlat<MGSTabbedView>(2);

    }

void MT_GSFramework::TeardownTabHelper()

    {

    delete iCGSTabHelper;

    iCGSTabHelper = NULL;

    delete iPlugins;

    iPlugins = NULL;

    delete iTabbedViews;

    iTabbedViews = NULL;

    }

void MT_GSFramework::T_CGSTabHelper_NewLL()

    {

    CGSTabHelper* ptr = CGSTabHelper::NewL();

    EUNIT_ASSERT( ptr );

    delete ptr;

    }

void MT_GSFramework::T_CGSTabHelper_NewLCL()

    {

    CGSTabHelper* ptr = CGSTabHelper::NewLC();

    EUNIT_ASSERT( ptr );

    CleanupStack::PopAndDestroy();

    }

void MT_GSFramework::T_CGSTabHelper__CGSTabHelperL(  )

    {

    RHeap heap = User::Heap();

    TInt block = 0;

    TInt after;

    CGSTabHelper* th;

    TInt before = heap.Available( block );

    th = CGSTabHelper::NewL();

    delete th;

    after = heap.Available( block );

    TInt delta = before - after;

    EUNIT_ASSERT_DESC( before <= after, "Possible heap memory leak");

    }

void MT_GSFramework::T_CGSTabHelper_CreateTabGroupLL(  )

    {

    iCGSTabHelper->CreateTabGroupL( KTestActiveViewId, this );

    EUNIT_ASSERT_DESC( ETrue, "Tab group pseudo creation done");

    }

void MT_GSFramework::T_CGSTabHelper_CreateTabGroupL2L(  )

    {

    iCGSTabHelper->CreateTabGroupL( KTestActiveViewId, iPlugins );

    EUNIT_ASSERT_DESC( ETrue, "Run this far wihout panic?");

    }

void MT_GSFramework::T_CGSTabHelper_CreateTabGroupL3L(  )

    {

    iCGSTabHelper->CreateTabGroupL( KTestActiveViewId, iTabbedViews );

    EUNIT_ASSERT_DESC( ETrue, "Run this far without panic?");

    }

void MT_GSFramework::T_CGSTabHelper_RemoveTabGroupL(  )

    {

    iCGSTabHelper->RemoveTabGroup();

    EUNIT_ASSERT_DESC( ETrue, "Run this far without panic?");

    }

void MT_GSFramework::T_CGSTabHelper_TabChangedLL(  )

    {

    TInt tabIndex = 0;

    iCGSTabHelper->TabChangedL( tabIndex );

    EUNIT_ASSERT_DESC( ETrue, "Run this far without panic?");

    }

// MGSTabbedViewOwner

CArrayPtrFlat<CGSPluginInterface>* MT_GSFramework::TabbedViews()

	{

	return iPlugins;

	}

// MGSTabbedViewOwner

void MT_GSFramework::TabChangedL( TUid /*selectedTabUid*/ )

	{

	}

// MGSPluginLoadObserver

void MT_GSFramework::HandlePluginLoaded( KGSPluginLoaderStatus aStatus )

    {

    }

/////////////////////// CGSPluginLoader test cases ///////////////////////////////////

void MT_GSFramework::SetupPluginLoaderL()

    {

    iPlugins =  new (ELeave) CArrayPtrFlat<CGSPluginInterface>(2);

    CAknViewAppUi* appUi = (CAknViewAppUi*)CEikonEnv::Static()->EikAppUi();

    iCGSPluginLoader = CGSPluginLoader::NewL( appUi );

    }

void MT_GSFramework::TearDownPluginLoader()

    {

    delete iCGSPluginLoader;

    iCGSPluginLoader = NULL;

    delete iPlugins;

    iPlugins = NULL;

    }

void MT_GSFramework::T_CGSPluginLoader_NewL()

    {

    CAknViewAppUi* appUi = (CAknViewAppUi*)CEikonEnv::Static()->EikAppUi();

    iCGSPluginLoader = CGSPluginLoader::NewL( appUi );

    delete iCGSPluginLoader;

    iCGSPluginLoader = NULL;

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPluginLoader__CGSPluginLoader()

    {

    CAknViewAppUi* appUi = (CAknViewAppUi*)CEikonEnv::Static()->EikAppUi();

    iCGSPluginLoader = CGSPluginLoader::NewL( appUi );

    delete iCGSPluginLoader;

    iCGSPluginLoader = NULL;

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPluginLoader_LoadAsyncL()

    {

    iCGSPluginLoader->LoadAsyncL( KGSPluginInterfaceUid,

                                  KTestActiveViewId,

                                  iPlugins );

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPluginLoader_SetObserver()

    {

    iCGSPluginLoader->SetObserver( this );

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPluginLoader_AbortAsyncLoad()

    {

    iCGSPluginLoader->AbortAsyncLoad();

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPluginLoader_SortPluginsL()

    {

    iCGSPluginLoader->SortPluginsL( iPlugins );

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

/////////////// CGSParentContainer test cases //////////////////////////////

// CGSParentContainer

void MT_GSFramework::SetupParentContainerL()

	{

//    iGSParentContainer = new (ELeave) CGSParentContainer();

//    iGSParentContainer->ConstructL();

	}

void MT_GSFramework::TearDownParentContainer()

	{

//	delete iGSParentContainer;

//    iGSParentContainer = NULL;

	}

// CGSParentContainer test cases:

void MT_GSFramework::T_CGSParentContainer_FocusChanged()

	{

//    iGSParentContainer->FocusChanged( ENoDrawNow );

#pragma message("TODO: implement real test case!")

    EUNIT_ASSERT_DESC( EFalse, "Not implemented.");

	}

///////////////////// CGSPubSubsListener test cases ///////////////////////

void MT_GSFramework::SetupPubSubsListenerL()

    {

    iCGSPubSubsListener = CGSPubSubsListener::NewL( KTestWhateverPubSubId,

                                                    KTestWhateverPubSubKey,

                                                    this );

    }

void MT_GSFramework::TearDownPubSubsListener()

    {

    delete iCGSPubSubsListener;

    iCGSPubSubsListener = NULL;

    }

void MT_GSFramework::T_CGSPubSubsListener_NewL()

    {

    CGSPubSubsListener* psl = CGSPubSubsListener::NewL( KTestWhateverPubSubId,

            KTestWhateverPubSubKey,

            this );

    delete psl;

    psl = NULL;

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPubSubsListener__CGSPubSubsListener()

    {

    CGSPubSubsListener* psl = CGSPubSubsListener::NewL( KTestWhateverPubSubId,

            KTestWhateverPubSubKey,

            this );

    delete psl;

    psl = NULL;

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPubSubsListener_Get1()

    {

    TInt val = 0;

    iCGSPubSubsListener->Get( val );

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPubSubsListener_Get2()

    {

    TBuf8<25> buf;

    iCGSPubSubsListener->Get( buf );

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

void MT_GSFramework::T_CGSPubSubsListener_Get3()

    {

    TBuf16<25> buf;

    iCGSPubSubsListener->Get( buf );

    EUNIT_ASSERT_DESC( ETrue, "Run this far?");

    }

// From MGSSettingPSObserver

void MT_GSFramework::HandleNotifyPSL( const TUid aUid,

                                      const TInt& aKey,

                                      const TRequestStatus& aStatus )

    {

    }

// ------------------------------- Launch Gs application test cases ---------------------------------------//

void MT_GSFramework::SetupLaunch()

    {

    iPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );

    // Launch Gs application...

    RApaLsSession lsSession;

    User::LeaveIfError( lsSession.Connect() );

    CleanupClosePushL( lsSession );

	TApaAppInfo appInfo;

	TUid uid;

	uid.iUid = 0x100058EC;	// Gs application uid

	User::LeaveIfError( lsSession.GetAppInfo(appInfo, uid) );

    TFileName appName = appInfo.iFullName;

    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

    cmdLine->SetExecutableNameL( appName );

    cmdLine->SetCommandL( EApaCommandRun );

    User::LeaveIfError( lsSession.StartApp( *cmdLine ) );

    CleanupStack::PopAndDestroy( cmdLine );

    CleanupStack::PopAndDestroy();	// lsSession

    }

void MT_GSFramework::TeardownLaunch()

    {

    if ( !iPeriodic->IsActive() )

    	{

	    iPeriodic->Start( 2000000, 1000000, TCallBack( CloseTopMostWindow, static_cast<TAny*>( this ) ) );

    	}

    CActiveScheduler::Start();

	// Close the error note

	ikeySimulateCase = 0;

	iKeyNumber = 0;

    if ( !iPeriodic->IsActive() )

    	{

	    iPeriodic->Start( 2000000, 500000, TCallBack( SimulateKeyEvent, static_cast<TAny*>( this ) ) );

    	}

    CActiveScheduler::Start();

    if ( iPeriodic )

        {

        iPeriodic->Cancel();

        }

    delete iPeriodic;

    }

TBool MT_GSFramework::GetKeyCodeCase0( TKeyCode& aKeyCode )

	{

	TBool ret = ETrue;

    iKeyNumber++;

    switch ( iKeyNumber )

    	{

    	case 1:

    		aKeyCode = EKeyOK;

    		break;

    	default:

    		ret = EFalse;

    	}

    return ret;

	}

TInt MT_GSFramework::CloseTopMostWindow( TAny* aPtr )

    {

    MT_GSFramework* instL = static_cast<MT_GSFramework*>( aPtr );

    instL->DoCloseTopMostWindowL();

    CActiveScheduler::Stop();

	return KErrNone;

    }

void MT_GSFramework::DoCloseTopMostWindowL()

	{

	RWsSession* ws = &CCoeEnv::Static()->WsSession();

    // Get a list of IDs of the all the window groups

    CArrayFixFlat<TInt>* windowList = new CArrayFixFlat<TInt>(4);

    CleanupStack::PushL(windowList);

    // Get a list of window group IDs

    User::LeaveIfError(ws->WindowGroupList(0, windowList));

    // Get the top most window group

    TInt wgId = (*windowList)[0];

	CleanupStack::PopAndDestroy(); // windowList

	TApaTask task(*ws);

	task.SetWgId(wgId);

	task.SendSystemEvent(EApaSystemEventShutdown);

	iPeriodic->Cancel();

	}

TInt MT_GSFramework::SimulateKeyEvent( TAny* aPtr )

    {

    MT_GSFramework* instL = static_cast<MT_GSFramework*>( aPtr );

    instL->DoSimulateKeyEventL();

	return KErrNone;

    }

void MT_GSFramework::DoSimulateKeyEventL()

	{

	TKeyCode keyCode;

	TBool hasKey;

	switch ( ikeySimulateCase )

		{

		case 0:

			hasKey = GetKeyCodeCase0( keyCode );

			break;

		case 1:

			hasKey = GetKeyCodeCase1( keyCode );

			break;

		case 2:

			hasKey = GetKeyCodeCase2( keyCode );

			break;

		case 3:

			hasKey = GetKeyCodeCase3( keyCode );

			break;

		case 4:

			hasKey = GetKeyCodeCase4( keyCode );

			break;

		default:

			hasKey = EFalse;

		}

	if ( hasKey )

		{

	    TKeyEvent event;

	    event.iCode = keyCode;

	    event.iScanCode = 0;

	    event.iRepeats = 0;

	    event.iModifiers = 0;

		TWsEvent wsEvent;

		*( wsEvent.Key() ) = event;

		wsEvent.SetType( EEventKey );

		wsEvent.SetTimeNow();

		RWsSession*	ws = &CCoeEnv::Static()->WsSession();

		TInt wgId = ws->GetFocusWindowGroup();

		ws->SendEventToWindowGroup( wgId, wsEvent );

		}

	else

		{

		iPeriodic->Cancel();

		CActiveScheduler::Stop();

		}

	}

void MT_GSFramework::LaunchGsApp1L()

	{

	ikeySimulateCase = 1;

	iKeyNumber = 0;

    if ( !iPeriodic->IsActive() )

    {

    iPeriodic->Start( 2000000, 1000000, TCallBack( SimulateKeyEvent, static_cast<TAny*>( this ) ) );

    }

    CActiveScheduler::Start();

	}