C++ CMsvEntrySelection::AppendL方法代码示例

void CMtfTestActionImap4Connected::ExecuteActionL()
	{
	TestCase().INFO_PRINTF2(_L("Test Action %S start..."), &KTestActionImap4Connected);
	TMsvId paramServiceId = ObtainValueParameterL<TMsvId>(TestCase(),ActionParameters().Parameter(0));

	// First parameter is the MTM
	CImap4ClientMtm* pMtm = ObtainParameterReferenceL<CImap4ClientMtm>(TestCase(),ActionParameters().Parameter(1));

	// Second parameter is the boolean state
	TBool connected = ObtainValueParameterL<TBool>(TestCase(),ActionParameters().Parameter(2));
	TInt  expected = KErrNone;
	if(connected == 0)
		expected = KErrDisconnected;

	// Get the state of the MTM
	CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(paramServiceId);
	TBuf8<16> param;
	pMtm->InvokeSyncFunctionL(KIMAP4MTMIsConnected, *selection, param);
	CleanupStack::PopAndDestroy();	// selection
	TInt err = param[0];
	
	if((err != KErrNone && connected != 0 ) || (err == KErrNone && connected == 0 ))
		{
		TestCase().ERR_PRINTF3( _L("CMtfTestActionImap4Connected err(%d) != expected(%d)"), err, expected );
		TestCase().SetTestStepResult(EFail);
		}

	TestCase().INFO_PRINTF2(_L("Test Action %S completed."), &KTestActionImap4Connected);
	TestCase().ActionCompletedL(*this);
	}

EXPORT_C void CMsvServerEntry::MoveEntryL(TMsvId aId, TMsvId aDestination, TRequestStatus& aObserverStatus)
//
//
//
/** Moves a child of the context to another entry that belongs to a different service.
All descendants will be moved as well.

The move is carried out asynchronously. The caller should supply in aObserverStatus
the status word of an active object that it owns. The function will signal
this to be completed when the move is complete.

If the function leaves, no changes are made.

In pre-Unicode versions an asynchronous move can be cancelled through CancelMoveEntry();
in other releases, use Cancel().

@param aId The ID of the entry to move
@param aDestination The ID of new parent
@param aObserverStatus The request status to be completed when the operation
has finished
@leave KErrArgument The destination is a child of aId
@leave KErrInUse The store or a file associated with the entry is open
@leave KErrNoMemory A memory allocation failed
@leave KErrNotFound aId is not a child of the context
@leave KErrPathNotFound The destination does not exist */
	{
	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aId);

	MoveEntriesL(*selection, aDestination, aObserverStatus);

	CleanupStack::PopAndDestroy(); // selection
	}

