// Copyright (c) 1996-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:
// File Name:		f32test/bench/t_fat_perf_impl.cpp
// This file contains FRAMEWORK implementation for the tests to test
// the FAT Performance on large number of files (PREQ 1885).
// 
//

// Include Files
#include "t_fat_perf.h"
#include <e32math.h>
#include <hal.h>

const TInt gMeasurementScale = K1mSec;	// defines the scales of measurement 

CMeasureAndLogUnit::CMeasureAndLogUnit()
	{
     
	}

void CMeasureAndLogUnit::ConstructL(const TMLUnitParam& aParam)
	{
	iID = aParam.iID;
	User::LeaveIfError(HAL::Get(HALData::EFastCounterFrequency, iFreq));
	iScale = gMeasurementScale;
	iLogItemNo = 1;
	}

CMeasureAndLogUnit* CMeasureAndLogUnit::NewLC(const TMLUnitParam& aParam)
	{
	CMeasureAndLogUnit* self = new(ELeave) CMeasureAndLogUnit();
	CleanupStack::PushL(self);
	self->ConstructL(aParam);
	return self;
	}

CMeasureAndLogUnit* CMeasureAndLogUnit::NewL(const TMLUnitParam& aParam)
	{
	CMeasureAndLogUnit* self = CMeasureAndLogUnit::NewLC(aParam);
	CleanupStack::Pop(self);
	return self;
	}

CMeasureAndLogUnit::~CMeasureAndLogUnit()
	{

	}

TInt CMeasureAndLogUnit::MeasureStart()
	{
	iStartStatus = User::FastCounter();
	return KErrNone;
	}
TInt CMeasureAndLogUnit::MeasureEnd()
	{
	iEndStatus = User::FastCounter();
	return KErrNone;
	}

//Measurement and Log unit
TInt CMeasureAndLogUnit::Log(const TFileName& aDirName, const TFileName& aFileName, TUint aCurrentFileNo, TUint aCurrentFilePos)
	{
	TReal measure = iScale * ((TReal)(iEndStatus - iStartStatus)) / ((TReal) iFreq);
	TBuf<0x10> scale;
	if (iScale == K1mSec)  
		{
		scale = _L("millisecond");
		}
	else if (iScale == K1Sec) 
		{
		scale = _L("second");
		}
	else if (iScale == K1uSec) 
		{
		scale = _L("microsecond");
		}
	test.Printf(_L("[LOG]: \t%u \t\"%S\" \t%f \t%S \t\"%S\" \t%u \t%u\n"), 
					iLogItemNo, &aDirName, measure, &scale, &aFileName, aCurrentFileNo, aCurrentFilePos);

	iLogItemNo++;

	return KErrNone;
	}



CFileOperationUnit::CFileOperationUnit()
:iDirCreated(EFalse)
	{

	}

// File Operation Unit
void CFileOperationUnit::ConstructL(const TFileOpUnitParam& aParam)
	{
	iDirName = aParam.iDirName;
	iNamingSchemeParam = aParam.iNamingSchemeParam;
	iFileOpMode = aParam.iFileOpMode;
	iMLUnitPtr = aParam.iMLUnitPtr;

	TInt rel = iRFs.Connect();
	if (rel != KErrNone)
		{
		test.Printf(_L("<<Error>>: DIRUNIT: iRFs.Connect = %d\n"), rel);
		test(EFalse);
		}
	}


CFileOperationUnit* CFileOperationUnit::NewLC(const TFileOpUnitParam& aParam)
	{
	CFileOperationUnit* self = new(ELeave) CFileOperationUnit();
	CleanupStack::PushL(self);
	self->ConstructL(aParam);
	return self;
	}

CFileOperationUnit* CFileOperationUnit::NewL(const TFileOpUnitParam& aParam)
	{
	CFileOperationUnit* self = CFileOperationUnit::NewLC(aParam);
	CleanupStack::Pop(self);
	return self;
    }

