--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/ximpfw/tsrc/src/t_presencecache/T_PresenceCache.cpp Thu Dec 17 08:54:49 2009 +0200
@@ -0,0 +1,978 @@
+/*
+* Copyright (c) 2006 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: XIMP Framework Test Code
+*
+*/
+
+
+// CLASS HEADER
+#include "T_PresenceCache.h"
+
+// EXTERNAL INCLUDES
+#include <EUnitMacros.h>
+#include <EUnitDecorators.h>
+
+
+#include <presenceinfoimp.h>
+#include <presenceinfo.h>
+#include <personpresenceinfoimp.h>
+#include <presenceinfofieldimp.h>
+#include <presenceinfofield.h>
+#include <presenceinfofieldcollectionimp.h>
+#include <presenceinfofieldcollection.h>
+#include <ximpbase.h>
+#include <presenceinfofieldvaluetext.h>
+#include <presenceinfofieldvaluetextimp.h>
+#include <presencebuddyinfo.h>
+#include <presencebuddyinfolist.h>
+#include <presencecacheclient.h>
+#include <ximpidentityimp.h>
+#include <ximpidentity.h>
+#include <presenceinfofieldvaluebinary.h>
+#include <presenceinfofieldvaluebinaryimp.h>
+
+#include <presencefeeder.h>
+
+
+// Implementation files used for testing only
+#include "presencebuddyinfoimp.h"
+#include "presenceinfoimp.h"
+#include "presencebuddyinfolistimp.h"
+
+
+// CONSTANTS
+_LIT8( KIdentityField, "Identity" );
+
+_LIT( KBuddyId1sip, "sip:BuddyId1@xyz.com" );
+_LIT( KBuddyId2sip, "sip:BuddyId2@xyz.com" );
+_LIT( KBuddyId3sip, "sip:BuddyId3@xyz.com" );
+_LIT( KBuddyId1ECE, "ECE:BuddyId1@xyz.com" );
+_LIT( KBuddyId2ECE, "ECE:BuddyId2@xyz.com" );
+_LIT( KBuddyId3ECE, "ECE:BuddyId3@xyz.com" );
+_LIT( KBuddyId1MSN, "MSN:BuddyId1@xyz.com" );
+_LIT( KBuddyId2MSN, "MSN:BuddyId2@xyz.com" );
+_LIT( KBuddyId3MSN, "MSN:BuddyId3@xyz.com" );
+_LIT( KBuddyId1VoIP, "VoIP:BuddyId1@xyz.com" );
+_LIT( KBuddyId2VoIP, "VoIP:BuddyId2@xyz.com" );
+_LIT( KBuddyId3VoIP, "VoIP:BuddyId3@xyz.com" );
+_LIT( KBuddyId1ICQ, "ICQ:BuddyId1@xyz.com" );
+_LIT( KBuddyId2ICQ, "ICQ:BuddyId2@xyz.com" );
+_LIT( KBuddyId3ICQ, "ICQ:BuddyId3@xyz.com" );
+_LIT( KBuddyId1no, "no:BuddyId1@xyz.com" );
+_LIT( KBuddyId2no, "no:BuddyId2@xyz.com" );
+_LIT( KBuddyId3no, "no:BuddyId3@xyz.com" );
+
+_LIT( KBuddyId1, "BuddyId1@xyz.com" );
+_LIT( KBuddyId2, "BuddyId2@xyz.com" );
+_LIT( KBuddyId3, "BuddyId3@xyz.com" );
+
+_LIT( KText1, "KText1" );
+_LIT( KText2, "KText2" );
+_LIT( KText3, "KText3" );
+_LIT( KText4, "KText4" );
+_LIT( KText5, "KText5" );
+_LIT( KText6, "KText6" );
+
+_LIT( KService1, "sip" );
+_LIT( KService2, "ECE" );
+_LIT( KService3, "MSN" );
+_LIT( KService4, "VoIP" );
+_LIT( KService5, "ICQ" );
+_LIT( KService6, "no" );
+
+// INTERNAL INCLUDES
+
+
+// CONSTRUCTION
+T_PresenceCache* T_PresenceCache::NewL()
+ {
+ T_PresenceCache* self = T_PresenceCache::NewLC();
+ CleanupStack::Pop();
+
+ return self;
+ }
+
+T_PresenceCache* T_PresenceCache::NewLC()
+ {
+ T_PresenceCache* self = new( ELeave ) T_PresenceCache();
+ CleanupStack::PushL( self );
+
+ self->ConstructL();
+
+ return self;
+ }
+
+// Destructor (virtual by CBase)
+T_PresenceCache::~T_PresenceCache()
+ {
+ }
+
+// Default constructor
+T_PresenceCache::T_PresenceCache()
+ {
+ }
+
+// Second phase construct
+void T_PresenceCache::ConstructL()
+ {
+ // The ConstructL from the base class CEUnitTestSuiteClass must be called.
+ // It generates the test case table.
+ CEUnitTestSuiteClass::ConstructL();
+
+ iCoverageTesting=EFalse;
+ }
+
+// METHODS
+
+
+void T_PresenceCache::SetupL( )
+ {
+ __UHEAP_MARK;
+ iMPresenceCacheWriter = MPresenceCacheWriter::NewL();
+ iMPresenceCacheReader = MPresenceCacheReader::NewL();
+
+ iPresenceFeeder = MPresenceFeeder::NewL(KService6);
+ }
+
+
+void T_PresenceCache::Teardown( )
+ {
+ if(iMPresenceCacheReader)
+ delete iMPresenceCacheReader;
+ delete iMPresenceCacheWriter;
+ delete iPresenceFeeder;
+ delete iExpectedNotifyContent;
+
+ if(iPresBuddyInfoList)
+ delete iPresBuddyInfoList;
+ REComSession::FinalClose();
+ User::SetJustInTime( ETrue );
+ __UHEAP_MARKEND;
+ }
+
+void T_PresenceCache::T__PresenceInfoL()
+ {
+ // Try to read while empty
+ MXIMPIdentity* identity = iMPresenceCacheReader->NewIdentityLC();
+ identity->SetIdentityL(KBuddyId1);
+
+ //KErrArgument
+ MPresenceInfo* presInfoRead = iMPresenceCacheReader->PresenceInfoLC(*identity);
+ EUNIT_ASSERT_EQUALS( (TInt)presInfoRead, NULL );
+
+ //empty read
+ identity->SetIdentityL(KBuddyId1sip);
+ presInfoRead = iMPresenceCacheReader->PresenceInfoLC(*identity);
+ EUNIT_ASSERT_EQUALS( (TInt)presInfoRead, NULL );
+
+ // write buddy presence info
+ MPresenceBuddyInfo* buddyPresInfoWrite =
+ MakeBuddyPresenceInfoLC(KBuddyId1sip, KText1);
+ TInt err = iMPresenceCacheWriter->WritePresenceL(buddyPresInfoWrite);
+
+ // Now read it
+ presInfoRead = iMPresenceCacheReader->PresenceInfoLC(*identity);
+
+
+ //Now verify it
+ const CPresenceInfoImp* actualInfo =
+ TXIMPGetImpClassOrPanic<const CPresenceInfoImp>::From(*(buddyPresInfoWrite->PresenceInfo()));
+
+ CPresenceInfoImp* readInfo =
+ TXIMPGetImpClassOrPanic<CPresenceInfoImp>::From(*presInfoRead);
+
+ TBool same = actualInfo->EqualsContent(*readInfo);
+
+ CleanupStack::PopAndDestroy(3); //identity, buddyPresInfoWrite, presInfoRead;
+
+ EUNIT_ASSERT_EQUALS( same, ETrue );
+ }
+
+
+void T_PresenceCache::T_WriteReadPresenceAsyncL()
+ {
+
+ //MPresenceBuddyInfoList* buddyInfoList = CPresenceBuddyInfoListImp::NewLC();
+ MPresenceBuddyInfoList* buddyInfoList =
+ iMPresenceCacheWriter->NewPresenceBuddyInfoListLC(KNullDesC);
+ //buddyInfoList->SetServiceNameL(KService1);
+ // write buddies in all services
+ MPresenceBuddyInfo* buddyPresInfoWrite(NULL);
+
+ TInt err2(KErrNone);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId1sip, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId2sip, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId3sip, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId1ECE, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId2ECE, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId3ECE, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId1MSN, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId2MSN, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId3MSN, KText1);
+ buddyInfoList->AddOrReplace(buddyPresInfoWrite);CleanupStack::Pop(1);
+
+
+ //Only For increasing coverage for lists
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId3no);
+ EUNIT_ASSERT_EQUALS( buddyInfoList->FindAndRemove(*identity), KErrNotFound);
+ EUNIT_ASSERT_EQUALS( buddyInfoList->Count(), 9);
+ buddyPresInfoWrite =MakeBuddyPresenceInfoLC(KBuddyId3no, KText1);
+ EUNIT_ASSERT_EQUALS( buddyInfoList->AddOrReplace(buddyPresInfoWrite), KErrNone);
+
+ EUNIT_ASSERT_EQUALS( buddyInfoList->Count(), 10);
+ EUNIT_ASSERT_EQUALS( buddyInfoList->FindAndRemove(*identity), KErrNone);
+ EUNIT_ASSERT_EQUALS( buddyInfoList->Count(), 9);
+ EUNIT_ASSERT_EQUALS( buddyInfoList->FindAndRemove(*identity), KErrNotFound);
+ CleanupStack::Pop(1); // buddyPresInfoWrite
+ EUNIT_ASSERT_EQUALS( (TInt)(buddyInfoList->FindAndGet(*identity)), NULL);
+ CleanupStack::PopAndDestroy(1); // identity
+
+ //calling async write function
+ TInt err = iMPresenceCacheWriter->WritePresenceL(buddyInfoList,this);
+ //if (err==KErrNone)
+ // WaitComplete();
+ //Try Cancelling
+ err = iMPresenceCacheWriter->CancelWrite(); //always cancels receiving callback
+ //Write Again
+ err = iMPresenceCacheWriter->WritePresenceL(buddyInfoList,this);
+ if (err==KErrNone)
+ WaitComplete();
+ else //Try again
+ {
+ err = iMPresenceCacheWriter->WritePresenceL(buddyInfoList,this);
+ if (err==KErrNone)
+ WaitComplete();
+ }
+ EUNIT_ASSERT_EQUALS( iErrorFromHandler, KErrNone);
+
+
+ // read from 3rd service MSN
+ err = iMPresenceCacheReader->AllBuddiesPresenceInService(KService3, this);
+ //Try Cancelling
+ err = iMPresenceCacheReader->CancelRead();
+ // Try reading again
+ err = iMPresenceCacheReader->AllBuddiesPresenceInService(KService3, this);
+ if (err+1)
+ WaitComplete();
+ EUNIT_ASSERT_EQUALS( iErrorFromHandler, KErrNone);
+
+
+ //Now verify it, pick something to verify
+ CPresenceBuddyInfoImp* actualInfo(NULL);
+ CPresenceBuddyInfoImp* readInfo(NULL);
+ RPointerArray<MPresenceBuddyInfo> myArraywrite = buddyInfoList->GetObjectCollection();
+
+ RPointerArray<MPresenceBuddyInfo> myArrayread; // wont be owned
+
+ TBool same1(EFalse);
+ if(iPresBuddyInfoList) // if list is received, compare for 3rd service MSN
+ {
+ myArrayread = iPresBuddyInfoList->GetObjectCollection(); //not owned
+ //1
+ actualInfo =
+ TXIMPGetImpClassOrPanic<CPresenceBuddyInfoImp>::From(*(myArraywrite[6]));
+
+ readInfo =
+ TXIMPGetImpClassOrPanic<CPresenceBuddyInfoImp>::From(*(myArrayread[0]));
+
+ same1 = actualInfo->EqualsContent(*readInfo);
+ }
+
+
+ // read for first service sip
+ err = iMPresenceCacheReader->AllBuddiesPresenceInService(KService1, this);
+ if (err+1)
+ WaitComplete();
+ EUNIT_ASSERT_EQUALS( iErrorFromHandler, KErrNone);
+ TBool same2(EFalse);
+ if(iPresBuddyInfoList) // if list is received, compare for 1st service SIP
+ {
+ myArrayread = iPresBuddyInfoList->GetObjectCollection(); //not owned
+
+ actualInfo =
+ TXIMPGetImpClassOrPanic<CPresenceBuddyInfoImp>::From(*(myArraywrite[2]));
+
+ readInfo =
+ TXIMPGetImpClassOrPanic<CPresenceBuddyInfoImp>::From(*(myArrayread[2]));
+
+ same2 = actualInfo->EqualsContent(*readInfo);
+ }
+
+
+ // All buddies count
+ TInt count = iMPresenceCacheReader->BuddyCountInAllServices();
+
+ // buddies count in specific service
+ TInt count2 = iMPresenceCacheReader->BuddyCountInService(KService2);
+
+
+ // Testing DeletePresenceL
+ MXIMPIdentity* identity2 = CXIMPIdentityImp::NewLC();
+ identity2->SetIdentityL(KBuddyId3MSN);
+ TInt remove = iMPresenceCacheWriter->DeletePresenceL(*identity2);
+ EUNIT_ASSERT_EQUALS( remove, KErrNone );
+ remove = iMPresenceCacheWriter->DeletePresenceL(*identity2);
+ EUNIT_ASSERT_EQUALS( remove, KErrNotFound );
+ identity2->SetIdentityL(KBuddyId3ICQ);
+ remove = iMPresenceCacheWriter->DeletePresenceL(*identity2);
+ EUNIT_ASSERT_EQUALS( remove, KErrNotFound );
+ CleanupStack::PopAndDestroy(1); //identity2;
+
+
+
+ TInt serviceCount = iMPresenceCacheReader->ServicesCount();
+
+ CleanupStack::PopAndDestroy(1); //buddyInfoList;
+
+ EUNIT_ASSERT_EQUALS( same1, ETrue );
+ EUNIT_ASSERT_EQUALS( same2, ETrue );
+ EUNIT_ASSERT_EQUALS( count, 9 );
+ EUNIT_ASSERT_EQUALS( count2, 3 );
+ EUNIT_ASSERT_EQUALS( serviceCount, 3 );
+
+ }
+
+
+void T_PresenceCache::T_DeletingAndCancellingL()
+ {
+ //Empty Reading
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId1);
+
+
+ CleanupStack::PopAndDestroy(1); //identity
+
+ //Empty counting functions
+
+ // All buddies count
+ TInt count = iMPresenceCacheReader->BuddyCountInAllServices();
+ EUNIT_ASSERT_EQUALS( count, 0 );
+
+ // buddies count in specific service
+ TInt count2 = iMPresenceCacheReader->BuddyCountInService(KService2);
+ EUNIT_ASSERT_EQUALS( count2, KErrNotFound );
+
+
+ //Services count
+ TInt serviceCount = iMPresenceCacheReader->ServicesCount();
+ EUNIT_ASSERT_EQUALS( serviceCount, 0 );
+
+
+ //Empty async reading
+ TInt err = iMPresenceCacheReader->AllBuddiesPresenceInService(KService3, this);
+ if (err+1)
+ WaitComplete();
+ EUNIT_ASSERT_EQUALS( iErrorFromHandler, KErrNotFound);
+
+ //Writing async and verify results// this checks cancelling also
+ T_WriteReadPresenceAsyncL();
+
+ // Now try deleting
+ err = iMPresenceCacheWriter->DeleteService(KService3);
+ EUNIT_ASSERT_EQUALS( err, KErrNone);
+
+ //Try deleting again
+ err = iMPresenceCacheWriter->DeleteService(KService3);
+ EUNIT_ASSERT_EQUALS( err, KErrNotFound);
+
+ //Try reading the deleted presence
+ err = iMPresenceCacheReader->AllBuddiesPresenceInService(KService3, this);
+ if (err==KErrNone)
+ WaitComplete();
+ EUNIT_ASSERT_EQUALS( iErrorFromHandler, KErrNotFound);
+ }
+
+void T_PresenceCache::T_PerformanceL()
+ {
+
+
+
+
+ }
+
+void T_PresenceCache::T_RunAllL()
+ {
+ T__PresenceInfoL();
+ T_DeleteAllCacheL();
+
+ T_WriteReadPresenceAsyncL();
+ T_DeleteAllCacheL();
+
+ T_DeletingAndCancellingL();
+ // let the destructor delete the cache
+ }
+
+
+//Utility Functions
+MPresenceInfo* T_PresenceCache::MakePresenceInfoLC()
+ {
+ MPresenceInfo* presInfo = CPresenceInfoImp::NewLC();
+
+ MPresenceInfoFieldValueText* value = CPresenceInfoFieldValueTextImp::NewLC();
+ value->SetTextValueL(KBuddyId1);
+
+ MPresenceInfoField* infoField = CPresenceInfoFieldImp::NewLC();
+ infoField->SetFieldTypeL(KIdentityField);
+ infoField->SetFieldValue(value);
+
+
+ MPersonPresenceInfo* personPres = CPersonPresenceInfoImp::NewLC();
+ MPresenceInfoFieldCollection& fieldCol = personPres->Fields();
+ fieldCol.AddOrReplaceFieldL(infoField);
+ TInt fieldCount= fieldCol.FieldCount();
+
+ presInfo->SetPersonPresenceL(personPres);
+
+ CleanupStack::Pop(3);//personPres,infoField,value
+
+ return presInfo;
+ }
+
+// Utility function but also test some code
+MPresenceBuddyInfo* T_PresenceCache::MakeBuddyPresenceInfoLC(
+ const TDesC& id, const TDesC& text)
+ {
+ // it sets objects differently for different flag values of iCoverageTesting
+ // just of code coverage purpose
+ if(iCoverageTesting)
+ { // make the new
+ iCoverageTesting = !iCoverageTesting;
+ MPresenceBuddyInfo* buddyPresInfo = iMPresenceCacheWriter->NewBuddyPresenceInfoLC();
+ MPresenceInfo* presInfo = iMPresenceCacheWriter->NewPresenceInfoLC();
+
+ MPresenceInfoFieldValueText* value = CPresenceInfoFieldValueTextImp::NewLC();
+ value->SetTextValueL(text);
+
+ MPresenceInfoField* infoField = CPresenceInfoFieldImp::NewLC();
+ infoField->SetFieldTypeL(KIdentityField);
+ infoField->SetFieldValue(value);
+
+
+ MPersonPresenceInfo* personPres = CPersonPresenceInfoImp::NewLC();
+ MPresenceInfoFieldCollection& fieldCol = personPres->Fields();
+ fieldCol.AddOrReplaceFieldL(infoField);
+ TInt fieldCount= fieldCol.FieldCount();
+
+ presInfo->SetPersonPresenceL(personPres);
+
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(id);
+
+ buddyPresInfo->Set(identity, presInfo);
+
+ CleanupStack::Pop(5);//personPres,infoField,value,buddyPresInfo, identity
+
+ return buddyPresInfo;
+ }
+
+ iCoverageTesting = !iCoverageTesting;
+ MPresenceBuddyInfo* buddyPresInfo = iMPresenceCacheWriter->NewBuddyPresenceInfoLC();
+ MPresenceInfo* presInfo = iMPresenceCacheWriter->NewPresenceInfoLC();
+
+ MPresenceInfoFieldValueText* value = CPresenceInfoFieldValueTextImp::NewLC();
+ value->SetTextValueL(text);
+
+ MPresenceInfoField* infoField = CPresenceInfoFieldImp::NewLC();
+ infoField->SetFieldTypeL(KIdentityField);
+ infoField->SetFieldValue(value);
+
+
+ MPersonPresenceInfo* personPres = CPersonPresenceInfoImp::NewLC();
+ MPresenceInfoFieldCollection& fieldCol = personPres->Fields();
+ fieldCol.AddOrReplaceFieldL(infoField);
+ TInt fieldCount= fieldCol.FieldCount();
+
+ presInfo->SetPersonPresenceL(personPres);
+
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(id);
+
+
+ //Call again for the sake of code coverage
+ EUNIT_ASSERT_EQUALS( buddyPresInfo->SetBuddyId(identity), KErrNone);
+ EUNIT_ASSERT_EQUALS( buddyPresInfo->SetPresenceInfo(presInfo), KErrNone);
+
+ CleanupStack::Pop(5);//personPres,infoField,value,buddyPresInfo, identity
+
+ return buddyPresInfo;
+ }
+
+void T_PresenceCache::T_DeleteAllCacheL()
+ {
+ // all service uids
+ TInt count = iMPresenceCacheReader->ServicesCount();
+ TInt err(KErrNone);
+
+ err = iMPresenceCacheWriter->DeleteService(KService1);
+ err = iMPresenceCacheWriter->DeleteService(KService2);
+ err = iMPresenceCacheWriter->DeleteService(KService3);
+ err = iMPresenceCacheWriter->DeleteService(KService4);
+ err = iMPresenceCacheWriter->DeleteService(KService5);
+ err = iMPresenceCacheWriter->DeleteService(KService6);
+ }
+
+void T_PresenceCache::T_MakePerformancePreconditionsL()
+ {
+ }
+
+// Buddy with status text and avater
+MPresenceBuddyInfo* T_PresenceCache::T_MakePerformanceBuddyLC(const TDesC& /*id*/ )
+ {
+ /*
+ MPresenceBuddyInfo* buddyPresInfo = iMPresenceCacheWriter->NewBuddyPresenceInfoLC();
+ MPresenceInfo* presInfo = iMPresenceCacheWriter->NewPresenceInfoLC();
+
+ //Text field
+ MPresenceInfoFieldValueText* value = CPresenceInfoFieldValueTextImp::NewLC();
+ value->SetTextValueL(text);
+
+ MPresenceInfoField* infoField = CPresenceInfoFieldImp::NewLC();
+ infoField->SetFieldTypeL(KIdentityField);
+ infoField->SetFieldValue(value);
+
+ //Binary field
+ MPresenceInfoFieldValueBinay* value = CPresenceInfoFieldValueBinaryImp::NewLC();
+ value->SetBinaryValueL(text);
+
+ MPresenceInfoField* infoField = CPresenceInfoFieldImp::NewLC();
+ infoField->SetFieldTypeL(KIdentityField);
+ infoField->SetFieldValue(value);
+
+
+
+ MPersonPresenceInfo* personPres = CPersonPresenceInfoImp::NewLC();
+ MPresenceInfoFieldCollection& fieldCol = personPres->Fields();
+ fieldCol.AddOrReplaceFieldL(infoField);
+ TInt fieldCount= fieldCol.FieldCount();
+
+ presInfo->SetPersonPresenceL(personPres);
+
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(id);
+
+ TUid serviceid;
+ serviceid.iUid = service;
+
+ buddyPresInfo->Set(serviceid, identity, presInfo);
+
+ CleanupStack::Pop(5);//personPres,infoField,value,buddyPresInfo, identity
+
+ return buddyPresInfo;*/
+ }
+
+
+void T_PresenceCache::T_SubscribeBuddy1Response()
+ {
+ // Notice: First set the initial state for User1, this is needed at least now.
+ MPresenceBuddyInfo* initInfo = MakeBuddyPresenceInfoLC(KBuddyId1no, KText1);
+ TInt err = iMPresenceCacheWriter->WritePresenceL(initInfo);
+ CleanupStack::PopAndDestroy( ); // initInfo
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ err = iMPresenceCacheReader->SetObserverForSubscribedNotifications( this );
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId1no);
+
+ err = iMPresenceCacheReader->SubscribePresenceBuddyChangeL( *identity);
+ CleanupStack::PopAndDestroy(1); //identity
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ // Presence feeder
+ iExpectedNotifyStatus = KErrNone;
+ iNbrNotifys = 1;
+ iPresenceFeeder->SetAvailabilityL( KBuddyId1, MPresenceFeeder::ENotAvailable, KText2);
+
+ // TODO:
+ delete iExpectedNotifyContent;
+ iExpectedNotifyContent = NULL;
+ iExpectedNotifyContent =
+ MakeBuddyPresenceInfoLC(KBuddyId1no, KText2);
+ CleanupStack::Pop( ); // iExpectedNotifyContent
+ err = iMPresenceCacheWriter->WritePresenceL(iExpectedNotifyContent);
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ iPresenceFeeder->RemoveAvailabilityL(KBuddyId2);
+
+ // Now we start to wait callback method HandlePresenceNotificationL
+ WaitComplete();
+ }
+
+void T_PresenceCache::T_SubscribeBuddyAndUnsubscribe()
+ {
+ // Test few error cases first
+
+ // Test null parameter error case
+ TInt err = iMPresenceCacheReader->SetObserverForSubscribedNotifications( NULL );
+ EUNIT_ASSERT_EQUALS( err, KErrArgument );
+
+ // Test subscription without callback registeration
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId1ECE);
+
+ err = iMPresenceCacheReader->SubscribePresenceBuddyChangeL( *identity);
+ EUNIT_ASSERT_EQUALS( err, KErrNotReady );
+
+ // Now make successful subscription
+ err = iMPresenceCacheReader->SetObserverForSubscribedNotifications( this );
+ EUNIT_ASSERT_EQUALS( err, 0 );
+ err = iMPresenceCacheReader->SubscribePresenceBuddyChangeL( *identity);
+ EUNIT_ASSERT_EQUALS( err, 0);
+
+ // Make successful unsubscription
+ iMPresenceCacheReader->UnSubscribePresenceBuddyChangeL( *identity);
+
+ CleanupStack::PopAndDestroy(1); //identity
+ // Now we start to wait callback method HandlePresenceNotificationL
+ }
+
+void T_PresenceCache::T_SubscribeBuddyManyResponses()
+ {
+ // Notice: First set the initial state for User1, this is needed at least now.
+ MPresenceBuddyInfo* initInfo = MakeBuddyPresenceInfoLC(KBuddyId1no, KText1);
+ TInt err = iMPresenceCacheWriter->WritePresenceL(initInfo);
+ CleanupStack::PopAndDestroy( ); // initInfo
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ err = iMPresenceCacheReader->SetObserverForSubscribedNotifications( this );
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId1no);
+
+ err = iMPresenceCacheReader->SubscribePresenceBuddyChangeL( *identity);
+ CleanupStack::PopAndDestroy(1); //identity
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ // Presence feeder
+ iExpectedNotifyStatus = KErrNone;
+ iNbrNotifys = 4;
+ iPresenceFeeder->SetAvailabilityL( KBuddyId1, MPresenceFeeder::ENotAvailable, KText2);
+
+ delete iExpectedNotifyContent;
+ iExpectedNotifyContent = NULL;
+ iExpectedNotifyContent =
+ MakeBuddyPresenceInfoLC(KBuddyId1no, KText1);
+ CleanupStack::Pop( ); // iExpectedNotifyContent
+ err = iMPresenceCacheWriter->WritePresenceL(iExpectedNotifyContent);
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ // Now we start to wait callback method HandlePresenceNotificationL
+ WaitComplete();
+ }
+
+void T_PresenceCache::T_DeleteBeforeNotify()
+ {
+ // Notice: First set the initial state for User1, this is needed at least now.
+ TInt err;
+ /*
+ MPresenceBuddyInfo* initInfo = MakeBuddyPresenceInfoLC( KServiceUid6, KBuddyId1, KText1);
+ TInt err = iMPresenceCacheWriter->WritePresenceL(initInfo);
+ CleanupStack::PopAndDestroy( ); // initInfo
+ EUNIT_ASSERT_EQUALS( err, 0 ); */
+
+ err = iMPresenceCacheReader->SetObserverForSubscribedNotifications( this );
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId1no);
+
+ err = iMPresenceCacheReader->SubscribePresenceBuddyChangeL( *identity);
+ CleanupStack::PopAndDestroy(1); //identity
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ // Presence feeder
+ iExpectedNotifyStatus = KErrNone;
+ iNbrNotifys = 1;
+
+
+ delete iMPresenceCacheReader;
+ iMPresenceCacheReader = NULL;
+
+ // TODO:
+ delete iExpectedNotifyContent;
+ iExpectedNotifyContent = NULL;
+ iExpectedNotifyContent =
+ MakeBuddyPresenceInfoLC(KBuddyId1no, KText2);
+ CleanupStack::Pop( ); // iExpectedNotifyContent
+ err = iMPresenceCacheWriter->WritePresenceL(iExpectedNotifyContent);
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ //no notification should come, since we have deleted the subscriber
+ }
+
+
+// Callback observers
+
+void T_PresenceCache::HandlePresenceWriteL(TInt aErrorCode)
+ {
+ EUNIT_PRINT(_L("HandlePresenceWriteL"));
+ EUNIT_PRINT(_L(" aErrorCode: %d"), aErrorCode);
+ iCbReceived = ETrue;
+ iErrorFromHandler = aErrorCode;
+
+ if( iWait.IsStarted() )
+ {
+ iWait.AsyncStop();
+ }
+ }
+
+void T_PresenceCache::HandlePresenceReadL(TInt aErrorCode,
+ MPresenceBuddyInfoList* aPresenceBuddyInfoList)
+ {
+ EUNIT_PRINT(_L("HandlePresenceReadL"));
+ EUNIT_PRINT(_L(" aErrorCode: %d"), aErrorCode);
+ iCbReceived = ETrue;
+ iErrorFromHandler = aErrorCode;
+
+
+ if(iPresBuddyInfoList)
+ delete iPresBuddyInfoList; iPresBuddyInfoList=NULL;
+ iPresBuddyInfoList = aPresenceBuddyInfoList;
+
+ if( iWait.IsStarted() )
+ {
+ iWait.AsyncStop();
+ }
+ }
+
+// *****************************************************************************
+
+void T_PresenceCache::HandlePresenceNotificationL(TInt aErrorCode,
+ MPresenceBuddyInfo* aPresenceBuddyInfo)
+ {
+ EUNIT_PRINT(_L("HandlePresenceNotiicationL"));
+ EUNIT_PRINT(_L(" aErrorCode: %d"), aErrorCode);
+ iCbReceived = ETrue;
+ iErrorFromHandler = aErrorCode;
+
+ // check what is expected
+ EUNIT_ASSERT_EQUALS( aErrorCode, iExpectedNotifyStatus );
+
+ if ( aPresenceBuddyInfo )
+ {
+ // We do not want to get anything when not expecting it.
+ TBool isNull = iExpectedNotifyContent ? EFalse : ETrue;
+ EUNIT_ASSERT_EQUALS( isNull, EFalse );
+ // just check that this does not crash
+ const MXIMPIdentity* buddyId = aPresenceBuddyInfo->BuddyId();
+ // Then test the whole content
+ TBool eq = iExpectedNotifyContent->EqualsIdentity( aPresenceBuddyInfo );
+ EUNIT_ASSERT_EQUALS( eq, ETrue );
+ }
+ else
+ {
+ EUNIT_PRINT(_L(" received buddyInfo is NULL"));
+ }
+
+ delete aPresenceBuddyInfo;
+
+ iNbrNotifys--;
+
+ /* The test sequence of complicated case is
+ * sub Usr1
+ * write Usr1 -> Notify
+ * sub Usr2
+ * write Usr1 -> Notify
+ * write Usr2 -> Notify
+ * unsub Usr2
+ * write Usr2
+ * delete Usr1 -> notify(empty)
+ */
+
+ switch ( iNbrNotifys )
+ {
+ case 3:
+ // subscribe U2
+ {
+ // Notice: First set the initial state for User1, this is needed at least now.
+ MPresenceBuddyInfo* initInfo = MakeBuddyPresenceInfoLC(KBuddyId2no, KText2);
+ TInt err = iMPresenceCacheWriter->WritePresenceL(initInfo);
+ CleanupStack::PopAndDestroy( ); // initInfo
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId2no);
+ err = iMPresenceCacheReader->SubscribePresenceBuddyChangeL( *identity);
+ CleanupStack::PopAndDestroy(1); //identity
+ EUNIT_ASSERT_EQUALS( err, 0 );
+
+ // Presence feeder
+ iExpectedNotifyStatus = KErrNone;
+ delete iExpectedNotifyContent;
+ iExpectedNotifyContent = NULL;
+ iExpectedNotifyContent =
+ MakeBuddyPresenceInfoLC(KBuddyId1no, KText1);
+ CleanupStack::Pop( ); // iExpectedNotifyContent
+ err = iMPresenceCacheWriter->WritePresenceL(iExpectedNotifyContent);
+ EUNIT_ASSERT_EQUALS( err, 0 );
+ // Now we start to wait callback method HandlePresenceNotificationL
+ }
+ break;
+ case 2:
+ {
+ // Presence feeder
+ iExpectedNotifyStatus = KErrNone;
+ delete iExpectedNotifyContent;
+ iExpectedNotifyContent = NULL;
+ iExpectedNotifyContent =
+ MakeBuddyPresenceInfoLC(KBuddyId2no, KText3);
+ CleanupStack::Pop( ); // iExpectedNotifyContent
+ TInt err = iMPresenceCacheWriter->WritePresenceL(iExpectedNotifyContent);
+ EUNIT_ASSERT_EQUALS( err, 0 );
+ // Now we start to wait callback method HandlePresenceNotificationL
+ }
+ break;
+ case 1:
+ {
+ // Unsubscribe Usr2
+ MXIMPIdentity* identity = CXIMPIdentityImp::NewLC();
+ identity->SetIdentityL(KBuddyId2no);
+ iMPresenceCacheReader->UnSubscribePresenceBuddyChangeL( *identity );
+ CleanupStack::PopAndDestroy(1); //identity
+
+ // Write Usr2
+ iExpectedNotifyStatus = KErrNone;
+ delete iExpectedNotifyContent;
+ iExpectedNotifyContent = NULL;
+
+ // delete Usr1
+ iPresenceFeeder->RemovePresenceL(KBuddyId1no);
+ iExpectedNotifyContent =
+ MakeBuddyPresenceInfoLC( KBuddyId1no, KText3);
+ TInt err = iExpectedNotifyContent->SetPresenceInfo( NULL );
+ EUNIT_ASSERT_EQUALS( err, KErrArgument );
+ CleanupStack::Pop( ); // iExpectedNotifyContent
+
+ // Now we start to wait callback method HandlePresenceNotificationL
+ }
+ break;
+ case 0:
+ default:
+ if( iWait.IsStarted() )
+ {
+ iWait.AsyncStop();
+ }
+ break;
+ };
+
+ }
+
+// *****************************************************************************
+
+
+void T_PresenceCache::T_TestFeeder()
+ {
+ iPresenceFeeder->SetAvailabilityL(KBuddyId1,MPresenceFeeder::ENotAvailable,KText2);
+ iPresenceFeeder->SetAvailabilityL(KBuddyId1,MPresenceFeeder::ENotAvailable,KText2);
+ iPresenceFeeder->RemoveAvailabilityL(KBuddyId2);
+ iPresenceFeeder->RemoveAvailabilityL(KBuddyId1);
+ iPresenceFeeder->SetAvailabilityL(KBuddyId1,MPresenceFeeder::ENotAvailable,KText2);
+ iPresenceFeeder->RemovePresenceL(KBuddyId2);
+ iPresenceFeeder->RemovePresenceL(KBuddyId1);
+ iPresenceFeeder->SetAvailabilityL(KBuddyId1,MPresenceFeeder::ENotAvailable,KText2);
+ iPresenceFeeder->RemoveAllPresences();
+ }
+
+// TEST TABLE
+EUNIT_BEGIN_TEST_TABLE(
+ T_PresenceCache,
+ "Presence Cache module tests.",
+ "MODULE" )
+
+EUNIT_TEST(
+ "T__PresenceInfoL",
+ "PresenceCache",
+ "T__PresenceInfoL",
+ "FUNCTIONALITY",
+ SetupL, T__PresenceInfoL, Teardown)
+
+EUNIT_TEST(
+ "T_WriteReadPresenceAsyncL",
+ "PresenceCache",
+ "T_WriteReadPresenceAsyncL",
+ "FUNCTIONALITY",
+ SetupL, T_WriteReadPresenceAsyncL, Teardown)
+
+EUNIT_TEST(
+ "T_DeletingAndCancellingL",
+ "PresenceCache",
+ "T_DeletingAndCancellingL",
+ "FUNCTIONALITY",
+ SetupL, T_DeletingAndCancellingL, Teardown)
+
+EUNIT_TEST(
+ "T_RunAllL",
+ "PresenceCache",
+ "T_RunAllL",
+ "FUNCTIONALITY",
+ SetupL, T_RunAllL, Teardown)
+
+EUNIT_TEST(
+ "T_TestFeeder",
+ "PresenceFeeder",
+ "T_TestFeeder",
+ "FUNCTIONALITY",
+ SetupL, T_TestFeeder, Teardown)
+
+EUNIT_TEST(
+ "T_SubscribeBuddyAndUnsubscribe",
+ "PresenceCache",
+ "T_SubscribeBuddyAndUnsubscribe",
+ "FUNCTIONALITY",
+ SetupL, T_SubscribeBuddyAndUnsubscribe, Teardown)
+
+EUNIT_TEST(
+ "T_SubscribeBuddy1Response",
+ "PresenceCache",
+ "T_SubscribeBuddy1Response",
+ "FUNCTIONALITY",
+ SetupL, T_SubscribeBuddy1Response, Teardown)
+
+EUNIT_TEST(
+ "T_SubscribeBuddyManyResponses",
+ "PresenceCache",
+ "T_SubscribeBuddyManyResponses",
+ "FUNCTIONALITY",
+ SetupL, T_SubscribeBuddyManyResponses, Teardown)
+
+EUNIT_TEST(
+ "T_DeleteBeforeNotify",
+ "PresenceCache",
+ "T_DeleteBeforeNotify",
+ "FUNCTIONALITY",
+ SetupL, T_DeleteBeforeNotify, Teardown)
+
+EUNIT_END_TEST_TABLE
+
+// END OF FILE