// Copyright (c) 2007-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:

// Surface manager multi-threaded test code

// 

//

/**

 @file

 @test

 @internalComponent - Internal Symbian test code

*/

#include "tsurfacemanagermultithread.h"

#include <e32base.h>

#include <e32cons.h>

#include <e32test.h>

#include <e32std.h>

#include <e32cmn.h>

#include <e32def.h>	  

static TSurfaceId globalSurfaceId;	

static TInt testResult;

typedef CTSurfaceManagerMultiThread::TInfo TInfo;

CTSurfaceManagerMultiThread::CTSurfaceManagerMultiThread(CTestStep* aStep):

	CTGraphicsBase(aStep)

	{

	}

CTSurfaceManagerMultiThread::~CTSurfaceManagerMultiThread()

	{

	iSurfaceManager.Close();

	}

void CTSurfaceManagerMultiThread::RunTestCaseL(TInt aCurTestCase)

	{

	TInt procHandles1  =0;

	TInt threadHandles1=0;

	RThread().HandleCount(procHandles1, threadHandles1);

	((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(KUnknownSYMTestCaseIDName);

	switch(aCurTestCase)

		{

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0078

@SYMPREQ				PREQ1879, PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test accessing surface in another thread without opening it

						Thread 1: Create Surface 

						Thread 2: Map Surface - KErrNone (still accessible)

						Thread 2: SurfaceInfo - KErrNone (still accessible)

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),MapSurface(), SurfaceInfo()

@SYMTestExpectedResults The surface can be successfully accessed in other threads without first opening it.

*/

	case 1:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0078"));

		TestAccessSurfaceWithoutOpeningL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0079

@SYMPREQ				PREQ1879, PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test accessing a surface created in the existing shared chunk in another thread without opening it.

						Thread 1: Create a Surface in the new chunk with valid creation attributes

						Thread 1: Map the surface in the current process to get the chunk handle

						Thread 1: Create a new surface in the existing chunk with valid creation attributes

						Thread 2: Map the second Surface – KErrNone (still accessible)

						Thread 2: SurfaceInfo – KErrNone (still accessible)

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),MapSurface(), SurfaceInfo()

@SYMTestExpectedResults MapSurface, SurfaceInfo return KerrNone

*/	

	case 2:

        ((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0079"));

		TestAccessSurfaceInExistingSharedChunkL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0080

@SYMPREQ				PREQ1879, PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test closing surface in another thread without opening it

						Thread 1: Create Surface 

						Thread 2: Close Surface - KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface()

@SYMTestExpectedResults The surface can be successfully closed in other threads without first opening it.

*/

	case 3:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0080"));

		TestCloseSurfaceWithoutOpeningL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0081

@SYMPREQ				PREQ1879, PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test accessing an surface which is created in another thread but closed in current thread 

						Thread 2: Create Surface

						Thread 1: Close Surface - KerrNone

						Thread 2: Map Surface - KErrArgument

						Thread 2: SurfaceInfo - KErrArgument

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo()

@SYMTestExpectedResults The surface cant be accessd even after it is closed in other threads.

*/

	case 4:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0081"));

		TestAccessSurfaceClosedThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0067

@SYMPREQ				PREQ1879, PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test closing surface created in the existing chunk in another thread without opening it 

						Thread 1: Create a Surface in a new shared chunk with valid attributes

						Thread 1: Map the surface in the process to get the shared chunk handle

						Thread 1: Create a new surface in the existing shared chunk

						Thread 2: Close the second surface – KErrNone (the second surface is deleted)

						Thread 2: Call SurfaceInfo to the first surface and it returns KErrNone, but it returns KErrArgument to the second surface.

						Thread 2: Close the first surface and check it returns KErrNone (the first surface is deleted).

						Thread 1: Call SurfaceInfo to both surfaces and return KErrArgument

						Thread 1: Check the chunk is still accessible by calling RChunk::Base() 

						Thread 1: Close the chunk handle  

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface()

@SYMTestExpectedResults CloseSurface returns KErrNone. The chunk handle is not closed even when both surfaces are deleted.

*/		

	case 5:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0067"));

		TestCloseSurfaceExistingSharedChunkL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0068

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test closing an surface which is already closed in other thread return KErrArgument 

						Thread 2: Create Surface

						Thread 1: Close Surface - KerrNone

						Thread 2: Close Surface - KErrArgument

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface()

@SYMTestExpectedResults The surface cant be closed again.

*/

	case 6:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0068"));

		TestCloseSurfaceClosedThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0069

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test accessing an surface which is already opened and closed in another thread, given that the process still owns the surface 

						Thread 1: Create Surface

						Thread 2: Open Surface -- KErrNone

						Thread 2: Close Surface -- KErrNone

						Thread 1: Map Surface - KErrNone

						Thread 1: SurfaceInfo - KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo, OpenSurface()

@SYMTestExpectedResults The surface is still accessible in the thread residing the owning process

*/

	case 7:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0069"));

		TestAccessSurfaceOpenedClosedThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0070

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test closing an surface which is already opened and closed in another thread, given that the process still owns the surface

    					Thread 1: Create Surface

						Thread 2: Open Surface

						Thread 2: Close Surface

						Thread 1: Close Surface - KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), OpenSurface()

@SYMTestExpectedResults The surface is still closible in the thread residing in the owning process

*/

	case 8:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0070"));

		TestCloseSurfaceOpenedClosedThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0071

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test accessing surface in another thread when the opening thread is killed   

						Thread 1: Create Surface 

						Thread 2: Open Surface

						Thread 2: Kill the thread

						Thread 1: Map Surface - KErrNone

						Thread 1: Surface Info -- KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo(), OpenSurface()

@SYMTestExpectedResults The surface is accessible when the opening thread is killed

*/

	case 9:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0071"));

		TestAccessSurfaceOpenedKilledThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0072

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test closing surface in another thread when the opening thread is killed   

						Thread 1: Create Surface 

						Thread 2: Open Surface

						Thread 2: Kill the thread

						Thread 1: Close Surface - KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), OpenSurface()

@SYMTestExpectedResults The surface is closible when the opening thread is killed

*/

	case 10:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0072"));

		TestCloseSurfaceOpenedKilledThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0073

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test accessing surface in another thread when the creating thread is killed and it is closed in other threads

						Thread 2: Create Surface

						Thread 1: Close Surface

						Thread 2: Kill Thread

						Thread 1: Map Surface - KErrArgument

						Thread 1: Surface Info - KErrArgument

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo(),

@SYMTestExpectedResults The surface is accessible when the creating thread is killed and it is closed in other threads

*/

	case 11:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0073"));

		TestAccessSurfaceCreateKilledThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0074

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test accessing surface in another thread when the creating thread is killed and it is closed in other threads

						Thread 2: Create Surface

						Thread 1: Close Surface

						Thread 2: Kill Thread

						Thread 1: Close Surface - KErrArgument

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface()

@SYMTestExpectedResults The surface is accessible when the creating thread is killed and it is closed in other threads

*/

	case 12:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0074"));

		TestCloseSurfaceCreateKilledThreadL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0075

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test closing on one thread doesn't prevent opening on other Threads, provided one Thread still owns surface

    					Thread 1: Create Surface

						Thread 2: Open Surface

						Thread 2: Close Surface

						Thread 3: Open Surface - KerrNone

						Thread 3: Map Surface - KerrNone

						Thread 3: SurfaceInfo -- KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo(),

@SYMTestExpectedResults It is expected that closing on one thread doesn't prevent opening on other Threads, provided one Thread still owns surface

*/

	case 13:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0075"));

		TestAccessSurfaceThreeThreadsL();

		break;	

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0076

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test surface can be accessed from third thread when creating thread dies and second thread closes

    					Thread 2: Create Surface

						Thread 1: Open Surface

						Thread 3: Open Surface

						Thread 1: Close Surface

						Thread 2: Kill Thread

 					 	Thread 3: Close Surface

						Thread 3: Map Surface - KerrNone

						Thread 3: SurfaceInfo -- KErrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), MapSurface(), SurfaceInfo(), OpenSurface()

@SYMTestExpectedResults It is expected that surface can be accessed from third thread when creating thread dies and second thread closes

*/

	case 14:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0076"));

		TestAccessSurfaceDieCloseOtherThreadsL();

		break;

/**

@SYMTestCaseID			GRAPHICS-SURFACEMANAGER-0077

@SYMPREQ				PREQ1007

@SYMREQ					REQ8222,REQ8223

@SYMTestPriority		High 

@SYMTestCaseDesc		Test that the surface can be opened from the third Thread after creating thread dies and second and third thread close the surface

   						Thread 2: Create Surface

						Thread 1: Open Surface

						Thread 3: Open Surface

						Thread 1: Close Surface

						Thread 2: Kill Thread

 					    Thread 3: Close Surface

						Thread 3: Open Surface - KerrNone

@SYMTestStatus			Implemented

@SYMTestActions			Call CreateSurface(),CloseSurface(), OpenSurface()

@SYMTestExpectedResults It is expected that the surface can be opened from the third Thread after creating thread dies and second and third thread close the surface

*/

	case 15:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(_L("GRAPHICS-SURFACEMANAGER-0077"));

		TestOpenSurfaceDieCloseOtherThreadsL();

		break;

	default:

		((CTSurfaceManagerMultiThreadStep*)iStep)->SetTestStepID(KNotATestSYMTestCaseIDName);

		((CTSurfaceManagerMultiThreadStep*)iStep)->CloseTMSGraphicsStep();

		TestComplete();

		break;

		}

	((CTSurfaceManagerMultiThreadStep*)iStep)->RecordTestResultL();

	// Handle check

	TInt procHandles2  =0;

	TInt threadHandles2=0;

	RThread().HandleCount(procHandles2,threadHandles2);

	if (threadHandles1 != threadHandles2)

		{

		User::Leave(KErrGeneral);  // Thread-owned handles not closed

		}

 	}