CFileOperationUnit::~CFileOperationUnit()
	{
	iRFs.Close();
	}

void CFileOperationUnit::SetMLUnit(CMeasureAndLogUnit* aMLUnit)
	{
	iMLUnitPtr = aMLUnit;
	}


// File Operation unit - Test Functions 
TInt CFileOperationUnit::Run(const TFileName& aDirName, const TFileName& aFileName, TBool aIsTakingMeasurement, TUint aCurFileNo, TUint aCurFilePos)
	{
	TMLParam mlParam;
	RFile	rfile;
	TInt	rel = KErrNone;
	TInt	rel1 = KErrNone; 
	TInt	bufMaxLength = 4096;
	TInt	Ret1 = KErrNone; 
	TInt	Ret2 = KErrNone; 
	RBuf8 	buf; 
	RBuf8	databuf;

		
	if (aIsTakingMeasurement && iMLUnitPtr != NULL)
		{
		mlParam.iDirName = iDirName;
		mlParam.iFileName = aFileName;
		mlParam.iNamingScheme = iNamingSchemeParam;
		mlParam.iCurFileNo = aCurFileNo;
		mlParam.iFileOpMode = iFileOpMode;
		}
	else if (aIsTakingMeasurement && iMLUnitPtr == NULL)
		{
		test.Printf(_L("<<Error>>CZFileOperationUnit::Run(): no logging unit associated!!\n"));
		return KErrGeneral;
		}

	switch (iFileOpMode)
		{
		case EFATPerfFileReplace:		// Replace Operations
			{
			test.Printf(_L("CZFileOperationUnit::Run(): EZFileReplace\n"));
			break;
			}
		case EFATPerfFileCreate:
			{
			if (!iDirCreated && gTestCase != EFATPerfCreate)  // 'EFATPerfCreate' is  an enum defined in header file t_fat_perf.h
				{
				rel = iRFs.MkDirAll(aFileName);
				test.Printf(_L("MakeDirAll \"%S\" error: %d\n"), &aFileName, rel);					
				if (rel != KErrNone && rel != KErrAlreadyExists)
					{
					test.Printf(_L("<<Error>>: MakeDirAll \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
				iDirCreated = ETrue;
				}
			if (aIsTakingMeasurement)
				{
				iMLUnitPtr->MeasureStart();
				rel = rfile.Create(iRFs, aFileName, EFileShareAny);
				iMLUnitPtr->MeasureEnd();
				iMLUnitPtr->Log(aDirName, aFileName, aCurFileNo, aCurFilePos);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileCreating \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
				}
			else
				{
				rel = rfile.Create(iRFs, aFileName, EFileShareAny);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileCreating error: %d\n"), rel);
					return rel;
					}
				}
			break;
			}
	
		case EFATPerfFileOpen:      // Open Operations
			{
			if (aIsTakingMeasurement)
				{
				iMLUnitPtr->MeasureStart();
				rel = rfile.Open(iRFs, aFileName, EFileShareAny);
				iMLUnitPtr->MeasureEnd();
				iMLUnitPtr->Log(aDirName, aFileName, aCurFileNo, aCurFilePos);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileOpen \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
				}
			else
				{
				rel = rfile.Open(iRFs, aFileName, EFileShareAny);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileOpen error: %d\n"), rel);
					return rel;
					}
				}
			break;
			}
		
	
		case EFATPerfFileDelete:     // Delete Operations
			{
			
		
			if (aIsTakingMeasurement)
				{
				iMLUnitPtr->MeasureStart();
				rel = iRFs.Delete(aFileName);
				iMLUnitPtr->MeasureEnd();
				iMLUnitPtr->Log(aDirName, aFileName, aCurFileNo, aCurFilePos);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileDelete \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
															
				}
			else
				{
			
				rel = rfile.Open(iRFs, aFileName, EFileShareAny);
				if (rel != KErrNone)
				{
					test.Printf(_L("<<Error>>: FileOpen \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
				rfile.Close(); // file needs be closed before  deleting.
				
				rel = iRFs.Delete(aFileName);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileDelete \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
						
				}
			break;
			}
		
			
			
		case EFATPerfFileWrite:			//Write Operations
			{
			
			// creating buffer for Write operation 
			Ret2 = databuf.CreateMax(bufMaxLength);
	
			if (Ret2 != KErrNone)
				{
				test.Printf(_L("<<Error>>: Unable to create a buffer 'databuf': %d\n"), Ret2);
				return Ret2;
				}
			
			databuf.Fill('A', bufMaxLength);	
	
					
			if (aIsTakingMeasurement)
				{
				
				rel = rfile.Open(iRFs, aFileName, EFileShareAny|EFileWrite);
				iMLUnitPtr->MeasureStart();
				rel1 = rfile.Write(databuf);
				iMLUnitPtr->MeasureEnd();
				iMLUnitPtr->Log(aDirName, aFileName, aCurFileNo, aCurFilePos);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileOpen \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
			
				if (rel1 != KErrNone)
				{
				test.Printf(_L("<<Error>>: FileWrite \"%S\" error: %d\n"), &aFileName, rel1);
				return rel1;
				}
								
				}
			else
				{
			
				rel = rfile.Open(iRFs, aFileName, EFileShareAny|EFileWrite);
				rel1 = rfile.Write(databuf);
				
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileOpen error: %d\n"), rel);
					return rel;
					}
				
				if (rel1 != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileWrite error: %d\n"), rel1);
					return rel1;
					}
				}
			break;
			}
		
		
		
		case EFATPerfFileRead:			// Read Operations
			{
			
			// creating the buffer for Read operation 
			Ret1 = buf.CreateMax(bufMaxLength);	
			if (Ret1 != KErrNone)
				{
				test.Printf(_L("<<Error>>: Unable to create a buffer 'buf': %d\n"), Ret1);
				return Ret1;
				}
			
		
			if (aIsTakingMeasurement)
				{
				
				rel = rfile.Open(iRFs, aFileName, EFileShareAny|EFileRead);
				iMLUnitPtr->MeasureStart();
				rel1 = rfile.Read(buf);
				iMLUnitPtr->MeasureEnd();
				iMLUnitPtr->Log(aDirName, aFileName, aCurFileNo, aCurFilePos);
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileOpen \"%S\" error: %d\n"), &aFileName, rel);
					return rel;
					}
				if (rel1 != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileRead \"%S\" error: %d\n"), &aFileName, rel1);
					return rel1;
					}
				}
			else
				{
				rel = rfile.Open(iRFs, aFileName, EFileShareAny|EFileRead);
				rel1 = rfile.Read(buf);
				
				if (rel != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileOpen error: %d\n"), rel);
					return rel;
					}
				
				if (rel1 != KErrNone)
					{
					test.Printf(_L("<<Error>>: FileRead \"%S\" error: %d\n"), &aFileName, rel1);
					return rel1;
					}
			 	}
			break;
			}
		
		default:
			{
			// Error: KErrNotSupported!!
			test.Printf(_L("<<Error>>CZFileOperationUnit::Run(): KErrNotSupported!!\n"));
			return KErrNotSupported;
			}
		 }

	rfile.Close();
	buf.Close(); 
	databuf.Close();
	return KErrNone;
	}



