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

//

/**

 @file

 @test

 @internalComponent - Graphics Resource API Conformance Test Suite

*/

#include <e32debug.h>

#include "tgraphicsresourcemultiprocessthread.h"

#include "tgraphicsresourceteststepbase.h"

/**

Helper function to test the equivalence of two TSgImageInfo structures.

@param   aInfo1 A TSgImageInfo structure to compare.

@param   aInfo2 A TSgImageInfo structure to compare.

@return  ETrue if the two are identical, EFalse otherwise.

*/

TBool CompareInfos(TSgImageInfo& aInfo1, TSgImageInfo& aInfo2)

	{

	TBool result = EFalse;

	if(aInfo1.iPixelFormat == aInfo2.iPixelFormat

		&& aInfo1.iSizeInPixels == aInfo2.iSizeInPixels

		&& aInfo1.iUsage == aInfo2.iUsage)

		{

		result = ETrue;

		}

	return result;

	}

/**

Opens an image in a different process.

@param aInfo The test information passed from outside the current thread

@return The test result indicating which tests passed

*/

TInt TestOpenImageL(TSgProcessTestInfo& aInfo)

	{

	TSgDrawableId id = aInfo.iDrawableId;

	TSgImageInfo imageInfo1 = aInfo.iImageInfo;

	RSgImage image;

	TInt result = 0;

	if(KErrNone == image.Open(id))

		{

		result |=  EFirstTestPassed;

		}

	TSgImageInfo imageInfo2;

	TInt attribVal = KMaxTInt;

	if(KErrNone == image.GetInfo(imageInfo2))

		{

		result |= ESecondTestPassed;

		}

	if(CompareInfos(imageInfo1, imageInfo2))

		{

		result |= EThirdTestPassed;

		}

	if (image.Id() != KSgNullDrawableId)

		{

		result |= EFourthTestPassed;

		}

	if(image.Id() == id)

		{

		result |= EFifthTestPassed;

		}

	TUid uid = { 0x12345678 };

	if (KErrNotSupported == image.GetAttribute(uid, attribVal))

	    {

	    result |= ESixthTestPassed;

	    }

	if (KErrArgument == image.GetAttribute(KNullUid, attribVal))

	    {

	    result |= ESeventhTestPassed;

	    }

	image.Close();

	return result;

	}

/**

Opens an image in a different process into a RSgDrawable object.

@param aInfo The test information passed from outside the current thread

@return The test result indicating which tests passed

*/

TInt TestOpenDrawableL(TSgProcessTestInfo& aInfo)

	{

	TSgDrawableId id = aInfo.iDrawableId;

	RSgDrawable drawable;

	TInt result = 0;

	if(KErrNone == drawable.Open(id))

		{

		result |=  EFirstTestPassed;

		}

	TSgDrawableId id2 = drawable.Id();

	if(id2 != KSgNullDrawableId)

		{

		result |= ESecondTestPassed;

		}

	if(id2 == id)

		{

		result |= EThirdTestPassed;

		}

	drawable.Close();

	return result;

	}

/**

Opens an image in a different process with different invalid operations.

@param aInfo The test information passed from outside the current thread

@return The test result indicating which tests passed

*/

TInt TestOpenImageInvalidL(TSgProcessTestInfo& aInfo)

	{	

	TSgDrawableId id = aInfo.iDrawableId;

	TSgImageInfo imageInfo = aInfo.iImageInfo;

	RSgImage image;

	TInt result = 0;

	//create image

	if(KErrNone == image.Create(imageInfo, NULL, 0))

		{

		result |= EFirstTestPassed;

		}

	//  non-empty handle

	if(KErrInUse == image.Open(id))

		{

		result |= ESecondTestPassed;

		}

	image.Close();

	//  null drawable id	

	if(KErrArgument == image.Open(KSgNullDrawableId))

		{

		result |= EThirdTestPassed;

		}

	image.Close();

	//  non-existing drawable id

	TSgDrawableId fakeid = {0xFFFFFFFFFFFFFFFFU};

	if(KErrNotFound == image.Open(fakeid))

		{

		result |= EFourthTestPassed;

		}

	image.Close();

	//Valid Drawable Id

	if (KErrNone == image.Open(id))

		{

		result |= EFifthTestPassed;

		}

	image.Close();

	return result;

	}

/**

Opens a drawable in a different process with different invalid operations.

@param aInfo The test information passed from outside the current thread

@return The test result indicating which tests passed

*/

TInt TestOpenDrawableInvalidL()

	{	

	RSgDrawable  drawable;

	TInt result = 0;

	//null drawable id	

	if(KErrArgument == drawable.Open(KSgNullDrawableId))

		{

		result |= EFirstTestPassed;

		}

	drawable.Close();

	//non-existing drawable id

	TSgDrawableId fakeid = {0xFFFFFFFFFFFFFFFFU};

	if(KErrNotFound == drawable.Open(fakeid))

		{

		result |= ESecondTestPassed;

		}

	drawable.Close();

	//non-empty handle

	//create an image

	TSgImageInfo info1;

	info1.iSizeInPixels = TSize(8, 8);

	info1.iUsage = ESgUsageBitOpenVgImage;

	info1.iPixelFormat = EUidPixelFormatRGB_565;

	RSgImage image;

	TInt err = image.Create(info1, NULL, 0);

	if(KErrNoMemory == err)

		{

		result = KErrNoMemory;

		}

	else if(KErrNone != err)

		{

		result = err;

		}

	else

		{		

		if(KErrNone == drawable.Open(image.Id()))

			{

			result |= EThirdTestPassed;

			if (KErrInUse == drawable.Open(image.Id()))

				{

				result |= EFourthTestPassed;

				}

			}		

		drawable.Close();

		}

	image.Close();

	return result;

	}

