--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/imaging/imagingfws/MediaClientImage/Source/Test/TMdaStress/Tmdatest.cpp	Wed Aug 25 12:29:52 2010 +0300
@@ -0,0 +1,457 @@
+// Copyright (c) 2000-2009 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:
+// TMDAVID1.CPP
+// These tests are designed to perform multiple Media Server opertaions by using multiple threads
+// each containing many active objects.
+// 
+//
+
+#include "tmdatest.h"
+
+
+/*********************************************************************************************/
+class CStressTestMonitor : public CBase
+	{
+public:
+	void IncActiveCount();
+	void DecActiveCount();
+	void SetError(TInt aError);
+	TInt Error();
+private:
+	TInt iActiveCount;
+	TInt iError;
+	};
+
+void CStressTestMonitor::IncActiveCount()
+	{
+	iActiveCount++;
+	}
+
+void CStressTestMonitor::DecActiveCount()
+	{
+	iActiveCount--;
+	if(iActiveCount==0)
+		CActiveScheduler::Stop();
+	}
+
+void CStressTestMonitor::SetError(TInt aError)
+	{
+	if(iError==KErrNone)
+		iError = aError;
+	}
+
+TInt CStressTestMonitor::Error()
+	{
+	return(iError);
+	}
+
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+class CStressTestActive : public CActive
+	{
+public:
+	inline CStressTestActive(CStressTestMonitor& aMonitor) : CActive(EPriorityStandard), iMonitor(&aMonitor) { aMonitor.IncActiveCount(); }
+	~CStressTestActive();
+protected:
+	// From CActive
+	TInt RunError(TInt aError);
+	// New
+	void SetPending();
+public:
+	CStressTestMonitor* iMonitor;
+	};
+
+CStressTestActive::~CStressTestActive()
+	{
+	iMonitor->DecActiveCount();
+	}
+
+void CStressTestActive::SetPending()
+	{
+	if(!IsAdded())
+		CActiveScheduler::Add(this);
+	iStatus = KRequestPending;
+	SetActive();
+	}
+
+TInt CStressTestActive::RunError(TInt aError)
+	{
+	iMonitor->SetError(aError);
+	delete this;
+	return KErrNone;
+	}
+
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+class CImageUtil : public CStressTestActive, public MMdaImageUtilObserver
+	{
+public:
+	inline CImageUtil(CStressTestMonitor& aMonitor) : CStressTestActive(aMonitor) {}
+private:
+	virtual void MiuoCreateComplete(TInt aError);
+	virtual void MiuoOpenComplete(TInt aError);
+	virtual void MiuoConvertComplete(TInt aError);
+	};
+
+void CImageUtil::MiuoCreateComplete(TInt aError)
+	{
+	TRequestStatus* status = &iStatus;
+	User::RequestComplete(status,aError);
+	}
+
+void CImageUtil::MiuoOpenComplete(TInt aError)
+	{
+	TRequestStatus* status = &iStatus;
+	User::RequestComplete(status,aError);
+	}
+
+void CImageUtil::MiuoConvertComplete(TInt aError)
+	{
+	TRequestStatus* status = &iStatus;
+	User::RequestComplete(status,aError);
+	}
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+class CImageLoadUtil : public CImageUtil
+	{
+public:
+	static CImageLoadUtil* NewL(CStressTestMonitor& aMonitor,const TDesC& aFileName,const TDisplayMode aDisplayMode);
+	~CImageLoadUtil();
+private:
+	inline CImageLoadUtil(CStressTestMonitor& aMonitor) : CImageUtil(aMonitor) {};
+	void RunL();
+	void DoCancel();
+private:
+	TBuf<255> iMessage;
+	TDisplayMode iDisplayMode;
+	CFbsBitmap* iBitmap;
+	CMdaImageFileToBitmapUtility* iMdaUtil;
+	TInt iState;
+	};
+
+CImageLoadUtil* CImageLoadUtil::NewL(CStressTestMonitor& aMonitor,const TDesC& aFileName,const TDisplayMode aDisplayMode)
+	{
+	CImageLoadUtil* ptr = new (ELeave) CImageLoadUtil(aMonitor);
+
+	CleanupStack::PushL(ptr);
+
+	ptr->iBitmap = new(ELeave) CFbsBitmap;
+	ptr->iDisplayMode = aDisplayMode;
+
+	ptr->iMdaUtil = CMdaImageFileToBitmapUtility::NewL(*ptr);
+
+	ptr->iMessage.Append(_L("Loading image "));
+	ptr->iMessage.Append(aFileName);
+
+	ptr->iMdaUtil->OpenL(aFileName,NULL,NULL,NULL);
+
+	CleanupStack::Pop();
+
+	ptr->SetPending();
+
+	return ptr;
+	}
+
+CImageLoadUtil::~CImageLoadUtil()
+	{
+	Cancel();
+	delete iBitmap;
+	delete iMdaUtil;
+	}
+
+void CImageLoadUtil::RunL()
+	{
+	TInt error = iStatus.Int();
+
+	if(error==KErrNone)
+		{
+		if(!iState)
+			{
+			TFrameInfo frameInfo;
+			iMdaUtil->FrameInfo(0,frameInfo);
+
+			iBitmap->Reset();
+			error = iBitmap->Create(frameInfo.iOverallSizeInPixels,iDisplayMode);
+			if(error==KErrNone)
+				{
+				TRAP(error,iMdaUtil->ConvertL(*iBitmap));
+				if(error==KErrNone)
+					{
+					iState++;
+					SetPending();
+					return;
+					}
+				}
+			}
+		}
+
+	if(error!=KErrNone)
+		{
+		iMessage.AppendFormat(_L(" - Failed with error %d"),error);
+		RDebug::Print(iMessage);
+		User::Leave(error);
+		}
+	else
+		{
+		iMessage.AppendFormat(_L(" - Finished OK"));
+		RDebug::Print(iMessage);
+		}
+	delete this;
+	}
+
+void CImageLoadUtil::DoCancel()
+	{
+	iMdaUtil->Cancel();
+	}
+
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+GLDEF_C TInt TestStartupThread(TAny* /*aParam*/)
+	{
+	return KErrNone;
+	}
+/*********************************************************************************************/
+
+
+
+
+/*********************************************************************************************/
+void DoTestLoadImagesL(CMdaStressTestThread* aThread)
+	{
+	TInt err;
+
+	 // Install active scheduler
+	CActiveScheduler* as = new CActiveScheduler;
+	__ASSERT_ALWAYS(as,User::Invariant());	
+	CActiveScheduler::Install(as);
+	CleanupStack::PushL(as);
+
+	// Connect to file server
+	RFs fs;
+	err = fs.Connect();
+	__ASSERT_ALWAYS(err == KErrNone, User::Invariant());
+	CleanupClosePushL(fs);
+
+	// Connect to FBS
+	User::LeaveIfError(FbsStartup());
+	User::LeaveIfError(RFbsSession::Connect());
+
+	// Create monitor object
+	CStressTestMonitor* monitor = new (ELeave) CStressTestMonitor;
+	CleanupStack::PushL(monitor);
+
+	CDir* dir = NULL;
+	fs.GetDir(KNullDesC,0,0,dir);
+	CleanupStack::PushL(dir);
+	TInt entries = dir->Count();
+
+	TDisplayMode displayMode;
+	if(aThread->iId==CMdaStressTest::ELoadImages1)
+		displayMode = EColor256;
+	else
+		displayMode = EGray4;
+
+	entries--;
+	while(entries>=0)
+		{
+		const TEntry& entry = (*dir)[entries];
+		TFileName fileName;
+		User::LeaveIfError(fs.DefaultPath(fileName));
+		fileName.Append(entry.iName);
+		CImageLoadUtil::NewL(*monitor,fileName,displayMode);
+		entries -= 2;	// only load every other image to keep memory usage down
+		}
+	CleanupStack::PopAndDestroy();	// dir
+
+	// Run active objects
+	CActiveScheduler::Start();
+
+	// Check for errors
+	User::LeaveIfError(monitor->Error());
+
+	// Close everything
+	CleanupStack::PopAndDestroy(); // monitor
+	RFbsSession::Disconnect();
+	CleanupStack::PopAndDestroy(2); // fs and as
+	}
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+GLDEF_C TInt TestLoadImages(TAny* aParam)
+	{
+	CTrapCleanup* tc = CTrapCleanup::New();
+	__ASSERT_ALWAYS(tc,User::Invariant());	
+
+	TRAPD(err,DoTestLoadImagesL(REINTERPRET_CAST(CMdaStressTestThread*,aParam)));
+
+	delete tc;
+	return err;
+	}
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+CMdaStressTest::CMdaStressTest()
+	: CMdaCoreTest(), iThreadList(_FOFF(CMdaStressTestThread,iLink)), iThreadIter(iThreadList), iRandomSeed(1)
+	{
+	}
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+CMdaStressTest::~CMdaStressTest()
+	{
+	// Delete all threads
+	CMdaStressTestThread* thread;
+	iThreadIter.SetToFirst();
+	while ((thread=iThreadIter++)!=NULL)
+		DeleteTestThread(thread);
+	}
+/*********************************************************************************************/
+
+
+
+const TInt KThreadScanDelay = 200000;
+
+/*********************************************************************************************/
+void CMdaStressTest::DoTestL()
+	{
+	TInt error = KErrNone;
+	TInt time = 10000000;
+	TInt testNumber;
+	CMdaStressTestThread* thread;
+
+	// Launch test threads
+	for(testNumber=0; testNumber<ENumTestThreads; testNumber++)
+		StartTestThreadL(STATIC_CAST(TTestThreadId,testNumber));
+
+	// Scan thread list
+	do
+		{
+		TInt numThreads = 0;
+
+		iThreadIter.SetToFirst();
+		while ((thread=iThreadIter++)!=NULL)
+			{
+			if(thread->iThread.ExitType()==EExitPending)
+				numThreads++;
+			else
+				{
+				TInt reason = thread->iThread.ExitReason();
+				if(reason!=KErrNone)
+					{
+					iEngine->TestFailed(reason);
+					error = reason;
+					break;
+					}
+				testNumber = thread->iId;
+				DeleteTestThread(thread);
+				StartTestThreadL(STATIC_CAST(TTestThreadId,testNumber));	// Restart test
+				}
+			}
+
+		if(error)
+			break;
+
+		User::After(KThreadScanDelay);
+		time -= KThreadScanDelay;
+		}
+	while(time>0);
+
+//	iEngine->Print(_L("Waiting for test threads to end..."));
+
+	// Wait for all threads to finish
+	while(!iThreadList.IsEmpty())
+		{
+		User::After(KThreadScanDelay);
+		// Delete all completed threads
+		iThreadIter.SetToFirst();
+		while ((thread=iThreadIter++)!=NULL)
+			if(thread->iThread.ExitType()!=EExitPending)
+				{
+				TInt reason = thread->iThread.ExitReason();
+				if(reason!=KErrNone)
+					iEngine->TestFailed(reason);
+				DeleteTestThread(thread);
+				}
+		}
+
+
+	}
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+void CMdaStressTest::StartTestThreadL(TTestThreadId aId)
+	{
+	TThreadFunction function;
+
+	switch(aId)
+		{
+		case ELoadImages1:
+		case ELoadImages2:
+			function = TestLoadImages;
+			break;
+		default:
+			return;
+		}
+
+	TBuf<40> name;
+	name.Append(_L("CMdaStressTestThread #"));
+	name.AppendNum(aId,EDecimal);
+	name.Append(_L("-"));
+	name.AppendNum(iThreadNameCount++,EDecimal);
+
+	CMdaStressTestThread* thread = new (ELeave) CMdaStressTestThread;
+	CleanupStack::PushL(thread);
+
+	thread->iId = aId;
+	User::LeaveIfError(thread->iThread.Create(name, function, KDefaultStackSize, 1024, 2048*1024, thread));
+
+	CleanupStack::Pop();
+
+	iThreadList.AddLast(*thread);
+	thread->iThread.Resume();
+	}
+/*********************************************************************************************/
+
+
+
+/*********************************************************************************************/
+void CMdaStressTest::DeleteTestThread(CMdaStressTestThread* thread)
+	{
+	if(thread->iThread.ExitType()==EExitPending)
+		thread->iThread.Terminate(KErrNone);
+	thread->iThread.Close();
+	iThreadList.Remove(*thread);
+	delete thread;
+	}
+/*********************************************************************************************/