CDirUnit::CDirUnit()
	{

	}

void CDirUnit::ConstructL(const TDirUnitParam& aParam, const TChar aDriveChar)
	{
	iPriority = aParam.iPriority;
	iDirName.Copy(aParam.iDirName);
	iDirName[0] = (TUint16)aDriveChar;  
	iRuns = aParam.iRuns;
	iCurrentRunNo = 1;
	iFilesPerRun = aParam.iFilesPerRun;
	iCurrentFileNo = 1;
	iTotalFileNo = iRuns * iFilesPerRun;
	iSampleInterval = aParam.iSampleInterval;
	
	
	iConOrRan = aParam.iNamingScheme.iConOrRan;
	iUniOrAsc = aParam.iNamingScheme.iUniOrAsc;
	iZeroPadFileNumberForFixedLengthFileNames = aParam.iNamingScheme.iZeroPadFileNumber;
	iFileNameBase = aParam.iNamingScheme.iFileNameBase;
	iMaxFileNameLength = aParam.iNamingScheme.iMaxFileNameLength;
	iMinStringLength = aParam.iNamingScheme.iMinStringLength;

	if (iZeroPadFileNumberForFixedLengthFileNames)
	    {
	    // Calculate how many digits the highest file postfix will have so that
	    // zero padding can be added.
	    TFileName fileNamePostFixBuffer;
	    fileNamePostFixBuffer.AppendNum(iTotalFileNo);
	    iNumDigitsInTotalFileNo = fileNamePostFixBuffer.Length();
	    }
	else
	    {
	    iNumDigitsInTotalFileNo = 0;
	    }
	
	TFileOpUnitParam fileOpParam;
	fileOpParam.iDirName = iDirName;
	fileOpParam.iNamingSchemeParam = aParam.iNamingScheme;
	fileOpParam.iFileOpMode = aParam.iFileOpMode;
	fileOpParam.iMLUnitPtr = iMLUnitPtr;
	CFileOperationUnit* fileOpUnit = CFileOperationUnit::NewL(fileOpParam);
	iFileOpUnit = fileOpUnit;
	}