void CT_CMsvSession::TestIncPcSyncCountL()
	{
	TInt error = KErrGeneral;
	INFO_PRINTF1(_L("Testing: Increment PC Sync Count -- started"));
	TRAP(error, iSession = CMsvSession::OpenSyncL(*this));
	TEST(error == KErrNone);

	CMsvOperationWait* active = CMsvOperationWait::NewLC();
	
	CMsvEntry* cEntry = CMsvEntry::NewL(*iSession, KMsvGlobalInBoxIndexEntryId, TMsvSelectionOrdering());
	CleanupStack::PushL(cEntry);
	
	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(selection);

	TInt ret = iSession->InstallMtmGroup(KDataComponentFilename);
	TEST(ret==KErrNone|| ret==KErrAlreadyExists);

	cEntry->SetEntryL(KMsvRootIndexEntryId);
	TMsvEntry service;
	service.iType=KUidMsvServiceEntry;
	service.iMtm = KUidTestServerMtmType;
	cEntry->CreateL(service);

	selection->AppendL(service.Id());
	
	TBuf8<256> progress;
	TBuf8<32> param;
	TRAP(error, iSession->IncPcSyncCountL(*selection);)

TBool CSmsSendRecvTest::SendNextMessageL()
{
    iCurrentMessageNum++;
    const TInt count = iSelection->Count();

    if (iCurrentMessageNum < count)
    {
        iSmsTest.Printf(_L("Sending message %d of %d\n"), iCurrentMessageNum + 1, count);


        delete iOperation;
        iOperation = NULL;

        CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection();
        CleanupStack::PushL(sel);
        const TMsvId id = iSelection->At(iCurrentMessageNum);
        sel->AppendL(id);
        iSent += CountRecipientsL(id);
        iSmsTest.SetEntryL(KMsvGlobalOutBoxIndexEntryId);
        iOperation = MsvEntry().CopyL(*sel, iSmsTest.iSmsServiceId, iStatus);
        CleanupStack::PopAndDestroy(); //sel

        iState = EStateSending;
        SetActive();
        CActiveScheduler::Start();
        return ETrue;
    }

    return EFalse;
}

EXPORT_C void CMsvServerEntry::CopyEntryL(TMsvId aId, TMsvId aDestination, TRequestStatus& aObserverStatus)
//
// Recursively copies a child of the context to another entry that belongs to a different service.
//
/** Copies a child of the context to another entry. All descendants will be copied
as well.

The copy is carried out asynchronously. The caller should supply in aObserverStatus
the status word of an active object that it owns. The function will signal
this to be completed when the copy is complete.

If the function leaves, no changes are made.

@param aId The ID of the entry to copy
@param aDestination The ID of new parent
@param aObserverStatus The request status to be completed when the operation
has finished
@leave KErrArgument The destination is a child of an aSelection entry
@leave KErrInUse The store or a file associated with an entry is open
@leave KErrNoMemory A memory allocation failed
@leave KErrNotFound An aSelection entry is not a child of the context
@leave KErrPathNotFound The destination does not exist */
	{
	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(selection);
	selection->AppendL(aId);
	iCompletedSelection = NULL;
	iCompletedEntryId = NULL;

	DoCopyEntriesL(*selection, aDestination, aObserverStatus);

	CleanupStack::PopAndDestroy(); // selection
	}

void CTestNbssMtm::DoProcessAgainL()
	{
	TBuf8<1>dummy;
	iState = ENbssTestProcess;
	// add service entry and msg entry to selection passed to MTM
	iSelection->Reset();
	iSelection->AppendL((*iMsvSelection)[iFilesProcessed]);

#if defined _HEAP_FAILURE_TEST_
	TBool finished=EFalse;

#ifdef _DEBUG
	TInt failCount=0;
#endif

	while (!finished)
		{
		__UHEAP_FAILNEXT(failCount++);
		TRAPD(error,iNbssServerMtm->StartCommandL(*iSelection, KBiosMtmProcess, dummy, iStatus));
		if (error==KErrNone)
			{
			finished=ETrue;
			__UHEAP_RESET;
			}
		else 
			{
			test(error==KErrNoMemory);
			__UHEAP_RESET;
			}
		}
#else
	iNbssServerMtm->StartCommandL(*iSelection, KBiosMtmProcess, dummy, iStatus);
#endif
	iState = ENbssTestProcess;
	}

CMsvEntrySelection* TestUniDataModelVCalPlugin::GenerateMessagesL()
{
		HBufC* aFileDirectory = KBIOTxtFilePath().AllocL();
		TMsvId messageId;
		TBIOMessageType currentMsgType;

		CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection();
		CleanupStack::PushL(selection);

		TInt err = iFs.GetDir(aFileDirectory->Des(),
                          KEntryAttMatchMask,
                          ESortByName,
                          iDir);
		if (err == KErrPathNotFound)
			{
				TInt makeDirErr = iFs.MkDirAll(aFileDirectory->Des());
				makeDirErr == KErrNone ? User::Leave(KErrNotFound)
                : User::Leave(makeDirErr);
			}
		else if (err != KErrNone)
			{
				User::Leave(err);
			}

		// Set the session path for the RFs
		SetSessionPath(aFileDirectory->Des());
		if (iDir)
			{
				delete iDir;
				iDir = NULL;
			}
        
		User::LeaveIfError(iFs.GetDir(_L("*.txt"), KEntryAttNormal, ESortByName, iDir));
		TInt count = iDir->Count();
		if (count == 0)
			{
				User::Leave(KErrNotFound); // No files to process
			}

		TBuf<60> outputBuf;

		for (TInt loop = 0; loop < count; loop++)
			{
				TEntry as = (*iDir)[0];
				currentFile = (as.iName);
				// Not processed all the messages - so keep the current state
				iFilesProcessed++; // Here because need to update the counter promptly
				currentMsgType = SetMessageType(currentFile);
				if (currentMsgType != ENoMessage) // skip any dodgy filenames
					{
						messageId = CreateBIOEntryFromFileL(currentFile, currentMsgType);
						selection->AppendL(messageId);
						TPtrC tempPtr = (currentFile.Des());

					}
			}
		CleanupStack::Pop(); // selection
		
		return selection;
}

// ----------------------------------------------------------------------------
// ---------------------------------------------------------------------------- 
void CIpsSosAOImapAgent::StartSyncL()
    {
    FUNC_LOG;
    if ( iOngoingOp )
        {
        User::Leave( KErrNotReady );
        }
    LoadSettingsL( );
    if ( !IsConnected() )
        {
        NM_COMMENT("CIpsSosAOImapAgent: starting sync");
        TPckg<MMsvImapConnectionObserver*> parameter(this);
        // connect and synchronise starts background sync or idle
        CMsvEntrySelection* sel = new ( ELeave ) CMsvEntrySelection();
        CleanupStack::PushL( sel );
        sel->AppendL( iServiceId );
        iImapClientMtm->SwitchCurrentEntryL( iServiceId );
        iOngoingOp = iImapClientMtm->InvokeAsyncFunctionL(
                KIMAP4MTMConnectAndSyncCompleteAfterFullSync, 
                *sel, parameter, iStatus);
        CleanupStack::PopAndDestroy( sel );
        SetActive();
        iState = EStateConnectAndSync;
        }
    else
        {
        NM_COMMENT("CIpsSosAOImapAgent: already connected do not sync");
        // do not do anything if we are connected, especially do never
        // try to sync if sync is is already started (ex. from ips plugin)
        // that cause problems with imap flags etc.
        iError = KErrCancel;
        iState = EStateCompleted;
        SetActiveAndCompleteThis();
        }
    }

void CMsgImOutboxSend::DisconnectUnsentMessagesL()
    {
    //  Pos errors
    TInt err = KErrNone;
    //  Temp entry selection...
    CMsvEntrySelection* unsentSelection = new (ELeave) CMsvEntrySelection();
    CleanupStack::PushL(unsentSelection);
    //  Append unsent messages into the temp array..
    for(TInt i=0; i<iEntrySelection.Count(); i++)
        {
        err = iServerEntry.SetEntry((iEntrySelection)[i]);
        //  If not found carry on along the array...
        if(err != KErrNone)
            continue;
        if(iServerEntry.Entry().Parent() == KMsvGlobalOutBoxIndexEntryIdValue)
            {
            unsentSelection->AppendL((iEntrySelection)[i]);
            }
        }

    //  Reset the iConnected flag on the lot.
	 User::LeaveIfError(iServerEntry.SetEntry(KMsvGlobalOutBoxIndexEntryIdValue));
    if(unsentSelection->Count() > 0)
        {
		  User::LeaveIfError(iServerEntry.ChangeAttributes(*unsentSelection, 0, KMsvConnectedAttribute));
        }
	iServerEntry.SetEntry(KMsvNullIndexEntryId);
    CleanupStack::PopAndDestroy();  //  unsentSelection..
    }

void CMsvSendExe::RescheduleAllL(TInt aError)
	{
	SCHSENDLOG(FLog(iFileName, _L("\tRescheduleAllL [aError=%d]"), aError));
	RScheduler scheduler;
	TSchedulerItemRef ref;
	ref.iHandle = KErrNotFound;
	TInt count = 0;
	TInt err = KErrNone;
	TTime start;
	start.UniversalTime();

	TInt activeCount = iOperations.Count();
	while (activeCount--)
		{
		CMsvSendExeActive& active = *iOperations[activeCount];
		active.Cancel();
		TRAP(err, DoResheduleOnErrorL(scheduler, active.Selection(), active.Package(), aError, ref, count, start)); //ignore error
		FailOnError(active.Selection(), aError);
		}

	activeCount = iPackages.Count();
	CMsvEntrySelection* sel = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(sel);
	while (activeCount--)
		{
		const TMsvSchedulePackage& package = iPackages[activeCount];
		sel->Reset();
		sel->AppendL(package.iId);
		TRAP(err, DoResheduleOnErrorL(scheduler, *sel, package, aError, ref, count, start)); //ignore error
		FailOnError(*sel, aError);
		}
	CleanupStack::PopAndDestroy(sel);

	CompleteReschedule(scheduler, ref, count);
	}

void CPopsTestHarness::CreateTestHarnessesL()
	{
	CMsvEntrySelection* serviceSelection = new (ELeave) CMsvEntrySelection;
	CleanupStack::PushL(serviceSelection);
	serviceSelection->AppendL(iPop3Service);
	TBuf8<128> parameter;

	//--------------------------------------------
	// Copy To Local
	//--------------------------------------------
	delete iConnectAndCopyAll;
	iConnectAndCopyAll = NULL;
	iConnectAndCopyAll = CMtmTestHarness::NewL(*(iTestUtils->iPopServerMtm), *iTestUtils);
	// Connect
	iConnectAndCopyAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMConnect, parameter));
	// Copy all messages under the service to the local inbox.
	CMtmTestCommand* copyToLocal = CMtmTestCopyToLocal::NewL(*(iTestUtils->iPopServerMtm), 0, KMsvGlobalInBoxIndexEntryId);
	iConnectAndCopyAll->AddCommandL(CMtmTestCommandOnAllMessages::NewL(*(iTestUtils->iPopServerMtm), copyToLocal, iPop3Service, *(iTestUtils->iServerEntry)));
	// Quit
	iConnectAndCopyAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMDisconnect, parameter));

	//--------------------------------------------
	// Copy Within Service
	//--------------------------------------------
	delete iConnectAndPopulateAll;
	iConnectAndPopulateAll = NULL;
	iConnectAndPopulateAll = CMtmTestHarness::NewL(*(iTestUtils->iPopServerMtm), *iTestUtils);
	// Connect
	iConnectAndPopulateAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMConnect, parameter));
	// Copy all messages under the service to the local service.
	copyToLocal = CMtmTestCopyWithinService::NewL(*(iTestUtils->iPopServerMtm), 0, iPop3Service);
	iConnectAndPopulateAll->AddCommandL(CMtmTestCommandOnAllMessages::NewL(*(iTestUtils->iPopServerMtm), copyToLocal, iPop3Service, *(iTestUtils->iServerEntry)));
	// Quit
	iConnectAndPopulateAll->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMDisconnect, parameter));


	//--------------------------------------------
	// Offline Copy
	//--------------------------------------------
	CMsvServerEntry* serverEntry = iTestUtils->iServerEntry;
	serverEntry->SetEntry(iPop3Service);
	CMsvEntrySelection* newMessageList = new (ELeave)CMsvEntrySelection();
	CleanupStack::PushL(newMessageList);
	serverEntry->GetChildren(*newMessageList);
	delete iOfflineCopy;
	iOfflineCopy = NULL;
	iOfflineCopy = CMtmTestHarness::NewL(*(iTestUtils->iPopServerMtm), *iTestUtils);
	// Copy all messages under the service to the local inbox.
	copyToLocal = CMtmTestCopyToLocal::NewL(*(iTestUtils->iPopServerMtm), newMessageList, KMsvGlobalInBoxIndexEntryId);
	iOfflineCopy->AddCommandL(CMtmTestCommandOnAllMessages::NewL(*(iTestUtils->iPopServerMtm), copyToLocal, iPop3Service, *(iTestUtils->iServerEntry)));
	// Connect
	iOfflineCopy->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMConnect, parameter));
	// Quit
	iOfflineCopy->AddCommandL(CMtmTestStartCommand::NewL(*(iTestUtils->iPopServerMtm), serviceSelection, KPOP3MTMDisconnect, parameter));


	CleanupStack::PopAndDestroy(2); // newMessageList, serviceSelection
	}

