--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/contextframework/cfw/tsrc/public/basic/UT_CCFEngine/UT_CCFEngine.cpp Tue Feb 02 10:12:00 2010 +0200
@@ -0,0 +1,578 @@
+/*
+* Copyright (c) 2007 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 "UT_CCFEngine.h"
+#include "CFTestDelay.h"
+
+// EXTERNAL INCLUDES
+#include <EUnitMacros.h>
+#include <ECom/ECom.h>
+
+// INTERNAL INCLUDES
+#include "CFEngine.h"
+#include "cftestcontextlistener.h"
+#include "CFContextInterface.h"
+#include "CFContextSubscription.h"
+#include "CFContextIndication.h"
+#include "cfenvutils.h"
+
+// CONSTANTS
+const TInt KSecond = 1000000;
+
+// CONSTRUCTION
+UT_CCFEngine* UT_CCFEngine::NewL()
+ {
+ UT_CCFEngine* self = UT_CCFEngine::NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+UT_CCFEngine* UT_CCFEngine::NewLC()
+ {
+ UT_CCFEngine* self = new( ELeave ) UT_CCFEngine();
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ return self;
+ }
+
+// Destructor (virtual by CBase)
+UT_CCFEngine::~UT_CCFEngine()
+ {
+ // Enable screen saver
+ CFEnvUtils::EnableScreenSaver( ETrue );
+ }
+
+// Default constructor
+UT_CCFEngine::UT_CCFEngine()
+ {
+ }
+
+// Second phase construct
+void UT_CCFEngine::ConstructL()
+ {
+ // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+ // It generates the test case table.
+ CEUnitTestSuiteClass::ConstructL();
+
+ // Disable screen saver
+ CFEnvUtils::EnableScreenSaver( EFalse );
+ }
+
+
+// INTERFACE IMPLEMENTATIONS
+
+// from MCFContextSubscriptionListener
+void UT_CCFEngine::ContextIndicationL( CCFContextIndication* aIndication )
+ {
+ iIndication = ETrue;
+ delete aIndication;
+
+ if ( iRemoveSubscription )
+ {
+ iCFContextInterface->UnsubscribeContext( *iRemoveSubscription, *this);
+ iRemoveSubscription = NULL;
+ }
+ if ( iRemoveSubscriptions )
+ {
+ iCFContextInterface->UnsubscribeContexts( *this );
+ }
+ }
+
+// from MCFContextSubscriptionListener
+TInt UT_CCFEngine::Client( RThread& aThread ) const
+ {
+ aThread = RThread();
+ return KErrNone;
+ }
+
+// from MCFContextSubscriptionListener
+void UT_CCFEngine::HandleContextSubscriptionError( TInt /*aError*/,
+ const TDesC& /*aSource*/,
+ const TDesC& /*aType*/ )
+ {
+ iSubscriptionError = ETrue;
+ StopWait();
+ }
+
+
+// from MCFSecurityChecker
+TBool UT_CCFEngine::CheckClientSecurity( const RThread& aClientThread,
+ const TSecurityPolicy& aSecurityPolicy )
+ {
+ // Security check only needed if request is from other process than CF
+ TBool securityPassed = ETrue;
+
+ if ( iDoSecurityCheck > 0 )
+ {
+ iDoSecurityCheck--;
+ securityPassed = aSecurityPolicy.CheckPolicy( aClientThread );
+ }
+ return securityPassed;
+ }
+
+
+// METHODS
+
+
+
+void UT_CCFEngine::SetupForNewL( )
+ {
+ iWait = new( ELeave ) CActiveSchedulerWait;
+ iTestDelay = CCFTestDelay::NewL();
+ }
+
+void UT_CCFEngine::StopWait()
+ {
+ if( iWait )
+ {
+ if( iWait->IsStarted() )
+ {
+ iWait->AsyncStop();
+ }
+ delete iWait;
+ iWait = NULL;
+ }
+ }
+
+void UT_CCFEngine::TeardownForNewL( )
+ {
+ iTestDelay->Start( KSecond );
+
+ delete iTestDelay;
+ iTestDelay = NULL;
+ if( iWait )
+ {
+ if( iWait->IsStarted() )
+ {
+ iWait->AsyncStop();
+ }
+ delete iWait;
+ iWait = NULL;
+ }
+
+#ifdef __WINS__
+ REComSession::FinalClose();
+#endif
+ }
+
+void UT_CCFEngine::SetupL( )
+ {
+ SetupForNewL();
+ iCFEngine = CCFEngine::NewL( *this );
+ iCFContextInterface = (MCFContextInterface*) iCFEngine;
+
+ iTestDelay->Start( KSecond * 2 );
+ }
+
+void UT_CCFEngine::Teardown( )
+ {
+ delete iCFEngine;
+ iCFEngine = NULL;
+ iCFContextInterface = NULL;
+ iIndication = EFalse;
+ iSubscriptionError = EFalse;
+ TeardownForNewL();
+ }
+
+void UT_CCFEngine::UT_CCFEngine_NewLL( )
+ {
+ CCFEngine* engine = CCFEngine::NewL( *this );
+
+ CleanupStack::PushL( engine );
+
+ EUNIT_ASSERT_DESC( engine, "CFEngine not created!" );
+
+ iTestDelay->Start( KSecond * 4 );
+
+ CleanupStack::PopAndDestroy();
+ }
+
+void UT_CCFEngine::UT_CCFEngine_NewLCL( )
+ {
+ CCFEngine* engine = CCFEngine::NewLC( *this );
+
+ EUNIT_ASSERT_DESC( engine, "CFEngine not created!" );
+
+ iTestDelay->Start( KSecond * 2 );
+
+ CleanupStack::PopAndDestroy(engine);
+ }
+
+void UT_CCFEngine::UT_PublishContextL( )
+ {
+ RThread thread;
+ CleanupClosePushL(thread);
+
+ CCFContextObject* co = CCFContextObject::NewLC();
+ co->SetSourceL(_L("testsource"));
+ co->SetTypeL(_L("testtype"));
+ co->SetValueL(_L("testvalue"));
+ TInt error = iCFContextInterface->PublishContext( *co, thread );
+ EUNIT_ASSERT_DESC ( error, "Context published succeed without defining!" );
+
+ static _LIT_SECURITY_POLICY_PASS( alwaysPass );
+ error = iCFContextInterface->DefineContext( _L("testsource"),
+ _L("testtype"), alwaysPass );
+
+ EUNIT_ASSERT_DESC ( !error, "Could not define context!" );
+
+ error = iCFContextInterface->PublishContext( *co, thread );
+ EUNIT_ASSERT_DESC ( !error, "Context published returned an error!" );
+
+ CleanupStack::PopAndDestroy( co );
+ CleanupStack::PopAndDestroy( &thread );
+ }
+
+
+
+void UT_CCFEngine::UT_SubscribeContextL()
+ {
+ RThread thread;
+ CleanupClosePushL(thread);
+
+ CCFContextSubscription* subscription = CCFContextSubscription::NewLC();
+ subscription->SetContextSourceL(_L("testsource"));
+ subscription->SetContextTypeL(_L("listenedtype"));
+ CleanupStack::Pop( subscription );
+
+ // make subscription
+ TInt error = iCFContextInterface->SubscribeContext(subscription,
+ this, thread);
+ EUNIT_ASSERT_DESC ( !error, "Subscription did not succeeded!");
+
+ // define context 1
+ static _LIT_SECURITY_POLICY_PASS( alwaysPass );
+ error = iCFContextInterface->DefineContext( _L("testsource"),
+ _L("notlistenedtype"), alwaysPass );
+ EUNIT_ASSERT_DESC ( !error, "Could not define context!" );
+
+ // define context 2
+ error = iCFContextInterface->DefineContext( _L("testsource"),
+ _L("listenedtype"), alwaysPass );
+ EUNIT_ASSERT_DESC ( !error, "Could not define context!" );
+
+
+ CCFContextObject* co = CCFContextObject::NewLC();
+ co->SetSourceL(_L("testsource"));
+ co->SetTypeL(_L("listenedtype"));
+ co->SetValueL(_L("testvalue"));
+ error = iCFContextInterface->PublishContext( *co, thread );
+ EUNIT_ASSERT_DESC ( !error, "Context publish returned an error!" );
+
+ iTestDelay->Start( KSecond / 2 );
+
+ // check that we get the published context
+ EUNIT_ASSERT_DESC ( iIndication, "Context indication did not arrive");
+ iIndication = EFalse;
+
+ //CCFContextObject* co = CCFContextObject::NewLC();
+ co->SetSourceL(_L("testsource"));
+ co->SetTypeL(_L("notlistenedtype"));
+ co->SetValueL(_L("testvalue"));
+ error = iCFContextInterface->PublishContext( *co, thread );
+ EUNIT_ASSERT_DESC ( !error, "Context publish returned an error!" );
+
+ // check that we did not get the published context
+ EUNIT_ASSERT_DESC ( !iIndication,
+ "Context indication arrived for context not listened!");
+
+
+ // Test subscription that fails later because of capabilities
+ // Cannot be tested from the same process because
+ // subscription from same process will always succeed.
+ /*
+ CCFContextSubscription* subscription2 = CCFContextSubscription::NewL();
+ subscription->SetContextSource(_L("testsource"));
+ subscription->SetContextType(_L("highcapabilities"));
+
+ error = iCFContextInterface->SubscribeContext(subscription2,
+ this, thread);
+ EUNIT_ASSERT_DESC ( !error, "Subscription did not succeeded!");
+
+ static _LIT_SECURITY_POLICY_FAIL( alwaysFail );
+ error = iCFContextInterface->DefineContext( _L("testsource"),
+ _L("highcapabilities"), alwaysFail );
+ EUNIT_ASSERT_DESC ( !error, "Could not define context!" );
+
+ iTestDelay->Start(1000000); // 1 seconds
+
+ EUNIT_ASSERT_DESC ( iSubscriptionError,
+ "Subscription remains although high capabilities required");
+
+ */
+
+ CleanupStack::PopAndDestroy( co );
+ CleanupStack::PopAndDestroy( &thread );
+ }
+
+void UT_CCFEngine::UT_RemoveContextSubscriptionL()
+ {
+ RThread thread;
+ CleanupClosePushL(thread);
+
+ CCFContextSubscription* subscription = CCFContextSubscription::NewLC();
+ subscription->SetContextSourceL(_L("testsource"));
+ subscription->SetContextTypeL(_L("listenedtype"));
+ CleanupStack::Pop( subscription );
+
+ // make subscription
+ TInt error = iCFContextInterface->SubscribeContext(subscription,
+ this, thread);
+ EUNIT_ASSERT_DESC ( !error, "Subscription did not succeeded!");
+
+ // define context
+ static _LIT_SECURITY_POLICY_PASS( alwaysPass );
+ error = iCFContextInterface->DefineContext( _L("testsource"),
+ _L("listenedtype"), alwaysPass );
+ EUNIT_ASSERT_DESC ( !error, "Could not define context!" );
+
+ iCFContextInterface->UnsubscribeContext(*subscription,
+ *this);
+ EUNIT_ASSERT_DESC ( !error, "Could not remove context subscription!" );
+
+ iTestDelay->Start( KSecond / 2 );
+
+ CCFContextObject* co = CCFContextObject::NewLC();
+ co->SetSourceL(_L("testsource"));
+ co->SetTypeL(_L("listenedtype"));
+ co->SetValueL(_L("testvalue"));
+ error = iCFContextInterface->PublishContext( *co, thread );
+ EUNIT_ASSERT_DESC ( !error, "Context publish returned an error!" );
+
+ iTestDelay->Start( KSecond / 2 );
+
+ // check that we get the published context
+ EUNIT_ASSERT_DESC ( !iIndication, "Context indication did arrive");
+ iIndication = EFalse;
+
+ CleanupStack::PopAndDestroy( co );
+ CleanupStack::PopAndDestroy( &thread );
+ }
+
+void UT_CCFEngine::UT_RemoveSubscriptionDuringIdicationL()
+ {
+ RThread thread;
+ CleanupClosePushL(thread);
+
+ CCFContextSubscription* subscription1 = CCFContextSubscription::NewLC();
+ subscription1->SetContextSourceL(_L("testsource"));
+ subscription1->SetContextTypeL(_L("listenedtype"));
+ CleanupStack::Pop( subscription1 );
+
+ // make the dummy subscription
+ TInt error = iCFContextInterface->SubscribeContext(subscription1,
+ this, thread);
+ EUNIT_ASSERT_DESC ( error == KErrNone, "Subscription did not succeeded!");
+
+ CCFContextSubscription* subscription2 = CCFContextSubscription::NewLC();
+ subscription2->SetContextSourceL(_L("testsource"));
+ subscription2->SetContextTypeL(_L("listenedtype"));
+ CleanupStack::Pop( subscription2 );
+
+ // make subscription
+ error = iCFContextInterface->SubscribeContext(subscription2, this, thread);
+ EUNIT_ASSERT_DESC ( error == KErrNone, "Subscription did not succeeded!");
+
+ // define context
+ static _LIT_SECURITY_POLICY_PASS( alwaysPass );
+ error = iCFContextInterface->DefineContext( _L("testsource"),
+ _L("listenedtype"), alwaysPass );
+ EUNIT_ASSERT_DESC ( error == KErrNone, "DefineContext did not succeeded!");
+
+ // Set remove susbcription that will be removed during next context
+ // indication
+ iRemoveSubscription = subscription1;
+
+ iIndication = EFalse;
+ CCFContextObject* co = CCFContextObject::NewLC();
+ co->SetSourceL(_L("testsource"));
+ co->SetTypeL(_L("listenedtype"));
+ co->SetValueL(_L("testvalue"));
+ error = iCFContextInterface->PublishContext( *co, thread );
+
+ iTestDelay->Start( KSecond / 2 );
+
+ // check that we get the published context
+ EUNIT_ASSERT_DESC ( iIndication, "Context indication shoud have arrived");
+ iIndication = EFalse;
+
+ CleanupStack::PopAndDestroy( co );
+ CleanupStack::PopAndDestroy( &thread );
+ }
+
+void UT_CCFEngine::UT_RemoveSubscriptionDuringIdication2L()
+ {
+ RThread thread;
+ CleanupClosePushL(thread);
+
+ CCFTestContextListener* listener = CCFTestContextListener::NewLC();
+
+ CCFContextSubscription* subscription1 = CCFContextSubscription::NewLC();
+ subscription1->SetContextSourceL(_L("testsource"));
+ subscription1->SetContextTypeL(_L("listenedtype"));
+ CleanupStack::Pop( subscription1 );
+
+ // make the dummy subscription
+ TInt error = iCFContextInterface->SubscribeContext(subscription1,
+ this, thread);
+ EUNIT_ASSERT_DESC ( error == KErrNone, "Subscription did not succeeded!");
+
+ CCFContextSubscription* subscription2 = CCFContextSubscription::NewLC();
+ subscription2->SetContextSourceL(_L("testsource"));
+ subscription2->SetContextTypeL(_L("listenedtype"));
+ CleanupStack::Pop( subscription2 );
+
+ // make subscription
+ error = iCFContextInterface->SubscribeContext(subscription2, this, thread);
+ EUNIT_ASSERT_DESC ( error == KErrNone, "Subscription did not succeeded!");
+
+ CCFContextSubscription* subscription3 = CCFContextSubscription::NewLC();
+ subscription3->SetContextSourceL(_L("testsource"));
+ subscription3->SetContextTypeL(_L("listenedtype"));
+ CleanupStack::Pop( subscription3 );
+
+ // make subscription with listener
+ error = iCFContextInterface->SubscribeContext(subscription3, listener, thread);
+ EUNIT_ASSERT_DESC ( error == KErrNone, "Subscription did not succeeded!");
+
+ // define context
+ static _LIT_SECURITY_POLICY_PASS( alwaysPass );
+ error = iCFContextInterface->DefineContext( _L("testsource"),
+ _L("listenedtype"), alwaysPass );
+ EUNIT_ASSERT_DESC ( error == KErrNone, "DefineContext did not succeeded!");
+
+ // Set remove susbcriptions flag so that all subscription from this
+ // (UT_CCFEngine) listener will be removed during next context indication.
+ iRemoveSubscriptions = ETrue;
+
+ EUNIT_ASSERT_DESC ( !listener->iLastIndication, "Separate listener should not have context indication");
+
+ iIndication = EFalse;
+ CCFContextObject* co = CCFContextObject::NewLC();
+ co->SetSourceL(_L("testsource"));
+ co->SetTypeL(_L("listenedtype"));
+ co->SetValueL(_L("testvalue"));
+ error = iCFContextInterface->PublishContext( *co, thread );
+
+ iTestDelay->Start( KSecond / 2 );
+
+ // check that we get the published context
+ EUNIT_ASSERT_DESC ( iIndication, "Context indication shoud have arrived");
+ iIndication = EFalse;
+ // check that separate listener class also received indication
+ EUNIT_ASSERT_DESC ( listener->iLastIndication, "Context indication shoud have arrived for separate listener");
+ EUNIT_ASSERT_DESC ( !listener->iSubscriptionError, "Subscription error for separate listener");
+
+ CleanupStack::PopAndDestroy( co );
+ CleanupStack::PopAndDestroy( listener );
+ CleanupStack::PopAndDestroy( &thread );
+ }
+
+void UT_CCFEngine::UT_DefineContextL()
+ {
+ RThread thread;
+ CleanupClosePushL( thread );
+ static _LIT_SECURITY_POLICY_PASS( alwaysPass );
+
+ // x. Define test context
+ //--------------------------------------------------------------------------
+ TInt err = iCFContextInterface->DefineContext(
+ _L("testsource"), _L("testtype"), alwaysPass );
+ EUNIT_ASSERT_DESC ( err == KErrNone, "Define context failed" );
+
+ // x. Re-define test context
+ //--------------------------------------------------------------------------
+ err = iCFContextInterface->DefineContext(
+ _L("testsource"), _L("testtype"), alwaysPass );
+ EUNIT_ASSERT_DESC ( err == KErrNone, "Define context failed" );
+
+ CleanupStack::PopAndDestroy( &thread );
+ }
+
+
+// TEST TABLE
+
+EUNIT_BEGIN_TEST_TABLE(
+ UT_CCFEngine,
+ "CCFEngine class unit test.",
+ "UNIT" )
+
+EUNIT_TEST(
+ "NewL - test ",
+ "CCFEngine",
+ "NewL",
+ "FUNCTIONALITY",
+ SetupForNewL, UT_CCFEngine_NewLL, TeardownForNewL)
+
+EUNIT_TEST(
+ "NewLC - test ",
+ "CCFEngine",
+ "NewLC",
+ "FUNCTIONALITY",
+ SetupForNewL, UT_CCFEngine_NewLCL, TeardownForNewL)
+
+EUNIT_TEST(
+ "PublishContext - test ",
+ "CCFEngine",
+ "PublishContext",
+ "FUNCTIONALITY",
+ SetupL, UT_PublishContextL, Teardown)
+
+EUNIT_TEST(
+ "SubscribeContext - test ",
+ "CCFEngine",
+ "SubscribeContext",
+ "FUNCTIONALITY",
+ SetupL, UT_SubscribeContextL, Teardown)
+
+EUNIT_TEST(
+ "DefineContext - test ",
+ "CCFEngine",
+ "DefineContext",
+ "FUNCTIONALITY",
+ SetupL, UT_DefineContextL, Teardown)
+
+EUNIT_TEST(
+ "RemoveContextSubscription - test ",
+ "CCFEngine",
+ "RemoveContextSubscription",
+ "FUNCTIONALITY",
+ SetupL, UT_RemoveContextSubscriptionL, Teardown)
+
+EUNIT_TEST(
+ "2 RemoveContextSubscription - during context indication",
+ "CCFEngine",
+ "RemoveContextSubscription",
+ "FUNCTIONALITY",
+ SetupL, UT_RemoveSubscriptionDuringIdicationL, Teardown)
+
+EUNIT_TEST(
+ "3 RemoveContextSubscription - 2nd during context indication",
+ "CCFEngine",
+ "RemoveContextSubscription",
+ "FUNCTIONALITY",
+ SetupL, UT_RemoveSubscriptionDuringIdication2L, Teardown)
+
+
+EUNIT_END_TEST_TABLE
+
+// END OF FILE