CDirUnit* CDirUnit::NewLC(const TDirUnitParam& aParam, const TChar aDriveChar)
	{
	CDirUnit* self = new(ELeave) CDirUnit();
	CleanupStack::PushL(self);
	self->ConstructL(aParam, aDriveChar);
	return self;
	}

CDirUnit* CDirUnit::NewL(const TDirUnitParam& aParam, const TChar aDriveChar)
	{
	CDirUnit* self = CDirUnit::NewLC(aParam, aDriveChar);
	CleanupStack::Pop(self);
	return self;
	}

CDirUnit::~CDirUnit()
	{
	delete iFileOpUnit;
	}

TInt CDirUnit::Priority()
	{
	return iPriority;
	}

const TFileName&	CDirUnit::Name()
	{
	return iDirName;
	}


_LIT(KFileExtDefault,	".TXT");

//Character set for random file generation
static TText16 gFileNameCharPool[] =
	{
	'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
//	'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',	
	'-', '_', '^', '$', '~', '!', '#', '%', '&', '{', '}', '@', '(', ')', '\'',
	'1', '2', '3', '4', '5', '6', '7', '8', '9', '0',
	};

const TUint KNumOfLegalAsciiChar = 51;


// Random String Generation for file names
TFileName CDirUnit::GenerateRandomString(const TUint aMinStringLength, const TUint aMaxStringLength, const TNamingUniOrAsc aUniOrAsc)
	{
	TInt strLen = -1;
	TFileName aFileName;
	
	if (aMinStringLength == aMaxStringLength && aMaxStringLength != 0)
		{
		strLen = aMinStringLength;
		}
	else if (aMaxStringLength > aMinStringLength)
		{
		do
			{
			strLen = aMinStringLength + ((TUint) (Math::Random())) % (aMaxStringLength - aMinStringLength);
			}
		while (strLen == 0);
		}
	else
		{
		test.Printf(_L("<<Random String Error>>: Bad String Length Setting!!\n"));
		}
	
	if (aUniOrAsc == EAscii)
		{
		TInt i;
		for (i = 0; i < strLen; ++i)
			{
			TInt nextCharIdx = (((TUint) (Math::Random())) % KNumOfLegalAsciiChar);
			aFileName.Append((TChar)gFileNameCharPool[nextCharIdx]);
			}
		}
	else if(aUniOrAsc == EUnicode)
		{
		test.Printf(_L("<<Random String Error>>: Unicode is not supported yet!!\n"));
		}
    else 
        {
        test(0);
        }

	return aFileName;
	}

