/*
* 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:
*
*/


//  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