/*

* 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 "UT_CCFContextManager.h"

//  EXTERNAL INCLUDES

#include <EUnitMacros.h>

//  INTERNAL INCLUDES

#include "CFContextManager.h"

#include "CFContextIndication.h"

#include "CFContextSubscription.h"

#include "cfcontextobjectimpl.h"

// CONSTRUCTION

UT_CCFContextManager* UT_CCFContextManager::NewL()

    {

    UT_CCFContextManager* self = UT_CCFContextManager::NewLC();

    CleanupStack::Pop();

    return self;

    }

UT_CCFContextManager* UT_CCFContextManager::NewLC()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// Destructor (virtual by CBase)

UT_CCFContextManager::~UT_CCFContextManager()

    {

    }

// Default constructor

UT_CCFContextManager::UT_CCFContextManager()

    {

    }

// Second phase construct

void UT_CCFContextManager::ConstructL()

    {

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

    // It generates the test case table.

    CEUnitTestSuiteClass::ConstructL();

    }

// INTERFACE IMPLEMENTATIONS

// from MCFContextSubscriptionListener

void UT_CCFContextManager::ContextIndicationL( 

	CCFContextIndication* aIndication )

	{

	iIndication = ETrue;

	delete iContextIndication;

	iContextIndication = aIndication;		

    }

// from MCFContextSubscriptionListener

TInt UT_CCFContextManager::Client( RThread& aThread ) const

	{

	aThread = RThread();

	return KErrNone;

	}

// from MCFContextSubscriptionListener

void UT_CCFContextManager::HandleContextSubscriptionError( TInt /*aError*/,

            const TDesC& /*aSource*/,

            const TDesC& /*aType*/ )

    {

    iSubscriptionError = ETrue;

    StopWait();

    }

// from MCFContextSource

void UT_CCFContextManager::Subscribers( const TDesC& aContextSource,

    const TDesC& aContextType )

	{

	iSubscribersCalled = ETrue;

	EUNIT_ASSERT_DESC( iExpectedSubscribersSource.Compare( aContextSource ) == 0,

			"No expected source");

	EUNIT_ASSERT_DESC( iExpectedSubscribersType.Compare( aContextType ) == 0,

			"No expected type");

	}

// from MCFContextSource

void UT_CCFContextManager::NoSubscribers( const TDesC& aContextSource,

    const TDesC& aContextType )

	{

	iNoSubscribersCalled = ETrue;

	EUNIT_ASSERT_DESC( iExpectedSubscribersSource.Compare( aContextSource ) == 0,

	"No expected source");

	EUNIT_ASSERT_DESC( iExpectedSubscribersType.Compare( aContextType ) == 0,

	"No expected type");

	}

// from MCFContextSource

void UT_CCFContextManager::HandleCommand(

    const CCFContextSourceCommand& /*aCommand*/ )

    {

    // Nothing to do.

    }

// from MCFSecurityChecker

TBool UT_CCFContextManager::CheckClientSecurity( const RThread& aClientThread,

	const TSecurityPolicy& aSecurityPolicy )

	{

    // Security check only needed if request is from other process than CF

    TBool securityPassed = ETrue;

    if ( iBypassSecurityCheck == 0 )

    	{

    	securityPassed = aSecurityPolicy.CheckPolicy( aClientThread );

    	}

    else

    	{

    	iBypassSecurityCheck--;	

    	}

    return securityPassed;

	}

//  METHODS

void UT_CCFContextManager::SetupForNewL(  )

    {

	iWait = new( ELeave ) CActiveSchedulerWait;

    }

void UT_CCFContextManager::StopWait()

	{

	if( iWait )

        {

        if( iWait->IsStarted() )

            {

            iWait->AsyncStop();

            }

        delete iWait;

        iWait = NULL;

        }	

	}

void UT_CCFContextManager::TeardownForNewL(  )

    {

	if( iWait )

        {

        if( iWait->IsStarted() )

            {

            iWait->AsyncStop();

            }

        delete iWait;

        iWait = NULL;

        }

    }

void UT_CCFContextManager::SetupL(  )

    {

	SetupForNewL();

	iCFContextManager = CCFContextManager::NewL( *this );

	iCFContextManagerInterface = iCFContextManager;

    }

void UT_CCFContextManager::Teardown(  )

    {

    delete iContextIndication;

    iContextIndication = NULL;

	delete iCFContextManager;

	iCFContextManagerInterface = NULL;

	iIndication = EFalse;

	iSubscriptionError = EFalse;

	iSubscribersCalled = EFalse;

	iNoSubscribersCalled = EFalse;

	TeardownForNewL();

    }