TBool CDirUnit::FileNameIsUnique(const TFileName& /*aFileName*/)
	{

	return ETrue;

	}

// File Name Generation
TInt CDirUnit::GenerateFileName(TFileName& aFileName)
	{
	TBool fileNameIsUnique = EFalse;
	if (iRuns == iFilesPerRun && iFilesPerRun == 1)
		{
		aFileName.Zero();
		aFileName.Append(iDirName);
		aFileName.Append(iFileNameBase);
		aFileName.Append(KFileExtDefault);
		fileNameIsUnique = FileNameIsUnique(aFileName);
		if (fileNameIsUnique == EFalse)
			{
			test.Printf(_L("<<Error>>: File name is not unique!\n"));
			return KErrArgument;
			}
		return KErrNone;
		}
	
	if (iConOrRan == EConsecutive)
		{
		aFileName.Zero();
		aFileName.Append(iDirName);
		aFileName.Append(iFileNameBase);
		
		if (iZeroPadFileNumberForFixedLengthFileNames)
		    {
		    aFileName.AppendNumFixedWidth(iCurrentFileNo, EDecimal, iNumDigitsInTotalFileNo);
		    }
		else
		    {
		    aFileName.AppendNum(iCurrentFileNo);
		    }

		aFileName.Append(KFileExtDefault);
		fileNameIsUnique = FileNameIsUnique(aFileName);
		if (fileNameIsUnique == EFalse)
			{
			test.Printf(_L("<<Error>>: File name is not unique!\n"));
			return KErrArgument;
			}
		return KErrNone;
		}
	else if(iConOrRan == ERandom)
		{
		if (iMaxFileNameLength <= 0)
			{
			test.Printf(_L("<<Parameter Error>>: DIR: \"%S\"\n"), &iDirName);
			test.Printf(_L("<<Parameter Error>>: EZRandom && iMaxNameLength <= 0\n"));
			return KErrArgument;
			}

		do
			{
			aFileName.Zero();
			aFileName.Append(iDirName);
			aFileName.Append(iFileNameBase);
			TFileName randomString = GenerateRandomString(iMinStringLength, iMaxFileNameLength, iUniOrAsc);
			aFileName.Append(randomString);
			aFileName.Append(KFileExtDefault);
			fileNameIsUnique = FileNameIsUnique(aFileName);
			}
		while(fileNameIsUnique == EFalse);
		
		return KErrNone;
		}

	return KErrNone;
	}

void CDirUnit::SetMLUnit(CMeasureAndLogUnit* aMLUnitPtr)
	{
	iMLUnitPtr = aMLUnitPtr;
	iFileOpUnit->SetMLUnit(aMLUnitPtr);
	}

TBool CDirUnit::CheckMeasurementTaking()
	{
	
	return (iSampleInterval > 0 && 
			iCurrentFileNo >= iSampleInterval && 
			((iCurrentFileNo % iSampleInterval) == 0));
	}

TInt CDirUnit::Run(const TInt aCurrentPriority)
	{
	if (aCurrentPriority != iPriority)
		{
		return KErrNotReady;
		}


	if (iCurrentRunNo <= iRuns)
		{
		
		TUint i;
		for (i = 0; i < iFilesPerRun; ++i, ++iCurrentFileNo)
			{
			// check currentFileNo < totalFileNo
			if (iCurrentFileNo > iTotalFileNo)
				{
				// Error
				User::Panic(_L("<<CZDirUnit::Run>>: file overflow!"), 100);
				}
			// generate file name
			TFileName fileName;
			GenerateFileName(fileName);
			
			// check if is taking measurement
			TBool isTakingMeasurement = CheckMeasurementTaking();

			// file operation
			iFileOpUnit->Run(iDirName, fileName, isTakingMeasurement, iCurrentFileNo, iCurrentFileNo);
			}
		iCurrentRunNo++;
		}

	if (iCurrentRunNo > iRuns)
		{
		return KErrCompletion;
		}
	return KErrNone;
	}