TInt TestCloseDriverOpenResources(RSgDriver& aDriver)

	{

	RSgImage image;

	TSgImageInfo info1;

	info1.iSizeInPixels = TSize(8, 8);

	info1.iUsage = ESgUsageBitOpenVgImage;

	info1.iPixelFormat = EUidPixelFormatRGB_565;

	TInt result = image.Create(info1, KCrossImageData, KCrossImageDataStride);

	if (result == KErrNone)

		{

		//Close the driver without closing the image.

		aDriver.Close(); //Should panic with SGRES2

		}

	return result;

	}

/**

Method executed by secondary thread for test TestOpenImageMulththreadedL

*/

_LIT(KTestOpenImageMultithreadedSem1, "TestOpenImageMultithreadedSem1");

_LIT(KTestOpenImageMultithreadedSem2, "TestOpenImageMultithreadedSem2");

TInt OpenImageMultiSecondThread(TAny* aAny)

	{

	TInt err = KErrNone;

	TSgProcessTestInfo* info = static_cast<TSgProcessTestInfo*>(aAny);	

	RSemaphore sem[2];

	err = sem[0].OpenGlobal(KTestOpenImageMultithreadedSem1, EOwnerThread);

	if (err != KErrNone)

		{

		return err;

		}

	err = sem[1].OpenGlobal(KTestOpenImageMultithreadedSem2, EOwnerThread);

	if (err != KErrNone)

		{

		sem[0].Close();

		return err;

		}

	RSgImage sgImage; 

	err = sgImage.Open(info->iDrawableId);

	sem[0].Signal();

	sem[1].Wait();

	sgImage.Close();	

	sem[0].Signal();

	return err;	

	}

/**

Creates a second thread which will initially open a handle to the passed TSgDrawableId.

The main thread then opens a new handle to the image.

The second thread will then close its handle to the image.

The main thread will then attempt to access the data of the image.

 */

TInt TestOpenImageMultithreadedL(TSgProcessTestInfo& aInfo)

	{

	TInt result = 0;

	//create two semaphores

	RSemaphore sem[2];

	User::LeaveIfError(sem[0].CreateGlobal(KTestOpenImageMultithreadedSem1, 0, EOwnerThread));

	CleanupClosePushL(sem[0]);

	User::LeaveIfError(sem[1].CreateGlobal(KTestOpenImageMultithreadedSem2, 0, EOwnerThread));

	CleanupClosePushL(sem[1]);

	//create secondary thread

	_LIT(KSecondaryThreadName, "TestOpenImageMultithreadedL");

	RThread thread;

	User::LeaveIfError(thread.Create(KSecondaryThreadName, OpenImageMultiSecondThread, KDefaultStackSize, KSecondThreadMinHeapSize, KSecondThreadMaxHeapSize, &aInfo));

	thread.Resume();

	// Make the second thread open the image before this thread.

	sem[0].Wait();

	// Second thread has opened image, now primary thread opens image

	RSgImage sgImage;

	TInt err = sgImage.Open(aInfo.iDrawableId);

	CleanupClosePushL(sgImage);

	sem[1].Signal();

	sem[0].Wait();

	// Second thread has closed image and terminated, now wait for thread to clean-up

	User::After(100000);

	if (err == KErrNone)

		{

		// Do something that requires data access of sgImage, in this case, creating a copy.

		result |= EFirstTestPassed;

		RSgImage sgImageCopy;

		err = sgImageCopy.Create(aInfo.iImageInfo, sgImage);

		sgImageCopy.Close();

		if (err == KErrNone)

			{

			result |= ESecondTestPassed;

			}	

		}

	CleanupStack::PopAndDestroy(3); // sgImage, sem[0], sem[1]		

	return result;	

	}

TInt MainL()

	{				

	TPckgBuf<TSgProcessTestInfo> infoPkg;

	User::LeaveIfError(User::GetDesParameter(KSecondProcessParametersSlot, infoPkg));

	TSgProcessTestInfo& info = infoPkg();

	TSgresTestCase testCase = info.iTestCase;

	TInt result = 0;

	RSgDriver sgDriver;

	CleanupClosePushL(sgDriver);

	if(KErrNone == sgDriver.Open())

		{

		switch(testCase)

			{

			case ESgresSecondProcessOpenImage:

				result = TestOpenImageL(info);

				break;

			case ESgresSecondProcessOpenDrawable:

				result = TestOpenDrawableL(info);

				break;

			case ESgresSecondProcessOpenImageInvalid:

				result = TestOpenImageInvalidL(info);

				break;

			case ESgresSecondProcessOpenDrawableInvalid:

				result = TestOpenDrawableInvalidL();

				break;

			case ESgresSecondProcessPanicDriverCloseOpenResources:

				result = TestCloseDriverOpenResources(sgDriver);

				break;

			case ESgresSecondProcessOpenImageMultithreaded:

				result = TestOpenImageMultithreadedL(info);

				break;

			}

		}	

	CleanupStack::PopAndDestroy(&sgDriver);

	return result;

	}

GLDEF_C TInt E32Main()

	{

	__UHEAP_MARK;

	CTrapCleanup* cleanupStack = CTrapCleanup::New();

	if(cleanupStack == NULL)

		{

		return KErrNoMemory;

		}

	TInt ret = 0;

	TRAP_IGNORE(ret=MainL());

	delete cleanupStack;

	__UHEAP_MARKEND;

	return ret;

	}