/*
* Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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: 
* Implements the test steps for transaction management APIs in the SCR
*
*/


#include "transactionmanagementsteps.h"

using namespace Usif;


// -----------CScrApplyTransactionStep-----------------

CScrApplyTransactionStep::CScrApplyTransactionStep(CScrTestServer& aParent)	: CScrTestStep(aParent)
	{
	}

void CScrApplyTransactionStep::ImplTestStepPreambleL()
	{
	// empty
	}


void CScrApplyTransactionStep::ImplTestStepL()
	{
	User::LeaveIfError(iScrSession.Connect());
	iScrSession.CreateTransactionL();
	
	// Add a new component into SCR database
	TComponentId componentId= AddNonLocalisableComponentL();
	AppendSharedComponentIdL(componentId);
	
	// Register a file to the component
	TPtrC fileName;
	GetFileNameFromConfigL(fileName);
	iScrSession.RegisterComponentFileL(componentId, fileName);
	
	// Get a property from config file and set it.
	CPropertyEntry *property = GetPropertyFromConfigLC(ETrue);
	if(property->PropertyType() != CPropertyEntry::EIntProperty)
		{
		ERR_PRINTF1(_L("The property is not an integer property which is expected!"));
		User::Leave(KErrArgument);
		}
	CIntPropertyEntry *propertyInt = dynamic_cast<CIntPropertyEntry*>(property);
	iScrSession.SetComponentPropertyL(componentId, propertyInt->PropertyName(), propertyInt->IntValue());
	CleanupStack::PopAndDestroy(propertyInt);
	
	// Commit the transaction if it is marked in the configuration
	TBool isCommitTransaction(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("CommitTransaction"), isCommitTransaction);
	if(isCommitTransaction)
		{
		iScrSession.CommitTransactionL();
		}
	
	// Cancel thetransaction if it is marked in the configuration
	TBool isCancelTransaction(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("CancelTransaction"), isCancelTransaction);
	if(isCancelTransaction)
		{
		iScrSession.RollbackTransactionL();
		}
	
	// Close the session
	iScrSession.Close();
	}

void CScrApplyTransactionStep::ImplTestStepPostambleL()
	{
	// empty
	}


// -----------CScrCreateTransactionStep-----------------

void OpenSessionLC(RSoftwareComponentRegistry& aSession)
	{
	User::LeaveIfError(aSession.Connect());
	CleanupClosePushL(aSession);
	}

void CreateTransactionL(RSoftwareComponentRegistry& aSession)
	{
	aSession.CreateTransactionL();
	}
	
void OpenSubsessionL(RSoftwareComponentRegistry aSession, RSoftwareComponentRegistryView& aSubsession)
	{
	CComponentFilter *filter = CComponentFilter::NewL(); // NewL is used for the sake of coverage
	CleanupStack::PushL(filter);
	aSubsession.OpenViewL(aSession, filter);
	CleanupStack::PopAndDestroy(filter);
	}	

void OpenSubsessionLC(RSoftwareComponentRegistry aSession, RSoftwareComponentRegistryView& aSubsession)
	{
	OpenSubsessionL(aSession, aSubsession);
	CleanupClosePushL(aSubsession);
	}

CScrCreateTransactionStep::CScrCreateTransactionStep(CScrTestServer& aParent)	: CScrTestStep(aParent)
	{
	}

void CScrCreateTransactionStep::ImplTestStepPreambleL()
	{
	// empty
	}