void CTestImapSyncManager::DeleteFolderL(const TDesC& aName)
	{
	TBuf8<128> parameter;
	TMsvId id = FindFolderL(aName);
	// delete
	CMsvEntrySelection* msvEntrySelection = new (ELeave) CMsvEntrySelection;
	msvEntrySelection->AppendL(id);
	iImapServerMtm->DeleteAllL(*msvEntrySelection,iActiveWaiter->iStatus);
	iActiveWaiter->WaitActive();
	delete msvEntrySelection;
	}

void CTestImapSyncManager::SetSubscriptionL(const TDesC& aName)
	{
	TBuf8<128> parameter;
	TMsvId id = FindFolderL(aName);
	CMsvEntrySelection*	msvEntrySelection = new (ELeave) CMsvEntrySelection;
	msvEntrySelection->Reset();
	msvEntrySelection->AppendL(id);
	iImapServerMtm->StartCommandL(*msvEntrySelection, KIMAP4MTMLocalSubscribe, parameter, iActiveWaiter->iStatus);
	iActiveWaiter->WaitActive();
	TBool sub = ((TMsvEmailEntry)iEntry->Entry()).LocalSubscription();
	delete msvEntrySelection;
	}

LOCAL_C void TestSetSendingStateAttributeL()
	{
	CDummyObserver* ob = new(ELeave)CDummyObserver;
	CleanupStack::PushL(ob);

	CMsvSession* session = CMsvSession::OpenSyncL(*ob);
	CleanupStack::PushL(session);

	CMsvEntry* cEntry = CMsvEntry::NewL(*session, KMsvDraftEntryId, TMsvSelectionOrdering());
	CleanupStack::PushL(cEntry);

	CMsvEntrySelection* selection = new(ELeave)CMsvEntrySelection;
	CleanupStack::PushL(selection);

	TMsvEntry entry1;
	entry1.iType = KUidMsvMessageEntry;
	entry1.iMtm = KUidMsvLocalServiceMtm;
	entry1.iServiceId = KMsvLocalServiceIndexEntryId;
	entry1.SetSendingState(12);
	cEntry->CreateL(entry1);
	selection->AppendL(entry1.Id());

	TMsvEntry entry2;
	entry2.iType = KUidMsvMessageEntry;
	entry2.iMtm = KUidMsvLocalServiceMtm;
	entry2.iServiceId = KMsvLocalServiceIndexEntryId;
	entry2.SetSendingState(3);
	cEntry->CreateL(entry2);
	selection->AppendL(entry2.Id());
	
	session->ChangeAttributesL(*selection, 6<<KMsvSendingStateShift, 0);

	cEntry->SetEntryL(entry1.Id());
	test(cEntry->Entry().SendingState() == 6);

	cEntry->SetEntryL(entry2.Id());
	test(cEntry->Entry().SendingState() == 6);
	
	CleanupStack::PopAndDestroy(4); // selection, cEntry, session, ob
	}