CExecutionUnit::CExecutionUnit()
	{

	}

void CExecutionUnit::ConstructL(CMeasureAndLogUnit* aMLUnitPtr, const TChar aDriveChar)
	{
	iCurPriority = -1;
	iDriveChar = aDriveChar;

	if (aMLUnitPtr != NULL)
		{
		iMLUnitPtr = aMLUnitPtr;
		}
	}

CExecutionUnit* CExecutionUnit::NewLC(CMeasureAndLogUnit* aMLUnitPtr, const TChar aDriveChar)
	{
	CExecutionUnit* self = new(ELeave) CExecutionUnit();
	CleanupStack::PushL(self);
	self->ConstructL(aMLUnitPtr, aDriveChar);
	return self;
	}

CExecutionUnit* CExecutionUnit::NewL(CMeasureAndLogUnit* aMLUnitPtr, const TChar aDriveChar)
	{
	CExecutionUnit* self = CExecutionUnit::NewLC(aMLUnitPtr, aDriveChar);
	CleanupStack::Pop(self);
	return self;
	}

CExecutionUnit::~CExecutionUnit()
	{
	TInt count = iDirUnitArray.Count();
	if (count > 0)
		{
		TInt i;
		for (i = 0; i < count; ++i)
			{
			CDirUnit* tempDirUnit = iDirUnitArray[i];
			delete tempDirUnit;
			}
		}
	iDirUnitArray.Close();
	}


TInt CExecutionUnit::AddDirUnitL(const TDirUnitParam& aParam)
	{
	CDirUnit* dirUnit = CDirUnit::NewL(aParam, iDriveChar);
	if (iMLUnitPtr)
		{
		dirUnit->SetMLUnit(iMLUnitPtr);
		}
	TInt rel = iDirUnitArray.Append(dirUnit);
	return rel;
	}


// To Re-calculate the priority
TInt CExecutionUnit::RecalculateCurrentPrioirty()
	{
	// findout the least number of iPriority in current array
	if (iDirUnitArray.Count() == 0)
		{
		iCurPriority = -1;
		return iCurPriority;
		}

	TBool found = EFalse;

	TInt i;
	
	for (i = 0; i < iDirUnitArray.Count(); ++i)
		{
		if (iDirUnitArray[i]->Priority() == iCurPriority)
			{
			found = ETrue;
			}
		}
	
	if (!found)
		{
		iCurPriority = iDirUnitArray[0]->Priority();
		for (i = 0; i < iDirUnitArray.Count(); ++i)
			{
			if (iDirUnitArray[i]->Priority() < iCurPriority)
				{
				iCurPriority = iDirUnitArray[i]->Priority();
				}
			}
		}

	return iCurPriority;
	}

TInt  CExecutionUnit::Run()
	{
	test.Printf(_L("CZExecutionUnit::Run()\n"));
	
	TInt curPriority = RecalculateCurrentPrioirty();
	
	while (iDirUnitArray.Count() > 0)
		{
		TInt i;
		for (i = 0; i < iDirUnitArray.Count(); ++i)
			{
			TInt rel = iDirUnitArray[i]->Run(curPriority);
			if (rel == KErrCompletion)
				{
				test.Printf(_L("DIR: \"%S\" terminated.\n"), &iDirUnitArray[i]->Name());
				CDirUnit* dirUnit = iDirUnitArray[i];
				iDirUnitArray.Remove(i);
				delete dirUnit;
				--i;
				curPriority = RecalculateCurrentPrioirty();
				}
			else if (rel == KErrNotReady)
				{
				// do nothing
            	}
			}
		}

	test.Printf(_L("\n"));
	test.Printf(_L("CZExecutionUnit::Finished.\n"));
	return KErrNone;
	}

/*-- EOF--*/