diff -r 000000000000 -r bde4ae8d615e os/graphics/graphicstest/graphicstestharness/inc/extendtef.h
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/os/graphics/graphicstest/graphicstestharness/inc/extendtef.h	Fri Jun 15 03:10:57 2012 +0200
@@ -0,0 +1,413 @@
+// Copyright (c) 2006-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:
+// These macros and templates extend the tef testsuite support.
+// 
+//
+
+/**
+ @file
+ @test
+ @internalComponent - Internal Symbian test code
+*/
+
+#ifndef __EXTENDTEF_H__
+#define __EXTENDTEF_H__
+
+#include <test/tefunit.h>
+
+// Adds a test suite that is not called CreateSuiteL so that one class can describe multiple subsets of tests.
+#define ADD_TEST_SUITE_SUB(subname) \
+	_LIT( KTest ## subname, #subname); \
+	lTestSuite->AddL( CreateSuiteSub##subname##L( KTest##subname));
+
+// Calls a subfunction to add more members to the current test suite at the current level. Can be the same function as used to create nested tests.
+#define ADD_TEST_SUITE_SUB_FLAT(subname) \
+	_LIT( KTest ## subname, #subname); \
+	CreateSuiteSub##subname##L( KTest##subname,lTestSuite);
+
+// Allows the class suite to be added with a name different to the class name, so class names can be computational
+#define ADD_TEST_SUITE_MODULE_SUB_AS(module,subname,as) \
+	_LIT( KTest ## as, #as); \
+	lTestSuite->AddL( module::CreateSuiteSub##subname##L( KTest##as));
+
+/** Use in a subsuite to distinguish between ADD_TEST_SUITE_SUB and ADD_TEST_SUITE_SUB_FLAT caller
+ *	ClassName is required - it defines the name of the class containing the referenced methods. 
+ *	aTestSuite is optional - it should be the function parameter aTestSuite or the keyword NULL 
+ **/
+#define SUB_SUITE_OPT(ClassName,aTestSuite) \
+	CTestSuite* lTestSuite = aTestSuite? (CTestSuite*)aTestSuite: CTestSuite::NewL(aName); \
+	typedef ClassName	ThisThis;
+
+// Create a dotted name subtest in the script that represents a parameter to the named test
+// This should be called from a ADD_TEST_SUITE_SUB with the same name as the test method,
+// so that entries can be inserted of the form CMyTestClass.MyTest.EColor256
+#define ADD_TEST_STEP_PARAM_1(method,param)	\
+	_LIT( KTest ## method ## param, #param); \
+	AddTestCaseParam(lTestSuite, KTest ## method ## param, method, param);
+
+// Insert a test that takes a parameter and a range of dotted subtests that set that parameter
+// This allows tests of the form CMyTestClass.MyLoopTest.8
+#define ADD_TEST_STEP_PARAM_RANGE(method,minparam,maxparam)	\
+	_LIT(KTest ## method,#method); \
+	AddTestCaseParamRangeL(lTestSuite,KTest ## method,&ThisThis::method,minparam,maxparam);
+
+// Insert a test that takes a parameter and a range of dotted subtests that set that parameter
+// This allows tests of the form CMyTestClass.MyLoopTest.8
+#define ADD_TEST_STEP_PARAM_RANGE_STEP(method,minparam,maxparam,step)		 \
+	_LIT( KTest ## method , #method); \
+	AddTestCaseParamRangeL(lTestSuite, KTest ## method, &ThisThis::method, minparam,maxparam,step);
+
+// Insert a test that takes a boolean parameter and a range of dotted subtests that set that parameter 
+// Names for dotted tests include "true", "yes", "on", "1"
+// This allows tests of the form CMyTestClass.EnableFeature.on
+#define ADD_TEST_STEP_PARAM_BOOL(method)	\
+	_LIT(KTest ## method,#method); \
+	AddTestCaseParamBoolL(lTestSuite,KTest ## method,&ThisThis::method);
+
+// Insert a test that that just requires calling a function
+#define ADD_WSGCE_TEST_STEP(classname,method) \
+	_LIT(KTest ## method,#method); \
+	AddTestCase(lTestSuite,KTest ## method,&classname::method);
+
+// Insert an asyncronus test that that just requires calling a function
+#define ADD_WSGCE_ASYNC_TEST_STEP(classname,method) \
+	_LIT(KTest ## method,#method); \
+	AddAsyncTestCase(lTestSuite,KTest ## method,&classname::method);
+
+// Insert a test that that just requires calling a function
+#define ADD_THIS_TEST_STEP(method) \
+	_LIT(KTest ## method,#method); \
+	AddTestCase(lTestSuite,KTest ## method,&ThisThis::method);
+
+// Insert an asyncronus test that that just requires calling a function
+#define ADD_THIS_ASYNC_TEST_STEP(method) \
+	_LIT(KTest ## method,#method); \
+	AddAsyncTestCase(lTestSuite,KTest ## method,&ThisThis::method);
+
+/*********************************************************************************
+ * Base class for derived doers that use the Setup/Shutdown
+ *********************************************************************************/
+template <class Fixture>
+class CTestCaseDoTemplate : public CTestCase
+	{
+private:
+	
+public:
+	CTestCaseDoTemplate(const TDesC &aName);
+	virtual ~CTestCaseDoTemplate();
+
+	virtual void RunL(CTestConfig& aConfig, CTestExecuteLogger& aLogger);
+	virtual void DoRunL(Fixture*aFixture)=0;
+
+protected:
+	};
+
+/*********************************************************************************
+ * Derived dorun to run a test with a parameter
+ *********************************************************************************/
+template <class Fixture,class Param>
+class CTestCaseParamTemplate : public CTestCaseDoTemplate<Fixture>
+	{
+private:
+	typedef void (Fixture::*TestMethod)(Param aParam);
+	
+public:
+	CTestCaseParamTemplate(const TDesC &aName, TestMethod aTestMethod, Param aParam)
+	:	CTestCaseDoTemplate<Fixture>(aName),
+		iTest(aTestMethod),iParam(aParam)
+	{}
+	virtual void DoRunL(Fixture*aFixture)
+		{
+		(aFixture->*iTest)(iParam);
+		}
+
+protected:
+	TestMethod	iTest;
+	Param iParam;
+	};
+
+/***************************************
+ * 
+ * Implementation of template <class Fixture,class Param> class CTestCaseTemplate
+ *
+ ***************************************/
+template <class Fixture>
+CTestCaseDoTemplate<Fixture>::CTestCaseDoTemplate(const TDesC &aName)
+: CTestCase(aName)
+	{
+	}
+template <class Fixture>
+CTestCaseDoTemplate<Fixture>::~CTestCaseDoTemplate()
+	{
+	}
+template <class Fixture>
+void CTestCaseDoTemplate<Fixture>::RunL(CTestConfig& aConfig, CTestExecuteLogger& aLogger)
+/**
+ * Creates and destroys the test fixture, but runs the DoRunL in the derived class, which in turn runs the test. 
+ *
+ * @param aConfig - Test configuration
+ * @param aLogger - Test logger
+ */
+	{
+	Fixture* iFixture = new (ELeave) Fixture();
+	CleanupStack::PushL(iFixture);
+	
+	// Must set the Logger and Config now
+	iFixture->SetLoggerL( aLogger );
+	iFixture->SetConfigL( aConfig );
+	
+	// Setup code
+	iFixture->SetupL();
+	
+	// Run the test
+	TRAPD( err, DoRunL(iFixture) );
+
+	// Log the result
+	CTEFLogger::LogResult( iName, err, aLogger );
+
+	// Now the test case has been logged we need to leave
+	// again if that is what the test did
+	if( err != KErrTEFUnitPass )
+		{
+		User::Leave(err);
+		}
+
+	// Teardown code
+	iFixture->TearDownL();
+
+	CleanupStack::PopAndDestroy();
+	}
+/**
+ * Support method to add a test that takes a specific value as its parameter.
+ * Can be used from ADD_TEST_STEP_PARAM_1, or from the methods below
+ **/
+template <class Param,class Fixture>
+inline void AddTestCaseParam(CTestSuite* aTestSuite, const TDesC& aName, void (Fixture::*aTestMethod)(Param aParam),Param aParam)
+	{
+	CTestCaseParamTemplate<Fixture,Param> *testCaseTemplate = new (ELeave) CTestCaseParamTemplate<Fixture,Param>(aName, aTestMethod,aParam);
+	CleanupStack::PushL(testCaseTemplate);
+	aTestSuite->AddL( testCaseTemplate );
+	CleanupStack::Pop(testCaseTemplate);
+	}
+/**
+ * Adds a test with a range of parameter values. Usually launched from ADD_TEST_STEP_PARAM_RANGE
+ * 
+ **/
+template <class Param,class Fixture>
+inline void AddTestCaseParamRangeL(CTestSuite* aTestSuite, const TDesC& aName, void (Fixture::*aTestMethod)(Param aParam),TInt aParamMin,TInt aParamMax,TInt aDelta=1)
+	{
+	CTestSuite* lTestSuite = CTestSuite::NewL(aName);
+	CleanupStack::PushL(lTestSuite);
+	__ASSERT_ALWAYS(aDelta!=0 && aParamMin!=aParamMax,User::Invariant());
+	__ASSERT_ALWAYS((aDelta>0) == (aParamMax>aParamMin),User::Invariant());
+	for (TInt count=aParamMin;count!=aParamMax;count+=aDelta)
+		{
+		TBuf<10> name2;
+		name2.AppendNum(count);
+		CTestCaseParamTemplate<Fixture,Param> *testCaseTemplate = new (ELeave) CTestCaseParamTemplate<Fixture,Param>(name2, aTestMethod,Param(count));
+		CleanupStack::PushL(testCaseTemplate);
+		lTestSuite->AddL( testCaseTemplate );
+		CleanupStack::Pop(testCaseTemplate);
+		}
+	aTestSuite->AddL(lTestSuite);
+	CleanupStack::Pop(lTestSuite);
+	}
+
+/**
+ * Adds a test with a range of parameter values. Usually launched from ADD_TEST_STEP_PARAM_BOOL
+ * 
+ **/
+template <class Param,class Fixture>
+inline void AddTestCaseParamBoolL(CTestSuite* aTestSuite, const TDesC& aName, void (Fixture::*aTestMethod)(Param aParam))
+	{
+	class CTestSuiteBool: public CTestSuite
+		{
+		public:
+		static CTestSuite* NewL(const TTestName& aName)
+			{
+			CTestSuite* lTestSuite = new (ELeave) CTestSuiteBool(aName);
+			CleanupStack::PushL(lTestSuite);
+			lTestSuite->ConstructL();
+			CleanupStack::Pop();
+			return lTestSuite;
+			}
+		protected:
+		CTestSuiteBool(const TTestName& aName):	CTestSuite(aName)
+			{	}
+		virtual void RunL(CTestConfig& aConfig, CTestExecuteLogger& aLogger)
+			{	//run "all the tests"
+			// Log that the runner is currently in this suite
+			CTEFLogger::LogTraverse( iName, aLogger );
+			TInt lError=KErrNone;
+			for(TInt lIndex = 0; lIndex < Count() && lIndex<2; lIndex++)
+				{
+				TRAPD(err,TestL(lIndex)->RunL(aConfig, aLogger));
+				if(err != KErrTEFUnitPass)
+					{
+					lError=err;
+					}
+				}
+			if(lError != KErrTEFUnitPass)
+				{
+				User::Leave(lError);
+				}
+			}
+		
+		};
+	typedef Fixture	ThisThis;
+	CTestSuite* lTestSuite = CTestSuiteBool::NewL(aName);
+	CleanupStack::PushL(lTestSuite);
+#define yes 1
+#define true 1
+#define on 1
+#define off 0
+#define no 0
+#define false 0
+	
+#define Yes 1
+#define True 1
+#define On 1
+#define Off 0
+#define No 0
+#define False 0
+	
+#define YES 1
+#define ON 1
+#define OFF 0
+#define NO 0
+
+
+#define ETrue 1
+#define EFalse 0
+	//The first two MUST be a true and a false so running "all" will run them both
+	ADD_TEST_STEP_PARAM_1(aTestMethod,ETrue);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,EFalse);
+
+	ADD_TEST_STEP_PARAM_1(aTestMethod,1);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,0);
+	
+	ADD_TEST_STEP_PARAM_1(aTestMethod,yes);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,true);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,on);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,no);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,false);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,off);
+
+	ADD_TEST_STEP_PARAM_1(aTestMethod,Yes);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,True);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,On);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,No);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,False);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,Off);
+
+	ADD_TEST_STEP_PARAM_1(aTestMethod,YES);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,TRUE);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,ON);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,NO);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,FALSE);
+	ADD_TEST_STEP_PARAM_1(aTestMethod,OFF);
+
+#undef yes 
+#undef true
+#undef on 
+#undef off
+#undef no 
+#undef false
+
+#undef Yes
+#undef True
+#undef On
+#undef Off
+#undef No
+#undef False
+	
+#undef YES
+#undef ON
+#undef OFF
+#undef NO
+
+
+#undef ETrue
+#undef EFalse
+
+	aTestSuite->AddL(lTestSuite);
+	CleanupStack::Pop(lTestSuite);
+	}
+
+void TefUnitFailLeaveL();
+	
+#undef 	__ASSERT_SHARED
+#define __MAKE_L_STRING(S)	L##S
+/**
+ * Redefining this macro allows the condition text of the assert to be logged when the fail is reported as well as the file and line number
+ * This allows simple issues to be diagnosed without resorting to the source.
+ **/
+#define __ASSERT_SHARED(aFunction, aMessage) \
+	if(!aFunction) \
+		{ \
+		struct Log	\
+			{	/*This wrapper is provided purely to hide the temp string from the debugger.*/ \
+			static const TLitC<sizeof("ASSERT FAILED: " #aFunction)>&	Str()\
+				{\
+				_LIT(aMessage, "ASSERT FAILED: " __MAKE_L_STRING(#aFunction) ); \
+				return aMessage;\
+				}\
+			};\
+		Logger().LogExtra(((TText8*)__FILE__), __LINE__, ESevrAll, Log::Str() );\
+		TefUnitFailLeaveL();\
+		}
+#define ASSERT_NOT_EQUALS(aExpected, aActual) \
+	__ASSERT_SHARED(!AssertEquals(aExpected, aActual) , KAssertFailedEquals);
+
+template <class Pointer>
+inline TBool AssertTrue(Pointer* aCondition)
+	{
+	return AssertTrue((TBool)aCondition);
+	}
+
+
+#define LOG_AND_RETURN_IF_GOT_GCE										\
+		{																\
+		if (GCEIsSupported())											\
+			{															\
+			INFO_PRINTF1(_L("Test skipped: GCE support is loaded"));	\
+			User::Panic(_L("GCE.Wrong.Mode"),1);						\
+			return;														\
+			}															\
+		}
+		
+#define LOG_AND_PANIC_IF_NOT_GCE											\
+		{																	\
+		if (!GCEIsSupported())												\
+			{																\
+			INFO_PRINTF1(_L("Test skipped: GCE support is not loaded"));	\
+			User::Panic(_L("GCE.Wrong.Mode"),1);							\
+			return;															\
+			}																\
+		}
+
+
+#define _LIT2(NAME,STRING)											\
+    class NAME														\
+    	{															\
+    public:															\
+    	static const TLitC<sizeof(L##STRING)/2>& S()			\
+    		{														\
+    		_LIT(singleton,STRING);								\
+    		return singleton;										\
+    		}														\
+    	}	;
+
+
+#endif	//__EXTENDTEF_H__