diff -r 000000000000 -r e6b17d312c8b ximpfw/tsrc/src/t_presencecache/T_PresenceCache.cpp --- /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 +#include + + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + + +// 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::From(*(buddyPresInfoWrite->PresenceInfo())); + + CPresenceInfoImp* readInfo = + TXIMPGetImpClassOrPanic::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 myArraywrite = buddyInfoList->GetObjectCollection(); + + RPointerArray 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::From(*(myArraywrite[6])); + + readInfo = + TXIMPGetImpClassOrPanic::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::From(*(myArraywrite[2])); + + readInfo = + TXIMPGetImpClassOrPanic::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