void CScrCreateTransactionStep::ImplTestStepL()
	{
	RSoftwareComponentRegistry session1;
	RSoftwareComponentRegistry session2;
	RSoftwareComponentRegistryView subsession;
	RSoftwareComponentRegistryView subsession2;
	
	TBool isBeginTransactionBeforeSubsession(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("BeginTransactionBeforeSubsession"), isBeginTransactionBeforeSubsession);
	if(isBeginTransactionBeforeSubsession)
		{
		OpenSessionLC(session1);
		CreateTransactionL(session1);
		OpenSessionLC(session2);
		OpenSubsessionLC(session2, subsession);
		CleanupStack::PopAndDestroy(3, &session1);
		}
	
	TBool isOpenSubsessionInTheSameSession(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("OpenSubsessionInTheSameSession"), isOpenSubsessionInTheSameSession);
	if(isOpenSubsessionInTheSameSession)
		{
		OpenSessionLC(session1);
		CreateTransactionL(session1);
		OpenSubsessionLC(session1, subsession);
		CleanupStack::PopAndDestroy(2, &session1);
		
		// Now do the same,  but in reverse order
		OpenSessionLC(session1);
		OpenSubsessionLC(session1, subsession);		
		CreateTransactionL(session1);
		CleanupStack::PopAndDestroy(2, &session1);
		}
		
	TBool isBeginTransactionAfterSubsession(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("BeginTransactionAfterSubsession"), isBeginTransactionAfterSubsession);
	if(isBeginTransactionAfterSubsession)
		{		
		OpenSessionLC(session1);
		OpenSessionLC(session2);
		OpenSubsessionLC(session1, subsession);
		CreateTransactionL(session2);
		CleanupStack::PopAndDestroy(3, &subsession);
		}
	
	TBool isBeginTransactionInTheSameSession(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("BeginTransactionInTheSameSession"), isBeginTransactionInTheSameSession);
	if(isBeginTransactionAfterSubsession)
		{		
		OpenSessionLC(session1);
		OpenSubsessionLC(session1, subsession);
		CreateTransactionL(session1);
		CleanupStack::PopAndDestroy(2, &subsession);
		}
		
	TBool isBeginAfterAnotherBegin(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("BeginTransactionAfterAnotherBegin"), isBeginAfterAnotherBegin);
	if(isBeginAfterAnotherBegin)
		{
		OpenSessionLC(session1);
		CreateTransactionL(session1);
		OpenSessionLC(session2);
		CreateTransactionL(session2);
		CleanupStack::PopAndDestroy(2, &session1);
		}
	
	TBool isMultipleSubsessions(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("MultipleSubsessions"), isMultipleSubsessions);
	if(isMultipleSubsessions)
		{
		OpenSessionLC(session1);
		OpenSubsessionLC(session1, subsession);
		OpenSessionLC(session2);
		OpenSubsessionLC(session2, subsession2);
		CleanupStack::PopAndDestroy(4, &session1);
		}
	
	TBool isWriteAfterBegin(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("WriteAfterBeginTransaction"), isWriteAfterBegin);
	if(isWriteAfterBegin)
		{
		OpenSessionLC(session1);
		CreateTransactionL(session1);
		OpenSessionLC(session2);
		session2.AddComponentL(_L("test"),_L("vendor"),_L("plain"));	
		CleanupStack::PopAndDestroy(2, &session1);
		}
	
	TBool isReadAfterBegin(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("ReadAfterBeginTransaction"), isReadAfterBegin);
	if(isReadAfterBegin)
		{
		OpenSessionLC(session1);
		CreateTransactionL(session1);
		OpenSessionLC(session2);
		CComponentEntry *entry = CComponentEntry::NewLC();
		session2.GetComponentL(1, *entry);	
		CleanupStack::PopAndDestroy(3, &session1);
		}
		
	TBool mutatingOperationWithSubsession(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("MutatingOperationWithSubsession"), mutatingOperationWithSubsession);
	if(mutatingOperationWithSubsession)
		{
		OpenSessionLC(session1);
		OpenSubsessionLC(session1, subsession);
		OpenSessionLC(session2);
		session2.AddComponentL(_L("test"),_L("vendor"),_L("plain"));
		CleanupStack::PopAndDestroy(3, &session1); // session2, subsession
		}	
		
	TBool closeSessionWithoutClosingSubsession(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("CloseSessionWithoutClosingSubsession"), closeSessionWithoutClosingSubsession);
  	if(closeSessionWithoutClosingSubsession)
   		{
   		OpenSessionLC(session1);
  		CreateTransactionL(session1);
  		OpenSubsessionL(session1, subsession);
  		OpenSubsessionL(session1, subsession2);
  		CComponentEntry *entry = subsession.NextComponentL();
  		CleanupStack::PushL(entry);
  		CComponentEntry *entry2 = subsession2.NextComponentL();
  		CleanupStack::PushL(entry2);		
  		CleanupStack::PopAndDestroy(3, &session1); // entry, entry2
		}
	
	
	TBool isMultipleActiveSubsessions (EFalse);
	GetBoolFromConfig(ConfigSection(), _L("MultipleActiveSubsessions"), isMultipleActiveSubsessions);
 	if(isMultipleActiveSubsessions)
 	    {
		OpenSessionLC(session1);
 	 	OpenSubsessionLC(session1, subsession);
 	 	TInt foundRecords (0);
 	 	CComponentEntry *entry = subsession.NextComponentL();
 	 	if(entry)
			{
			++foundRecords;
 	 	 	delete entry;
 	 	 	entry = NULL;
 	 	 	}

		OpenSessionLC(session2);
 	 	CComponentFilter *filter = CComponentFilter::NewL(); // NewL is used for the sake of coverage
 	 	CleanupStack::PushL(filter);
 	 	filter->SetNameL(_L("nonexistingcomponentnamefortransactionmanagementtest"));
 	 	filter->SetVendorL(_L("nonexistingvendornamefortransactionmanagementtest"));
 	 	subsession2.OpenViewL(session2, filter);
 	 	CleanupStack::PopAndDestroy(filter);
 	 	CleanupClosePushL(subsession2);
 	 	
 	 	CComponentEntry *entry2 = subsession2.NextComponentL();
 	 	if(entry2)
			{
 	 	 	delete entry2;
 	 	 	entry2 = NULL;
 	 	 	entry2 = subsession2.NextComponentL();
 	 	 	ERR_PRINTF1(_L("Subsession2 has unexpectedly retrieved a component!"));
 	 	 	SetTestStepResult(EFail);
 	 	 	}
		CleanupStack::PopAndDestroy(2, &session2); // session2, subsession2

 	 	entry = subsession.NextComponentL();
 	 	while(entry)
			{
 	 	 	++foundRecords;
 	 	 	delete entry;
 	 	 	entry = NULL;
 	 	 	entry = subsession.NextComponentL();
 	 	 	}
		if(foundRecords < 2)
			{
 	 	 	ERR_PRINTF1(_L("Subsession1 has unexpectedly reached the end of the view!"));
 	 	 	SetTestStepResult(EFail);
 	 	 	}
		CleanupStack::PopAndDestroy(2, &session1);
 	 	}	
	}

