Symaptic: os/graphics/windowing/windowserver/test/tauto/openwfc/AUTO.H@bde4ae8d615e

     1 // Copyright (c) 1995-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 // Header for window server auto test code

    15 //

    16 //

    19 #ifndef __AUTO_H__

    20 #define __AUTO_H__

    22 #include <e32std.h>

    23 #include <e32math.h>

    24 #include "../../SERVER/w32cmd.h"

    25 #include <w32std.h>

    26 #include "../tlib/testbase.h"

    27 #include <wsautotest.mbg>

    28 #include "TGraphicsHarness.h"

    29 #include "../../SERVER/openwfc/panics.h"

    31 #define DISABLE_FAIL_DIALOG

    33 #define TEST_BITMAP_NAME _L("Z:\\WSTEST\\WSAUTOTEST.MBM")

    35 #define SCREEN_MODE_TESTING

    37 #define LOG_MESSAGE(p) LogMessage(((TText8*)__FILE__), __LINE__,(p))

    38 #define LOG_MESSAGE2(p1,p2) LogMessage(((TText8*)__FILE__), __LINE__,(p1),(p2))

    39 #define LOG_MESSAGE3(p1,p2,p3) LogMessage(((TText8*)__FILE__), __LINE__,(p1),(p2),(p3))

    40 #define LOG_MESSAGE4(p1,p2,p3,p4) LogMessage(((TText8*)__FILE__), __LINE__,(p1),(p2),(p3),(p4))

    41 #define LOG_MESSAGE5(p1,p2,p3,p4,p5) LogMessage(((TText8*)__FILE__), __LINE__,(p1),(p2),(p3),(p4),(p5))

    42 #define LOG_MESSAGE6(p1,p2,p3,p4,p5,p6) LogMessage(((TText8*)__FILE__), __LINE__,(p1),(p2),(p3),(p4),(p5),(p6))

    43 #define LOG_MESSAGE7(p1,p2,p3,p4,p5,p6,p7) LogMessage(((TText8*)__FILE__), __LINE__,(p1),(p2),(p3),(p4),(p5),(p6),(p7))

    45 // MB 23\11\04 The heap size was only 4k which was causing DSA step 7 to fail on HW.

    46 // Increased heap size to 8k

    47 // 23/02/2009 Again failing with no memory due to COLOR16MAP used.

    48 // Increased heap size to 16k

    49 LOCAL_D const TUint KOtherProcHeapSize=0x4000;

    50 LOCAL_D const TInt KAutoTestPriority=-20;

    52 TBool DoCheckRect(CTBaseWin *aWin1,CTBaseWin *aWin2,const TRect &aRect);

    53 TBool DoCheckRect(CTBaseWin *aWin1,CTBaseWin *aWin2,const TRect &aRect, TUint aFlags);

    54 TBool DoCheckRectRWin(RWindowBase &aWin1,RWindowBase &aWin2,const TRect &aRect);

    55 TBool DoCheckRectRWin(RWindowBase &aWin1,RWindowBase &aWin2,const TRect &aRect, TUint aFlags);

    56 TBool DoCheckRect(CTBaseWin *aWin1,CTBaseWin *aWin2);

    57 TBool DoCheckRect(TPoint aPos1,TPoint aPos2,TSize aSize);

    59 _LIT(KWSERV,"WSERV");

    60 _LIT(KW32,"W32");

    61 _LIT(KPlatsecBegin,"*PlatSec* ERROR - BEGIN NEGATIVE PLATSEC TESTING");

    62 _LIT(KPlatsecEnd,"*PlatSec* ERROR - END NEGATIVE PLATSEC TESTING");

    63 _LIT(KTestFontTypefaceName,"DejaVu Sans Condensed");

    65 class TestClient;

    66 class CMinWin;

    67 class CTWsGraphicsBase;

    69 enum TestState

    70 	{

    71 	EInvalid,

    72 	ENext,

    73 	EWait,

    74 	EFinished

    75 	};

    77 enum TAutoPanics

    78 	{

    79 	EAutoPanicTestFailed,

    80 	EAutoPanicPanicFailed,

    81 	EAutoPanicTestRectsIndex,

    82 	EAutoPanicTestRectsSection,

    83 	EAutoPanicUnexpectedLeave,

    84 	EAutoPanicTestBrushesIndex,

    85 	EAutoPanicWindowType,

    86 	EAutoPanicTooManyDownKeys,

    87 	EAutoPanicInvalidEvent,

    88 	EAutoFadeWindow,

    89 	EAutoPanicWrongTest,

    90 	EAutoPanicAnimError,

    91 	ETManPanicPcFailed,		              //Panic use in a test copied from TMan

    92 	EAutoPanicTestError,	              //Test returned bad return type

    93 	EAutoPanicDirect,		              //Direct Screen Access logic state error

    94 	EAutoPanicScanCapital,	              //Scan codes must not be lower case letters

    95 	EAutoPanicRedrawStoring,              //Inconsistent Redraw Storing Behaviour

    96  	EAutoPanicRecalledCreateTestBaseL,    //Called CreateTestBaseL twice

    97  	EAutoPanicHeartBeatCursorRect,        //Invalid size of rectangle in ChangeTransAndCheckHeartBeat

    98 	EAutoPanicGroupWinHasChild,           //Main test group window has child at start of test

    99   	EAutoPanicPanicSetTrans,              //Error setting transparency during panic tests

   100   	EAutoPanicNoDigitiser,                //Pointer event when the configuration has no digitiser

   101 	};

   103 enum TPanicExitReasons

   104 	{

   105 	EWsExitReasonBad,

   106 	EWsExitReasonFinished,

   107 	};

   109 enum TAutoLeaves

   110 	{

   111 	ETestPassed=0,

   112 	ETestFailed=1,

   113 	};

   115 typedef TInt (*TPanicFunction)(TInt aInt, TAny *aPtr);

   117 struct SPanicParams

   118 	{

   119 	TInt num;

   120 	TPanicFunction func;

   121 	TAny *ptr;

   122 	};

   124 class LogWindow : public CTWin

   125 	{

   126 	enum

   127 		{

   128 		EDummyValue=-9999

   129 		};

   130 public:

   131 	LogWindow();

   132 	void ConstructL(CTWinBase& aParent);

   133 	void Draw();

   134 	void DrawSubTitle();

   135 	void DrawMessage();

   136 	void LogTest(const TDesC &aTitle,TInt aNum);

   137 	const TDesC& LogSubTest(const TDesC &aTitle,TInt aNum);

   138 	const TDesC& LogMessage(TBool aLog,const TDesC& aText,TInt aNum=EDummyValue);

   139 private:

   140 	TBuf<0x40> iTestTitle;

   141 	TBuf<0x40> iSubTitle;

   142 	TBuf<0x40> iMessage;

   143 	TInt iTitleHeight;

   144 	};

   146 class CTestBase;

   148 /**

   149 This class is a window that is used to fake a border around the TestWindow defined below.

   150 It simply draws an opaque black window on top of which the TestWindow will be drawn giving the illusion

   151 there is a border.

   153 @see TestWindow

   154 @internalComponent

   155 @released

   156 */

   157 class CBorderWindow : public CTWin

   158 	{

   159 public:

   160 	CBorderWindow();

   161 	void ConstructL(CTWinBase& aParent);

   162 	void Draw();

   163 	};

   165 class TestWindow : public CTWin

   166 	{

   167 public:

   168 	TestWindow();

   169 	~TestWindow();

   170 	void Draw();

   171 	void SetUpL(TPoint aPos, TSize aSize, CTWinBase* aParent, CWindowGc& aGc);

   172 	void ClearWin();

   173 	void SetBorderExt(TPoint aPos, TSize aSize);

   174 	CBorderWindow* GetBorderWin();

   175 private:

   176 	CBorderWindow* iBorderWin;

   177 	};

   179 /**

   180 This class used to run each individual test before the migration to TEF.

   181 Now it doesn't do much and should probably be refactored.

   183 @internalComponent

   184 @released

   185 */

   186 class CTestDriver : public CBase

   187 	{

   188 public:

   189 	/** Factory function that returns a class derived from CTestDriver */

   190 	static CTestDriver* CreateL(TInt aScreenNumber);

   191 	virtual ~CTestDriver();

   193 protected:

   194 	CTestDriver(TInt aScreenNumber);

   196 public:

   197 	virtual void DoDisplayDialog(TDesC& timeBuf,TDesC& testReport) = 0;

   199 	void TestComplete2();

   200 	void DestroyTest();

   202 	inline TInt ScreenNumber() {return iScreenNumber;}

   203 	inline TInt NumberOfScreens() {return iNumberOfScreens;}

   205 public:

   206 	CTestBase *iTest;

   207 	TInt iSubTestNum;

   208 	static TInt iTestNum;

   209 protected:

   210 	TTime iStartTime;

   211 	TInt iScreenNumber;

   212 	TInt iTestSize;

   213 	TInt iNumberOfScreens;

   214 	};

   216 /** Variant of CTestDriver used when the tests are run on the primary screen.

   218 @internalComponent

   219 @released

   220 */

   221 class CTestDriverPrimary: public CTestDriver

   222 	{

   223 public:

   224 	CTestDriverPrimary(TInt aScreenNumber);

   225 	void DoDisplayDialog(TDesC& timeBuf,TDesC& testReport);

   226 	};

   228 /** Variant of CTestDriver used when the tests are run on a secondary screen.

   230 @internalComponent

   231 @released

   232 */

   233 class CTestDriverSecondary : public CTestDriver

   234 	{

   235 public:

   236 	CTestDriverSecondary(TInt aScreenNumber);

   237 	void DoDisplayDialog(TDesC& timeBuf,TDesC& testReport);

   238 	};

   240 /** List of rectangles use by TGDI.CPP and TRECTLIST.CPP.

   242 Since only 2 tests make use of this shouldn't it be moved outside of the framework?

   244 @internalComponent

   245 @released

   246 */

   247 class TTestRects

   248 	{

   249 private:

   250 	enum TRectListLimits

   251 		{

   252 		EMaxRectFromList=64,

   253 		EMaxRectZeroSize=73,

   254 		EMaxRectWide=83,

   255 		EMaxRectHigh=93

   256 		};

   258 public:

   259 	void Construct(const RWindow &aWindow);

   260 	TInt Count1() const;

   261 	TInt Count2() const;

   262 	TInt Count3() const;

   263 	TRect operator[](TInt aIndex);

   264 	static void ResetSeed();

   265 private:

   266 	TInt Rnd(TInt aSize);

   267 	TInt RndMax(TInt aSize);

   268 	TInt RectCoord(TInt aSection,TInt aSize);

   269 	void RectCoordPair(TInt &aTl, TInt &aBr, TInt aSection, TInt aSize);

   271 private:

   272 	TSize iSize;

   273 	static TRect iList[64];

   274 	static TInt64 iSeed;

   275 	};

   277 /**

   278 @internalComponent

   279 @released

   280 */

   281 class CBitmap : public CBase

   282 	{

   283 public:

   284 	static CBitmap* NewLC(const TSize& aSizeInPixels,TDisplayMode aDispMode);

   285 	static CBitmap* NewL(const TSize& aSizeInPixels,TDisplayMode aDispMode);

   286 	static CBitmap* NewL(TInt aHandle);

   287 	static CBitmap* NewL(TDesC& aFileName);

   288 	~CBitmap();

   289 	inline CFbsBitmap& Bitmap() const {return *iBitmap;}

   290 	inline CFbsBitmapDevice& Device() const {return *iDevice;}

   291 	inline CFbsBitGc& Gc() const {return *iGc;}

   292 private:

   293 	static CBitmap* NewLC(TInt aHandle,const TSize& aSizeInPixels,TDisplayMode aDispMode);

   294 	void ConstructL(TInt aHandle,const TSize& aSizeInPixels,TDisplayMode aDispMode);

   295 private:

   296 	CFbsBitmap* iBitmap;

   297 	CFbsBitmapDevice* iDevice;

   298 	CFbsBitGc* iGc;

   299 	};

   301 /*TPartialRedrawType*/

   302 enum TPartialRedrawType

   303 	{

   304 	//redraw store type is not yet determined.

   305 	EPartialRedraw_Unknown,

   306 	//redraw store is discarded on invalidation and begin-redraw on a smaller rect.

   307 	EPartialRedraw_None,

   308 	// redraw store is preserved on invalidation and begin-redraw on a smaller rect.

   309 	EPartialRedraw_PreserveStoredCmds,

   310 	// redraw store is appended with partial redraw commands, and old redraw store is suitably modified.

   311 	EPartialRedraw_FullRedrawSupport

   312 	};

   314 class CTestBase : public CBase

   315 	{

   316 public:

   317 	enum TPriorites

   318 		{

   319 		EAutoTestPriority=KAutoTestPriority

   320 		};

   321 	enum TTestLevel

   322 		{

   323 		ELevelQuick,		// Quick check on main cases for each function

   324 		ELevelNormal,		// Suitable test level for internal release

   325 		ELevelRelease,		// Thorough test suitable for official releases

   326 		ELevelMega,			// Really OTT, takes forever to run, leave it going over the weekend sort of tests

   327 		};

   328 public:

   329 	CTestBase(const TDesC &aTitle,CTWsGraphicsBase* aTestBase);

   330 	~CTestBase();

   331 	void StartTestL(TInt aNum, CTestDriver* aDriver, TTestLevel aLevel);

   332 	void LogSubTest(const TDesC &aTitle);

   333 	void LogMessage(TInt aValue);

   334 	void LogSubState(TInt aSubState);

   335 	TInt LaunchPanicThread(RThread &aThread, SPanicParams *aPtr);

   336 	TInt TestPanicL(SPanicParams *aPtr, TInt aExitReason, const TDesC &aCategory, TBool* aTestFinished=NULL);

   337 	TInt TestPanicL(TPanicFunction aFunction, TInt aExitReason, TInt aInt, TAny *aPtr, const TDesC &aCategory, TBool* aTestFinished=NULL);

   338 	TInt TestWsPanicL(TPanicFunction aFunction, TClientPanic aExitReason, TInt aInt, TAny *aPtr=NULL, TBool* aTestFinished=NULL);

   339 	TInt TestW32PanicL(TPanicFunction aFunction, TW32Panic aExitReason, TInt aInt, TAny *aPtr, TBool* aTestFinished=NULL);

   340 	TInt TestWservPanicL(TPanicFunction aFunction, TWservPanic aExitReason, TInt aInt, TAny *aPtr);

   341 	void TriggerFail();

   342 	static void DrawTestBackground(TBool aInvertColours, const TSize &aSize, TInt aGrays=16);

   343 	inline CTestDriver* Driver();

   344 	void SimulatePointer(TRawEvent::TType aType, TInt aX, TInt aY);

   345 	TBool ConfigurationSupportsPointerEventTesting() const;

   346 	void SimulateEvent(TRawEvent::TType aType);

   347 	void LogColors(const CBitmapDevice& aDevice,TPoint aBasePoint, TPoint aStartPoint, TPoint aEndPoint);

   348 	void LogColors4(const CBitmapDevice& aDevice,TPoint aStartPoint,TInt aLen);

   349 	inline TInt ScreenNumber() {return iScreenNumber;}

   350 	TPartialRedrawType RedrawStoreTypeL();

   351 	TBool IsFullRomL();

   352 	void SimulateKeyDownUpWithModifiers(TInt aScanCode,TUint aModifiers);

   353 	void SimulatePointerDownUp(TInt aX, TInt aY);

   354 	void SimulateKeyDownUp(TInt aScanCode);

   355 	void SimulateKey(TRawEvent::TType aType, TInt aScanCode);

   356 	void DelayIfFullRomL();

   357 	void SetUpMember(TSpriteMember &aMember);

   358 	void AbortL();

   359 	void LogLeave(TInt aErr);

   360 	void CloseAllPanicWindows();

   361 	const TSize& StdTestWindowSize();

   362 	TInt MaxGrays() const;

   363 	TInt MaxColors() const;

   364 	TInt SaveScreen(const TDesC& aFileName);

   365 	TInt SaveScreen(const TDesC& aFileName,const TSize& aScreenSize,TDisplayMode aColorDepth);

   366 protected:

   367 	void UpdateTestResults(TInt aNoOfTest, TInt aNoOfTestPass);

   368 	void SaveScreenL(const TDesC& aFileName,const TSize& aScreenSize,TDisplayMode aColorDepth);

   369 public:

   370 	static TInt iNumberTestsPass;

   371 	static TInt iNumberTests;

   372 	TInt iState;

   373 	TInt iScreenNumber;

   374 	static TInt iScreenNo;

   375 	TTestRects iTestRects;

   376 	static TRect iNormalPointerCursorArea;

   377 	TBuf<0x40> iSubTitle;

   378 	TTestLevel iTestLevel;

   379 	static TInt iNumberOfGrpWndsOnPrimaryScreenWithZeroPriority; // Will be used in TGWHANDLE test.

   380 protected:

   381 	CTestDriver* iDriver;

   382 private:

   383 	TBuf<0x40> iTitle;

   384 	CTWsGraphicsBase* iTestBase;

   385 	/**

   386 	Several tests use 3 windows : one is a log window, one is a reference window

   387 	and one is the actual output of the test. All these windows have the same width which is roughly

   388 	1/3 of the screen. They also have the same height which is roughly equal to the screen height.

   389 	*/

   390 	TSize iStdTestWindowSize;

   391 	CMinWin* iMinWin;

   392 	TInt iTestNum;

   393 	TBool iFail;	// Used to trigger failures to test test code.

   394 	TInt iThreadNumber;

   395 	/**

   396 	The type of redraw store in use. Static members so that	RedrawStoreTypeL computes

   397 	this value only once and then returns the cached result as this remains the same for

   398 	the entire test run.

   399 	*/

   400 	static TPartialRedrawType iRedrawType;

   401 	/** The number of greys available in the richest grey mode. */

   402 	static TInt iMaxGrays;

   403 	/** The number of colours available in the richest supported colour mode. */

   404 	static TInt iMaxColors;

   405 	};

   407 class CTWsGraphicsBase : public CTGraphicsBase

   408 	{

   409 public:

   410 	CTWsGraphicsBase(CTestStep* aStep);

   411 	~CTWsGraphicsBase();

   412 	void CreateTestBaseL(CTTMSGraphicsStep* aTmsStep);

   413 	inline CTestBase *TestBase() const {return(iTest);};

   414 	void TestComplete();

   415 	void LogMessage(const TText8* aFile,TInt aLine,TRefByValue<const TDesC> aFmt,...);

   416 	TInt GetScreenFromIni() const;

   417 protected:

   418 	void CheckRect(TPoint aPos1,TPoint aPos2,TSize aSize, const TDesC *aErrorMsg=NULL);

   419 	void CheckRect(TPoint aPos1,TPoint aPos2,TSize aSize, const TDesC &aErrorMsg);

   420 	void CheckRectNoMatch(TPoint aPos1,TPoint aPos2,TSize aSize, const TDesC *aErrorMsg=NULL);

   421 	void CheckRectNoMatch(TPoint aPos1,TPoint aPos2,TSize aSize, const TDesC &aErrorMsg);

   422 	void CheckRect(CTBaseWin *aWin1,CTBaseWin *aWin2, const TDesC *aErrorMsg=NULL);

   423 	void CheckRect(CTBaseWin *aWin1,CTBaseWin *aWin2, const TDesC &aErrorMsg);

   424 	void CheckRectNoMatch(CTBaseWin *aWin1,CTBaseWin *aWin2, const TDesC *aErrorMsg=NULL);

   425 	void CheckRectNoMatch(CTBaseWin *aWin1,CTBaseWin *aWin2, const TDesC &aErrorMsg);

   426 	TBool CheckRect(CTBaseWin *aWin1,CTBaseWin *aWin2,const TRect &aRect, const TDesC *aErrorMsg=NULL);

   427 	TBool CheckRect(CTBaseWin *aWin1,CTBaseWin *aWin2,const TRect &aRect, const TDesC &aErrorMsg);

   428 	void CheckRectNoMatch(CTBaseWin *aWin1,CTBaseWin *aWin2,const TRect &aRect, const TDesC *aErrorMsg=NULL);

   429 	void CheckRectNoMatch(CTBaseWin *aWin1,CTBaseWin *aWin2,const TRect &aRect, const TDesC &aErrorMsg);

   430 	TBool CompareWindows(const TDesC *aErrorMsg=NULL);

   431 	TBool CompareWindows(const TDesC &aErrorMsg);

   432 	void CompareWindows(const TRect &aRect, const TDesC *aErrorMsg=NULL);

   433 	void CompareWindows(const TRect &aRect, const TDesC &aErrorMsg);

   434 	void CompareWindowsSoftFailWinscw(const TText8* aFile, TInt aLine);

   435 	const TSize& StdTestWindowSize();

   436 	TInt MaxGrays() const;

   437 	TInt MaxColors() const;

   438 private:

   439 	TBool CheckRetValue(TBool aPass,const TDesC* aErrorMsg,const TDesC& aErrorFunction);

   440 protected:

   441 	CTestBase* iTest;

   442 	CTTMSGraphicsStep* iTmsStep;

   443 	};

   445 class TestWindowGroup : public CTWindowGroup

   446 	{

   447 public:

   448 	TestWindowGroup(CTClient *aClient);

   449 	void BecomeOwning();

   450 	void KeyL(const TKeyEvent &aKey,const TTime &aTime);

   451 	void KeyDownL(const TKeyEvent &aKey,const TTime &aTime);

   452 	void KeyUpL(const TKeyEvent &aKey,const TTime &aTime);

   453 	};

   455 class TestClient : public CTClient

   456 	{

   457 public:

   458 	TestClient();

   459 	~TestClient();

   460 	void ConstructL();	// virtual from CTClient

   461 	void KeyL(const TKeyEvent &aKey,const TTime &aTime);

   462 	void Shutdown();

   463 	inline CTestDriver* Driver();

   464 	TBool WaitForEvent();

   465 	TBool IsEventWaiting();

   466 	void LogAvailableScreenModeL();

   467 	void TestWsSetBufferSizeL();

   468 	void TestWsSetMaxBufferSizeL();

   469 	inline LogWindow& StdLogWindow() {return *iStdLogWindow;}

   470 	void SetTestClientScreenMode(TInt aMode);

   471 	void UpdateTestClientScreenMode();

   472 public:

   473 	RArray<TInt> iScreenModes;

   475 private:

   476 	/**

   477 	Several tests use 3 windows : one is a log window, one is a reference window

   478 	and one is the actual output of the test. This member is the log window.

   479 	*/

   480 	LogWindow* iStdLogWindow;

   481 	CTestDriver* iDriver;

   482 	};

   484 class TThreadStartUp

   485 	{

   486 public:

   487 	TThreadStartUp() :iInitFunction(0), iParam(0) {}

   488 	TThreadStartUp(TThreadFunction aInitFunction,TAny* aParam) :iInitFunction(aInitFunction), iParam(aParam) {}

   489 public:

   490 	TThreadFunction iInitFunction;	   //The call to this fn will prepare a cleanup stack, but this function should not leave.

   491 	TAny* iParam;

   492 	};

   494 #if defined(__WINS__)

   495 	const TOwnerType KOwnerType=EOwnerThread;

   496 #else

   497 	const TOwnerType KOwnerType=EOwnerProcess;

   498 #endif

   500 typedef TBuf<32> TBufArg;

   502 class CProcess : public CBase

   503 	{

   504 public:

   505 	enum

   506 		{

   507 		eProcessPriortyTest,

   508 		eProcessKeyTest,

   509 		eProcessDirectTest,

   510 		eProcessMultiDisplayTest,

   511 		eNumProcessCalls		//Must be last one

   512 		};

   513 	struct TInitialFunction

   514 		{

   515 		inline TInitialFunction(const TDesC& aParam,TThreadFunction aFunction) :iParam(aParam), iFunction(aFunction) {}

   516 		TBuf<16> iParam;

   517 		TThreadFunction iFunction;

   518 		};

   519 public:

   520 	static TInt Start(const TWinCommand& aParam);

   521 	static CProcess* NewL(TInt aFunctionNo,TInt aScreenNumber=KDefaultScreen);

   522 	static CProcess* NewTL(TInt aFunctionNo,TInt aScreenNumber=KDefaultScreen,TRequestStatus* aClientRequestStatus = NULL);

   523 	static CProcess* NewThreadL(const TDesC& aName,TThreadFunction aFunction,TThreadStartUp* aPtr

   524 																							,TRequestStatus* aStatus);

   525 	static CProcess* NewThreadL(const TDesC& aName,TThreadStartUp* aPtr);

   526 	static CProcess* NewThreadRendezvousL(const TDesC& aName,TThreadFunction aFunction,TThreadStartUp* aPtr,TRequestStatus* aLogonStatus,TRequestStatus& aRendezvousStatus);

   527 	static CProcess* NewThreadRendezvousL(const TDesC& aName,TThreadStartUp* aPtr,TRequestStatus& aRendezvousStatus);

   529 	static CProcess* NewSimpleThreadL(const TDesC& aName,TThreadStartUp* aPtr,TRequestStatus* aStatus=NULL);

   530 	void ConstructL(TInt aFunctionNo,TInt aScreenNumber=KDefaultScreen);

   531 	void ConstructTL(TInt aFunctionNo,TInt aScreenNumber=KDefaultScreen,TRequestStatus* aStatus=NULL);

   532 	void ConstructL(const TDesC& aName,TThreadFunction aFunction,TThreadStartUp* aPtr,TRequestStatus* aStatus);

   533 	void ConstructRendezvousL(const TDesC& aName,TThreadFunction aFunction,TThreadStartUp* aPtr,TRequestStatus* aLogonStatus,TRequestStatus& aRendezvousStatus);

   535 	~CProcess();

   536 	void Logon(TRequestStatus& aStatus) const;

   537 	void Terminate(TInt aReason);

   538 	TBool StillAlive();

   539 	void LeaveIfDied();

   540 	static TBool ProcessDied(TInt aScreenNo=KDefaultScreen);

   541 private:

   542 	enum

   543 		{

   544 		eOtherCreated=0x0001,

   545 		eThreadCreated=0x0002,

   546 		};

   547 private:

   548 	static TInt ThreadInit(TAny *aPtr);

   549 	static void InitialiseL(TThreadStartUp* aPtr);

   550 	static TInt SimpleThreadInit(TAny *aPtr);

   551 	void Close();

   552 	static void GetProcArg(const TWinCommand& aParam,TBufArg& aProcArg);

   553 	static void GetScreenArg(const TWinCommand& aParam, TInt& aScreenArg);

   555 private:

   556 	TUint iCreated;

   557 	RProcess iOther;

   558 	RThread iThread;

   559 	static TInitialFunction iFunctions[eNumProcessCalls];

   560 	};

   562 GLREF_D TestWindow* BaseWin;

   563 GLREF_D TestWindow* TestWin;

   564 GLREF_D TestClient* TheClient;

   565 GLREF_D CWindowGc* TheGc;

   567 GLREF_C void AutoPanic(TInt aPanic);

   568 GLREF_C void CleanUpWindow(TAny *aWindow);

   569 GLREF_C void PushWindowL(RWindowTreeNode *aWindow);

   570 GLREF_C TBool OpacityAndAlphaSupportedL();

   571 GLREF_C TInt TransparencySupportedL();

   572 GLREF_C TInt CheckScalingSupportedOrNot();

   573 GLREF_C TBool CheckNonZeroOriginsSupportedOrNot();

   574 GLREF_C TPoint PhysicalToLogical(TPoint aPhysicalPtMinusOrigin,TSize aScale);

   575 GLREF_C TPtrC DisplayModeAsString(TDisplayMode aMode);

   576 GLREF_C TBool LossyCheckBlankBitmap(const CFbsBitmap& aBitmap, const TRect aArea, const TRgb aCheckColor, TBool aLossyCompare=ETrue);

   577 GLREF_C TBool LossyCompareBitmap(const CFbsBitmap& aBitmap1, const CFbsBitmap& aBitmap2, const TRect aCompareRect, TBool aLossyCompare=ETrue);

   578 GLDEF_C TBool LossyCompareBitmapRecord(CFbsBitmap& aBitmap1, CFbsBitmap& aBitmap2, const TRect aCompareRect, TBool aLossyCompare, TInt& aPixelsDifferent, CTestExecuteLogger& aLogger);

   579 GLREF_C TBool LossyCheckBlankWindow(const CWsScreenDevice& aScreen, CFbsBitmap& aBitmap, const TRect aArea, const TRgb aCheckColor);

   580 GLREF_C TBool LossyCompareWindow(const CWsScreenDevice& aScreen, CFbsBitmap& aBitmap1, CFbsBitmap& aBitmap2, const TRect aCompareRect);

   582 #define LogText(S) {_LIT(String__LINE__,S); Logger.Log(String__LINE__);}

   583 #define LogFormat(S) {Logger.Log(S);}

   585 inline CTestDriver* CTestBase::Driver()

   586 	{

   587 	return iDriver;

   588 	}

   590 class CTransWindow : public CBlankWindow

   591 	{

   592 public:

   593 	static CTransWindow* NewL(RPointerArray<CTransWindow>& aWindows,TRgb aColor,TRect aPos);

   594 	static CTransWindow* NewL(CTWinBase* aParent,TRgb aColor,TRect aPos,TDisplayMode* aDisplayMode);

   595 	static CTransWindow* NewL(CTWinBase* aParent,TRgb aColor,TDisplayMode* aDisplayMode);

   596 	void ToggleVisibility();

   597 	static void SetOrdinal(RPointerArray<CTransWindow>& aWindows,TInt aOldPos,TInt aNewPos);

   598 	inline TRgb Color() {return iCol;}

   599 	inline TBool IsVisible() {return iVisible;}

   600 	void SetShadowDisabled(TBool aState);

   601 	inline TBool IsShadowing() {return iShadowing;}

   602 	inline TBool ShadowHeight() {return iShadowHight;}

   603 	inline void SetPosOffset(TPoint aOffset) {iPosOffset=aOffset;}

   604 	virtual void Draw();

   605 	void SetDrawOpaque(TBool aDrawOpaque) { iDrawOpaque = aDrawOpaque; }

   606 	TBool DrawOpaque() const { return iDrawOpaque; }

   607 	//Virtual functions from CTWinBase overridden in CTBaseWin

   608 	void AdjustShadow(TInt aAdjust);

   609 	TPoint Position() const;

   610 	inline TInt TransparentError() {return iError;}

   611 private:

   612 	CTransWindow(TRgb aColor) :CBlankWindow(aColor), iVisible(ETrue) {}

   613 	//Virtual function from CTBaseWin

   614 	void InitWin();

   615 private:

   616 	TBool iVisible;

   617 	TBool iShadowing;

   618 	TBool iDrawOpaque;

   619 	TInt iShadowHight;

   620 	TPoint iPosOffset;

   621 	TInt iError;

   622 	};

   624 class CMinWin : public CBase

   625 	{

   626 public:

   627 	CMinWin(TInt aScreenNo);

   628 	~CMinWin();

   629 	void ConstructL();

   630 	void Draw(const TRect& aRect);

   631 private:

   632 	RWsSession iWs;

   633 	RWindow iWin;

   634 	RWindowGroup iGroup;

   635 	CWsScreenDevice* iScr;

   636 	TInt iScreenNo;

   637 	TRect iRect;

   638 	CWindowGc* iGc;

   639 	};

   641 class CTimeOut : public CTimer

   642 	{

   643 public:

   644 	inline CTimeOut(): CTimer((EPriorityLow+EPriorityIdle)/2) {}

   645 	void ConstructL();

   646 	void Start(TTimeIntervalMicroSeconds32 aInterval,TCallBack aCallBack);

   647 	//Pure virtual from CActive

   648 	void RunL();

   649 private:

   650 	TCallBack iCallBack;

   651 	};

   653 #define COMPARE_WINDOWS_SOFTFAIL_WINSCW	CompareWindowsSoftFailWinscw((TText8*)__FILE__, __LINE__)

   655 #define __WS_CONSTRUCT_STEP__(a) \

   656 	CT##a##Step::CT##a##Step() \

   657 	{ \

   658 	SetTestStepName(KT##a##Step); \

   659 	SetLogHeapInfo(ETrue); \

   660 	} \

   661 	 \

   662 CTGraphicsBase* CT##a##Step::CreateTestL() \

   663 	{ \

   664 	CTWsGraphicsBase* test=new (ELeave) CT##a (this); \

   665  	test->CreateTestBaseL(this);\

   666 	return test;\

   667 	}

   669 #endif

author	sl@SLION-WIN7.fritz.box
	Fri, 15 Jun 2012 03:10:57 +0200
changeset 0	bde4ae8d615e
permissions	-rw-r--r--