void UT_CCFContextManager::SetupContextCacheL()

	{

	RThread thread;

	CleanupClosePushL(thread);

	CCFContextObject* co = CCFContextObject::NewLC();

	static _LIT_SECURITY_POLICY_PASS( alwaysPass );

	static _LIT_SECURITY_POLICY_FAIL( alwaysFail );

	// CONTEXT 1

	co->SetSourceL(_L("SourceA"));

	co->SetTypeL(_L("TypeA"));

	co->SetValueL(_L("ValueBA"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysPass ) );

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT 2

	co->SetSourceL(_L("SourceB"));

	co->SetTypeL(_L("TypeA"));

	co->SetValueL(_L("ValueBA"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysPass ) );

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT 3

	co->SetSourceL(_L("SourceC"));

	co->SetTypeL(_L("TypeC"));

	co->SetValueL(_L("ValueCC"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysPass ) );

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT 4

	co->SetSourceL(_L("SourceC"));

	co->SetTypeL(_L("TypeD"));

	co->SetValueL(_L("ValueCD"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysPass ) );

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT 5

	co->SetSourceL(_L("SourceC"));

	co->SetTypeL(_L("TypeC.SubtypeA"));

	co->SetValueL(_L("ValueCCA"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysPass ) );

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT 6

	co->SetSourceL(_L("SourceC"));

	co->SetTypeL(_L("TypeC.SubtypeB"));

	co->SetValueL(_L("ValueCCB"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysPass ) );

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// bypass security check so that we publish context with high capabilities

	// CONTEXT  - no read or write access

	co->SetSourceL(_L("SourceE"));

	co->SetTypeL(_L("TypeE.NoaccessA"));

	co->SetValueL(_L("ValueEEA"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysFail, alwaysFail ) );

	iBypassSecurityCheck = 1;

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT - no write access

	co->SetSourceL(_L("SourceE"));

	co->SetTypeL(_L("TypeE.NoWriteAccessA"));

	co->SetValueL(_L("ValueEEA"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysFail ) );

	iBypassSecurityCheck = 1;

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT - no read access

	co->SetSourceL(_L("SourceE"));

	co->SetTypeL(_L("TypeE.NoReadAccessA"));

	co->SetValueL(_L("ValueEEA"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysFail, alwaysPass ) );

	iBypassSecurityCheck = 1;

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	// CONTEXT - full access

	co->SetSourceL(_L("SourceE"));

	co->SetTypeL(_L("TypeE.AccessB"));

	co->SetValueL(_L("ValueEEB"));

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->DefineContextL( co->Source(),

		co->Type(), alwaysPass, alwaysPass ) );

	iBypassSecurityCheck = 1;

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	CleanupStack::PopAndDestroy( co );

	CleanupStack::PopAndDestroy( &thread );

	}

TInt UT_CCFContextManager::FindContext(RContextObjectArray& aArray, 

	const TDesC& aSource, const TDesC& aType, const TDesC& aValue)

	{

	TInt index = KErrNotFound;

	for (TInt i = 0; i < aArray.Count(); i++)

		{

		if (aArray[i]->Source() == aSource &&

			aArray[i]->Type() == aType)

			{

			if (index == KErrNotFound)

				{

				index = i;

				if (aArray[i]->Value() == aValue)

					{

					return index;	

					}

				else

					{

					return -3; // found but wrong value!

					}

				}

			else 

				{

				index = -2; // Duplicate found!

				}

			}

		}

	return index;

	} 

// TESTS