void CScrCreateTransactionStep::ImplTestStepPostambleL()
	{
	// empty
	}

// -----------CScrManageAnotherTransactionStep-----------------

CScrManageAnotherTransactionStep::CScrManageAnotherTransactionStep(CScrTestServer& aParent)	: CScrTestStep(aParent)
	{
	}

void CScrManageAnotherTransactionStep::ImplTestStepPreambleL()
	{
	// empty
	}


void CScrManageAnotherTransactionStep::ImplTestStepL()
	{
	User::LeaveIfError(iScrSession.Connect());
	iScrSession.CreateTransactionL();
	
	RSoftwareComponentRegistry anotherSession;
	User::LeaveIfError(anotherSession.Connect());
	CleanupClosePushL(anotherSession);
	
	// Commit the transaction if it is marked in the configuration
	TBool isCommitTransaction(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("CommitTransaction"), isCommitTransaction);
	if(isCommitTransaction)
		anotherSession.CommitTransactionL();
	
	TBool isCancelTransaction(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("CancelTransaction"), isCancelTransaction);
	if(isCancelTransaction)
		anotherSession.RollbackTransactionL();
	
	TBool isInvokeMutatingFunction(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("InvokeMutatingFunction"), isInvokeMutatingFunction);
	if(isInvokeMutatingFunction)
		anotherSession.AddComponentL(_L("test"), _L("vendor"),_L("plain"));
	
	TBool isInvokeNonMutatingFunction(EFalse);
	GetBoolFromConfig(ConfigSection(), _L("InvokeNonMutatingFunction"), isInvokeNonMutatingFunction);
	if(isInvokeNonMutatingFunction)
		{
		RArray<TComponentId> componentIdList;
		anotherSession.GetComponentIdsL(componentIdList);
		componentIdList.Close();
		}
	
	CleanupStack::PopAndDestroy(&anotherSession);
	iScrSession.Close();
	}

void CScrManageAnotherTransactionStep::ImplTestStepPostambleL()
	{
	// empty
	}