void CTSurfaceManagerMultiThread::CloseSurfaceWhenLeave(TAny* aInfo) 

	{

	TInt err1 = ((TInfo*)aInfo)->iSurfaceManager.CloseSurface(((TInfo*)aInfo)->iSurfaceId);

	TInt err2 = ((TInfo*)aInfo)->iSurfaceManager.CloseSurface(((TInfo*)aInfo)->iSurfaceIdNew);

	if (err1!=KErrNone || err2!=KErrNone)

	   	RDebug::Print(_L("Error closing surfaces err1= %d, err2= %d\n"),err1,err2);	

	}

void CTSurfaceManagerMultiThread::TestAccessSurfaceWithoutOpeningL()

	{

	User::LeaveIfError(iSurfaceManager.Open());

	// Setup attributes

    RSurfaceManager::TSurfaceCreationAttributesBuf buf;

	RSurfaceManager::TSurfaceCreationAttributes& attributes = buf();

	attributes.iSize = TSize(480,16);

	attributes.iBuffers = 2;				// number of buffers in the surface

	attributes.iPixelFormat = EUidPixelFormatYUV_422Reversed;		// 2bpp

	attributes.iStride = 1013;				// Number of bytes between start of one line and start of next

	attributes.iOffsetToFirstBuffer = 0;	// way of reserving space before the surface pixel data

	attributes.iAlignment = RSurfaceManager::EPageAligned;			// alignment, 1,2,4,8,16,32,64 byte aligned or EPageAligned

	RSurfaceManager::THintPair hints[2];	// two hint pairs specified

	attributes.iHintCount = 2;

	attributes.iSurfaceHints = hints;

	hints[0].Set(TUid::Uid(0x124578), 25, ETrue);

	hints[1].Set(TUid::Uid(0x237755), 50, ETrue);

	attributes.iContiguous = ETrue;

	attributes.iCacheAttrib = RSurfaceManager::ECached;

	attributes.iMappable = ETrue;

	// Test create surface doesn't return an error

	TEST(KErrNone == iSurfaceManager.CreateSurface(buf, iSurfaceId));

    // Logging info   

    INFO_PRINTF1(_L("Test accessing surface in another thread without opening it\r\n"));

    // Create a semaphore

	RSemaphore sem;

	TEST(KErrNone == sem.CreateGlobal(KMultiThreadSemaphore, 0));

	CleanupClosePushL(sem);	

	// Create a second thread in the current process and opens the handle

	iInfo.iSurfaceManager = iSurfaceManager;

	iInfo.iSurfaceId = iSurfaceId;

	iInfo.iSurfaceIdNew = TSurfaceId::CreateNullId();

	iInfo.iThreadTestCase = EMapSurfaceInfo;		

	// Create a TCleanupItem object

    CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo));

    RThread thread1;

    _LIT(KNameThreadSecond1, "Test_SurfaceManager_ThreadSecond1");

	User::LeaveIfError(thread1.Create(KNameThreadSecond1,ThreadSecondStart, KDefaultStackSize, &User::Heap(), &iInfo));

   	CleanupStack::Pop();

    // Launch second thread

	TRequestStatus statusThreadSecond;

	thread1.Logon(statusThreadSecond);

	thread1.SetPriority(EPriorityLess);

	thread1.Resume();	

	testResult = EAllZero;

	// Passes control to the second process

	sem.Wait();

	thread1.Suspend();

	// Test results in second thread

	TEST (testResult = (EMapSurfaceTestPassed | ESurfaceInfoTestPassed));

	// Pass control off to the second process again

	thread1.Resume();

	// Wait for a second for the second thread to terminate

	User::WaitForRequest(statusThreadSecond);

	//Close the handles

    CleanupStack::PopAndDestroy(1, &sem);  //invoke surface manager to close the surface also close the handle to RSemaphore

    thread1.Close();

    iSurfaceManager.Close();

	}