void UT_CCFContextManager::UT_CCFContextManager_NewLL(  )

    {

    CCFContextManager* instance = CCFContextManager::NewL( *this );

    CleanupStack::PushL ( instance );

    EUNIT_ASSERT_DESC ( instance, "CCFContextManager not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void UT_CCFContextManager::UT_CCFContextManager_NewLCL(  )

    {

    CCFContextManager* instance = CCFContextManager::NewLC( *this );

    EUNIT_ASSERT_DESC ( instance, "CCFContextManager not created!" );

    CleanupStack::PopAndDestroy( instance );

    }

void UT_CCFContextManager::UT_CCFContextManager_PublishContextLL(  )

    {

	RThread thread;

	CleanupClosePushL(thread);

	CCFContextObject* co = CCFContextObject::NewLC();

	co->SetSourceL(_L("testsource"));

	co->SetTypeL(_L("testtype"));

	co->SetValueL(_L("testvalue"));

	EUNIT_ASSERT_LEAVE ( iCFContextManagerInterface

		->PublishContextL( *co, thread ) );

		//, "Context published succeed without defining!" );

	static _LIT_SECURITY_POLICY_PASS( alwaysPass );

	EUNIT_ASSERT_NO_LEAVE ( 

		iCFContextManagerInterface->DefineContextL( _L("testsource"),

		_L("testtype"), alwaysPass, alwaysPass ) );

	EUNIT_ASSERT_NO_LEAVE ( 

		iCFContextManagerInterface->PublishContextL( *co, thread ) );	

	CleanupStack::PopAndDestroy( co );

	CleanupStack::PopAndDestroy( &thread );

    }

void UT_CCFContextManager::UT_CCFContextManager_RequestContextL_2L(  )

    {

	RThread thread;

	CleanupClosePushL(thread);

	SetupContextCacheL();

	RContextObjectArray resultBuffer;

	resultBuffer.Reset();

	// QUERY 1

	CCFContextQuery* query = CCFContextQuery::NewLC( KNullDesC, KNullDesC );

	query->SetSourceL(_L("SourceC"));

	query->SetTypeL(_L("TypeC"));

    EUNIT_ASSERT_NO_LEAVE( 

    	iCFContextManagerInterface->RequestContextL(

    	resultBuffer,

        *query,

        thread )

		);

	EUNIT_ASSERT_DESC( resultBuffer.Count() == 1, 

		"More than 1 context returned!" );

	TInt index = FindContext(resultBuffer, _L("SourceC"), _L("TypeC"), _L("ValueCC"));

	EUNIT_ASSERT_DESC( index >= 0, "ResultError!" );

	// QUERY 2

	query->SetSourceL(_L("SourceC"));

	query->SetTypeL(_L(""));

	resultBuffer.Reset();

	query->SetSubTypeMatch(ETrue);

	EUNIT_ASSERT_NO_LEAVE( 

    	iCFContextManagerInterface->RequestContextL(

    	resultBuffer,

        *query,

        thread )

		);

	EUNIT_ASSERT_DESC( resultBuffer.Count() == 4, 

		"Did not return 4 contexts!" );

	index = FindContext(resultBuffer, _L("SourceC"), _L("TypeC"), _L("ValueCC"));

	EUNIT_ASSERT_DESC( index >= 0, "ResultError!" );

	index = FindContext(resultBuffer, _L("SourceC"), _L("TypeD"), _L("ValueCD"));

	EUNIT_ASSERT_DESC( index >= 0, "ResultError!" );

	index = FindContext(resultBuffer, _L("SourceC"), _L("TypeC.SubtypeA"), _L("ValueCCA"));

	EUNIT_ASSERT_DESC( index >= 0, "ResultError!" );

	index = FindContext(resultBuffer, _L("SourceC"), _L("TypeC.SubtypeB"), _L("ValueCCB"));

	EUNIT_ASSERT_DESC( index >= 0, "ResultError!" );

	resultBuffer.Close();

	CleanupStack::PopAndDestroy( query );

	CleanupStack::PopAndDestroy( &thread );

    }

void UT_CCFContextManager::UT_CCFContextManager_DefineContextLL(  )

    {

	RThread thread;

	CleanupClosePushL(thread);

	// define context 1

	static _LIT_SECURITY_POLICY_PASS( alwaysPass );

	EUNIT_ASSERT_NO_LEAVE ( 

		iCFContextManagerInterface->DefineContextL( _L("testsource"),

		_L("testtype"), alwaysPass, alwaysPass ) );

	// try to redefine 

    EUNIT_ASSERT_NO_LEAVE ( 

		iCFContextManagerInterface->DefineContextL( _L("testsource"),

		_L("testtype"), alwaysPass, alwaysPass ) );

	CleanupStack::PopAndDestroy( &thread );	

    }

void UT_CCFContextManager::UT_CCFContextManager_DefineContextL2L(  )

    {

	RThread thread;

	CleanupClosePushL(thread);

	TUid uid = TUid::Uid( 123 );

	// define context 1

	static _LIT_SECURITY_POLICY_PASS( alwaysPass );

	EUNIT_ASSERT_NO_LEAVE ( 

		iCFContextManagerInterface->DefineContextL( _L("testsource"),

		_L("testtype"), alwaysPass, alwaysPass, this, uid ) );

	// try to redefine 

	EUNIT_ASSERT_NO_LEAVE ( 

		iCFContextManagerInterface->DefineContextL( _L("testsource"),

		_L("testtype"), alwaysPass, alwaysPass, this, uid ) );

	// try to redefine with another UID

	TUid anotherUid = TUid::Uid( 345 );

	EUNIT_ASSERT_LEAVE (

		iCFContextManagerInterface->DefineContextL( _L("testsource"),

		_L("testtype"), alwaysPass, alwaysPass, this, anotherUid ) );

	// check that we get the subscribers notification

	CCFContextSubscription* subscription = CCFContextSubscription::NewLC();

	subscription->SetContextSourceL(_L("testsource"));

	subscription->SetContextTypeL(_L("testtype"));

	CleanupStack::Pop( subscription );

	iSubscribersCalled = EFalse;

	iExpectedSubscribersSource.Copy(_L("testsource"));

	iExpectedSubscribersType.Copy(_L("testtype"));

	// make subscription	

	EUNIT_ASSERT_NO_LEAVE (

		iCFContextManagerInterface->SubscribeContextL(subscription,

		this, thread) );

	EUNIT_ASSERT( iSubscribersCalled );

	iSubscribersCalled = EFalse;

	iNoSubscribersCalled = EFalse;

	EUNIT_ASSERT_NO_LEAVE (

			iCFContextManagerInterface->RemoveSubscription( *subscription,