/**
doTestStepL()
It establishes connection with the Pop server using a POP account.
The account is identified by the account name that is read from the INI file.

@return
Returns the test step result
*/
TVerdict CT_MsgConnectPop3Server::doTestStepL()
	{	
	INFO_PRINTF1(_L(" Test Step : ConnectPop3Server"));
	TPtrC popAccountName;
	if(!GetStringFromConfig(ConfigSection(), KPopAccountName, popAccountName))
		{
		ERR_PRINTF1(_L("Pop Account Name is not specified"));
		SetTestStepResult(EFail);
		}

	else
		{
		// Retrieving the Pop service Id for the given Pop account
		TMsvId popServiceId = CT_MsgUtilsCentralRepository::GetPopServiceIdL((TDes&)popAccountName);
		INFO_PRINTF2(_L("Pop service id is %d"),popServiceId);

		// Change the current context
		iSharedDataPOP.iMtm->SwitchCurrentEntryL(popServiceId);

		CMsvEntrySelection* selection = new (ELeave) CMsvEntrySelection;
		CleanupStack::PushL(selection);

		// Appends the popServiceId onto the end of the array
		selection->AppendL(popServiceId);
		
		TBuf8<KMaxLenghtOfChar> param;

		CT_MsgActive&	active=Active();
		// Attempts to connect to the Pop3 Service
		iOperation = iSharedDataPOP.iMtm->InvokeAsyncFunctionL(KPOP3MTMConnect,*selection,param, active.iStatus);

		active.Activate();
		CActiveScheduler::Start();
	
		// Get the error code from TPop3Progress
		TPop3Progress temp;
		TPckgC<TPop3Progress> paramPack(temp);
		paramPack.Set(iOperation->ProgressL());
		TPop3Progress progress=paramPack();
		SetTestStepError(progress.iErrorCode);

		delete iOperation;
		iOperation=NULL;
		
		CleanupStack::PopAndDestroy(selection); //operation,selection
	//	User::LeaveIfError(active.Result());
		}
	return TestStepResult();
	}