void CTSurfaceManagerMultiThread::TestAccessSurfaceInExistingSharedChunkL()

    {

    // Logging info   

    INFO_PRINTF1(_L("Test accessing a surface created in the existing shared chunk in another thread without opening it\r\n"));

    User::LeaveIfError(iSurfaceManager.Open());

    // Setup attributes 

    RSurfaceManager::TSurfaceCreationAttributesBuf buf;

    RSurfaceManager::TSurfaceCreationAttributes& attributes = buf();

    attributes.iSize = TSize(100,100);

    attributes.iBuffers = 1;                // number of buffers in the surface

    attributes.iPixelFormat = EUidPixelFormatYUV_422SemiPlanar;     // 2bpp

    attributes.iStride = 400;               // Number of bytes between start of one line and start of next

    attributes.iOffsetToFirstBuffer = 0;    // way of reserving space before the surface pixel data

    attributes.iAlignment = 2;          // alignment, 1,2,4,8,16,32,64 byte aligned or EPageAligned

    RSurfaceManager::THintPair hints[2];    // two hint pairs specified

    attributes.iHintCount = 2;

    attributes.iSurfaceHints = hints;

    hints[0].Set(TUid::Uid(0x124578), 25, ETrue);

    hints[1].Set(TUid::Uid(0x237755), 50, ETrue);

    attributes.iContiguous = ETrue;

    attributes.iCacheAttrib = RSurfaceManager::ECached;

    attributes.iOffsetBetweenBuffers = 0;

    attributes.iMappable = ETrue;

    // Test create surface doesn't return an error

    TEST(KErrNone == iSurfaceManager.CreateSurface(buf, iSurfaceId));

    //Map the surface in the current processs

    RChunk handle;

    TEST(KErrNone == iSurfaceManager.MapSurface(iSurfaceId,handle));

    // Cache, Contiguous and Alignment attributes are ignored for the already existing chunks

    RSurfaceManager::TSurfaceCreationAttributesBuf buff;

    RSurfaceManager::TSurfaceCreationAttributes& attributesNew = buff();

    attributesNew.iSize = TSize(480,16);

    attributesNew.iBuffers = 2;             // number of buffers in the surface

    attributesNew.iPixelFormat = EUidPixelFormatYUV_422Reversed;        // 2bpp

    attributesNew.iStride = 1013;               // Number of bytes between start of one line and start of next

    attributesNew.iOffsetToFirstBuffer = 0; // way of reserving space before the surface pixel data

    attributesNew.iHintCount = 1;

    attributesNew.iSurfaceHints = hints;

    hints[0].Set(TUid::Uid(0x124545), 50, EFalse);

    attributesNew.iAlignment = 2;

    attributesNew.iOffsetBetweenBuffers = 0;

    attributes.iMappable = ETrue;

    // Test create surface doesn't return an error

    // For the time being KErrArgument will be returned as the core codes are

    // not ready to check the passed in shared chunk handle.

    TEST(KErrNone == iSurfaceManager.CreateSurface(buff, iSurfaceIdNew, handle));

    // Create a semaphore

    RSemaphore sem;

    TEST(KErrNone == sem.CreateGlobal(KMultiThreadSemaphore, 0));

    CleanupClosePushL(sem); 

    // Create a second thread in the current process and opens the handle

    iInfo.iSurfaceManager = iSurfaceManager;

    iInfo.iSurfaceId = iSurfaceIdNew;

    iInfo.iSurfaceIdNew = iSurfaceId;

    iInfo.iThreadTestCase = EMapSurfaceInfo;    

    // Create a TCleanupItem object

    CleanupStack::PushL(TCleanupItem((TCleanupOperation)CloseSurfaceWhenLeave, &iInfo));

    RThread thread2;

    _LIT(KNameThreadSecond2, "Test_SurfaceManager_ThreadSecond2");

    User::LeaveIfError(thread2.Create(KNameThreadSecond2,ThreadSecondStart, KDefaultStackSize, &User::Heap(), &iInfo));

    CleanupStack::Pop();

    // Launch second thread

    TRequestStatus statusThreadSecond;

    thread2.Logon(statusThreadSecond);

    thread2.SetPriority(EPriorityLess);

    thread2.Resume();   

    testResult = EAllZero;

    // Passes control to the second process

    sem.Wait();

    thread2.Suspend();

    // Test results in second thread

    TEST (testResult = (EMapSurfaceTestPassed | ESurfaceInfoTestPassed));

    // Pass control off to the second process again

    thread2.Resume();