diff -r 000000000000 -r bde4ae8d615e os/graphics/graphicsdeviceinterface/directgdi/test/tdirectgdi_test_step_base.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/os/graphics/graphicsdeviceinterface/directgdi/test/tdirectgdi_test_step_base.h Fri Jun 15 03:10:57 2012 +0200 @@ -0,0 +1,455 @@ +// 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: +// + +/** + @file + @test + @internalComponent - Internal Symbian test code +*/ + +#ifndef __TDIRECTGDI_TEST_STEP_BASE__ +#define __TDIRECTGDI_TEST_STEP_BASE__ + +#include "tdisplaymode_mapping.h" +#include "tcontextbase.h" +#include +#include +#include +#include +#include +#include +#include +#include + +/** +Default size of the off screen image in pixels +*/ +const TSize KDefaultOffScreenImageSizeInPixels(200, 200); +const TInt KTestCaseLength = 100; + +_LIT(KCom, "Compressed"); +_LIT(KSeparator, "_"); +_LIT(KDirectGc, "DirectGdi"); +_LIT(KBitGc, "BitGdi"); +_LIT(KTargetString, "TGT"); +_LIT(KSourceString, "SRC"); + +const TInt KFileNameLength = 200; +const TInt KPixelFormatNameLength = 40; + +// Define 16 RGB colors +#define KRgbBlack TRgb(0x000000) +#define KRgbDarkGray TRgb(0x555555) +#define KRgbDarkRed TRgb(0x000080) +#define KRgbDarkGreen TRgb(0x008000) +#define KRgbDarkYellow TRgb(0x008080) +#define KRgbDarkBlue TRgb(0x800000) +#define KRgbDarkMagenta TRgb(0x800080) +#define KRgbDarkCyan TRgb(0x808000) +#define KRgbRed TRgb(0x0000ff) +#define KRgbGreen TRgb(0x00ff00) +#define KRgbYellow TRgb(0x00ffff) +#define KRgbBlue TRgb(0xff0000) +#define KRgbMagenta TRgb(0xff00ff) +#define KRgbCyan TRgb(0xffff00) +#define KRgbGray TRgb(0xaaaaaa) +#define KRgbWhite TRgb(0xffffff) + +// A 16 RGB color table +const TRgb KColor16Table[] = + { + KRgbWhite, + KRgbGray, + KRgbCyan, + KRgbMagenta, + KRgbBlue, + KRgbYellow, + KRgbGreen, + KRgbRed, + KRgbDarkCyan, + KRgbDarkMagenta, + KRgbDarkBlue, + KRgbDarkYellow, + KRgbDarkGreen, + KRgbDarkRed, + KRgbDarkGray, + KRgbBlack, + }; + +_LIT(KColorNameWhite,"White"); +_LIT(KColorNameGray,"Gray"); +_LIT(KColorNameCyan,"Cyan"); +_LIT(KColorNameMagenta,"Magenta"); +_LIT(KColorNameBlue,"Blue"); +_LIT(KColorNameYellow,"Yellow"); +_LIT(KColorNameGreen,"Green"); +_LIT(KColorNameRed,"Red"); +_LIT(KColorNameDarkCyan,"DarkCyan"); +_LIT(KColorNameDarkMagenta,"DarkMagenta"); +_LIT(KColorNameDarkBlue,"DarkBlue"); +_LIT(KColorNameDarkYellow,"DarkYellow"); +_LIT(KColorNameDarkGreen,"DarkGreen"); +_LIT(KColorNameDarkRed,"DarkRed"); +_LIT(KColorNameDarkGrey,"DarkGrey"); +_LIT(KColorNameBlack,"Black"); + +const TPtrC KColor16TableNames[] = + { + KColorNameWhite(), + KColorNameGray(), + KColorNameCyan(), + KColorNameMagenta(), + KColorNameBlue(), + KColorNameYellow(), + KColorNameGreen(), + KColorNameRed(), + KColorNameDarkCyan(), + KColorNameDarkMagenta(), + KColorNameDarkBlue(), + KColorNameDarkYellow(), + KColorNameDarkGreen(), + KColorNameDarkRed(), + KColorNameDarkGrey(), + KColorNameBlack(), + }; + + + +const DirectGdi::TBrushStyle KBrushStyleTable[] = + { + DirectGdi::ENullBrush, + DirectGdi::ESolidBrush, + DirectGdi::EPatternedBrush, + DirectGdi::EVerticalHatchBrush, + DirectGdi::EForwardDiagonalHatchBrush, + DirectGdi::EHorizontalHatchBrush, + DirectGdi::ERearwardDiagonalHatchBrush, + DirectGdi::ESquareCrossHatchBrush, + DirectGdi::EDiamondCrossHatchBrush, + }; +const TInt KNumBrushStyles = sizeof(KBrushStyleTable) / sizeof(DirectGdi::TBrushStyle); + +_LIT(KBrushStyleNullBrush,"NullBrush"); +_LIT(KBrushStyleSolidBrush,"SolidBrush"); +_LIT(KBrushStylePatternedBrush,"PatternedBrush"); +_LIT(KBrushStyleVerticalHatchBrush,"VerticalHatchBrush"); +_LIT(KBrushStyleForwardDiagonalHatchBrush,"ForwardDiagonalHatchBrush"); +_LIT(KBrushStyleHorizontalHatchBrush,"HorizontalHatchBrush"); +_LIT(KBrushStyleRearwardDiagonalHatchBrush,"RearwardDiagonalHatchBrush"); +_LIT(KBrushStyleSquareCrossHatchBrush,"SquareCrossHatchBrush"); +_LIT(KBrushStyleDiamondCrossHatchBrush,"DiamondCrossHatchBrush"); + +const TPtrC KBrushStyleTableNames[] = + { + KBrushStyleNullBrush(), + KBrushStyleSolidBrush(), + KBrushStylePatternedBrush(), + KBrushStyleVerticalHatchBrush(), + KBrushStyleForwardDiagonalHatchBrush(), + KBrushStyleHorizontalHatchBrush(), + KBrushStyleRearwardDiagonalHatchBrush(), + KBrushStyleSquareCrossHatchBrush(), + KBrushStyleDiamondCrossHatchBrush(), + }; + +const DirectGdi::TPenStyle KPenStyleTable[] = + { + DirectGdi::ENullPen, + DirectGdi::ESolidPen, + DirectGdi::EDottedPen, + DirectGdi::EDashedPen, + DirectGdi::EDotDashPen, + DirectGdi::EDotDotDashPen, + }; + +const DirectGdi::TTextAlign KTextAlignTable[] = + { + DirectGdi::ELeft, + DirectGdi::ECenter, + DirectGdi::ERight, + }; + +_LIT(KTextAlignNameLeft,"Left"); +_LIT(KTextAlignNameCenter,"Center"); +_LIT(KTextAlignNameRight,"Right"); + +const TPtrC KTextAlignTableNames[] = + { + KTextAlignNameLeft(), + KTextAlignNameCenter(), + KTextAlignNameRight(), + }; + +// Look-up table for pen-names. +_LIT(KPenNameNull,"NullPen"); +_LIT(KPenNameSolid,"SolidPen"); +_LIT(KPenNameDotted,"DottedPen"); +_LIT(KPenNameDashed,"DashedPen"); +_LIT(KPenNameDotDash,"DotDashPen"); +_LIT(KPenNameDotDotDash,"DotDotDashPen"); + +const TPtrC KPenNames[] = + { + KPenNameNull(), + KPenNameSolid(), + KPenNameDotted(), + KPenNameDashed(), + KPenNameDotDash(), + KPenNameDotDotDash() + }; + +// Look-up table for all available pen-styles. +const DirectGdi::TPenStyle KPenStyles[] = + { + DirectGdi::ENullPen, + DirectGdi::ESolidPen, + DirectGdi::EDottedPen, + DirectGdi::EDashedPen, + DirectGdi::EDotDashPen, + DirectGdi::EDotDotDashPen + }; +const TInt KNumPenStyles = sizeof(KPenStyles)/sizeof(DirectGdi::TPenStyle); + +// Look-up table for fill rule names. +_LIT(KFillRuleAlternate,"Alternate"); +_LIT(KFillRuleWinding,"Winding"); + +const TPtrC KFillRuleNames[] = + { + KFillRuleAlternate(), + KFillRuleWinding() + }; + +/** +Possible use cases of contexts and targets. +*/ +enum TContextTestCase + { + EOneContextOneTarget, + EOneContextTwoTargets_SamePixelType, + EOneContextTwoTargets_DifferentPixelType, + ETwoContextsOneTarget, + ETwoContextsTwoTargets_WithoutSharing_SamePixelType, + ETwoContextsTwoTargets_WithoutSharing_DifferentPixelType, + ETwoContextsTwoTargets_WithSharing_SamePixelType, + ETwoContextsTwoTargets_WithSharing_DifferentPixelType, + EOneContextOneTarget_TwiceActivate, + ELast + }; + +/** +Position iterator helper class. +Position iterator generates all possible positions from given start position to end position +with step. All combinations of horizontal and vertical positions are generated. +Additionaly x and y position index is iterated. + */ +class TPositionIterator + { +public: + TPositionIterator(TInt aStartX, TInt aEndX, TInt aStepX, + TInt aStartY, TInt aEndY, TInt aStepY); + void Begin(); + TBool Next(); +public: + TInt iStartX; + TInt iEndX; + TInt iStepX; + TInt iStartY; + TInt iEndY; + TInt iStepY; + TInt iPosX; // current x position + TInt iPosY; // current y position + TInt iIndexX; // current x position index + TInt iIndexY; // current y position index + }; + +/** +Base class for creating an off screen image target +*/ +class CTImageTarget : public CBase + { +public: + virtual TSize SizeInPixels() const = 0; + virtual CFbsBitmap* GetTargetFbsBitmapL() = 0; + virtual TInt CreateContext(CTContextBase*& aGc, TBool aActivate=ETrue) = 0; + virtual void Finish() = 0; + virtual TInt Activate(CTContextBase*& aGc) = 0; + virtual void Close() = 0; + virtual CBitmapDevice* BitmapDevice() const; + +protected: + CBitmapDevice* iBitmapDevice; // The virtual device + CFbsBitmap* iBitmap; // Virtual bitmap + }; + +/** +Create an image target using CFbsBitGc +*/ +class CTBitGdiTarget : public CTImageTarget + { +public: + virtual ~CTBitGdiTarget(); + static CTBitGdiTarget* NewL(TUidPixelFormat aPixelFormat, const TSize& aSize); + virtual TSize SizeInPixels() const; + virtual CFbsBitmap* GetTargetFbsBitmapL(); + virtual TInt CreateContext(CTContextBase*& aGc, TBool aActivate=ETrue); + virtual void Finish(); + virtual TInt Activate(CTContextBase*& aGc); + virtual void Close(); +private: + void ConstructL(TUidPixelFormat aPixelFormat, const TSize& aSize); + }; + +/** +Create an image target using DirectGDiGc + */ +class CTDirectGdiTarget : public CTImageTarget + { +public: + CTDirectGdiTarget(); + virtual ~CTDirectGdiTarget(); + static CTDirectGdiTarget* NewL(TUidPixelFormat aPixelFormat, const TSize& aSize); + virtual TSize SizeInPixels() const; + virtual CFbsBitmap* GetTargetFbsBitmapL(); + virtual TInt CreateContext(CTContextBase*& aGc, TBool aActivate=ETrue); + virtual void Finish(); + virtual TInt Activate(CTContextBase*& aGc); + virtual void Close(); +private: + void ConstructL(TUidPixelFormat aPixelFormat, const TSize& aSize); + +public: + CDirectGdiDriver* iDGdiDriver; // Driver for Direct GDI support + RDirectGdiImageTarget* iDGdiImageTarget; + RSgImage iRSgImage; + TSgImageInfo iImageInfo; // image info for RSgImage + }; + +/** +The reason to have a new step base is that it is very much possible that the all +individual test steps have project related common variables and members +and this is the place to define these common variable and members. +All directgdi test classes derive from this class +*/ +class CTDirectGdiStepBase : public CTTMSGraphicsStep + { + +protected: + // This structure is used to help manage parameters on a per test-case + // basis. A pointer to an instance of this structure is passed through + // to each test case as it executes. + // + struct TTestParams + { + TUidPixelFormat iTargetPixelFormat; + TUidPixelFormat iSourcePixelFormat; + TUidPixelFormat iSourceResourcePixelFormat; + TBool iDoCompressed; + + TTestParams () : + iTargetPixelFormat(EUidPixelFormatUnknown), + iSourcePixelFormat(EUidPixelFormatUnknown), + iSourceResourcePixelFormat(EUidPixelFormatUnknown), + iDoCompressed(EFalse){}; + }; + + virtual ~CTDirectGdiStepBase(); + CTDirectGdiStepBase(); + void SetTargetL(TUidPixelFormat aPixelFormat, const TContextTestCase aCase = EOneContextOneTarget, const TSize& aSize=KDefaultOffScreenImageSizeInPixels); + void ConvertPixelFormats(TPtrC aPixelFormatInput, RArray& aPixelFormatArray); + void CreateFileName(TTestParams& aParams, TDes& aTestName, TPtrC& aTestCaseName, TDesC* namePostfix = NULL); + void DisplayTargetImageL(TUidPixelFormat aPixelFormat); + void DisplayTargetImageL(TUidPixelFormat aPixelFormat, CTImageTarget* aGdiTarget); + TInt WriteTargetOutput(TTestParams& aParams, TPtrC aTestCaseName, TDesC* namePostfix = NULL); + TInt WriteTargetOutput(TTestParams& aParams, TPtrC aTestCaseName, CTImageTarget* aImageTarget, TDesC* namePostfix = NULL); + void ResetGc(); + CFbsBitmap* CreateConcentricRectsBitmapL(TUidPixelFormat aPixelFormat, const TSize& aSize); + CFbsBitmap* CreateCheckedBoardBitmapL(TUidPixelFormat aPixelFormat, + const TSize& aSize, const TSize& aChecksPerAxis = TSize(10, 10), TBool aGenAlpha = EFalse); + CFbsBitmap* CreateBlackWhiteBitmapL(TUidPixelFormat aPixelFormat, + const TSize& aSize, const TSize& aChecksPerAxis = TSize(10, 10)); + CFbsBitmap* CreateMaskingPixmapL (TUidPixelFormat aPixelFormat, const TSize& aSize); + CFont* GetFont(); + void ReleaseFont(CFont* aFont); + TBool TestTargetL(const TRgb& aColour); + void CheckErrorsL(TInt aDirectGdiErrorCode, TInt aBitGdiErrorCode, const TText8* aFile, TInt aLine); + +protected: + // From CTestStep + virtual TVerdict doTestStepPreambleL(); + virtual TVerdict doTestStepPostambleL(); + virtual void testBooleanTrue(TBool aCondition, const TText8* aFile, TInt aLine); + virtual void testBooleanTrueL(TBool aCondition, const TText8* aFile, TInt aLine); + virtual void testBooleanTrueWithErrorCode(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine); + virtual void testBooleanTrueWithErrorCodeL(TBool aCondition, TInt aErrorCode, const TText8* aFile, TInt aLine); + // Functions specific to CTDirectGdiStepBase (and derived classes) + virtual void RunTestsL() = 0; + void RunOomTestsL(); + static void ResetCache(TAny* aPtr); + static void ResetPenSize(TAny* aPtr); + +protected: + CTContextBase* iGc; + CTContextBase* iGc2; + CTImageTarget* iGdiTarget; + CTImageTarget* iGdiTarget2; + TBool iMakeRefImg; // switch on (ETrue) and off the control of generating reference images, from .ini file + TBool iUseDirectGdi; // switch on (ETrue) and off the control of using Directgdi or old bitgdi, from .ini file + RArray iTargetPixelFormatArray; // target pixel format(s) for testing + RArray iSourcePixelFormatArray; // source pixel format(s) for testing + RArray iSourceResourcePixelFormatArray; // source resource pixel format(s) for testing (for DrawResource) + TTestParams iTestParams; // Parameters used for testing in derived classes + TBool iDoOomTests; // switch on (ETrue) and off whether out of memory tests are run, from .ini file + TBool iRunningOomTests; // ETrue if out of memory tests are running + + CFbsTypefaceStore* iFontStore; + TInt iFontId; + MVgImageCache* iVgImageCache; + TBool iUseSwDirectGdi; // ETrue if software DirectGDI is being used +private: + CActiveScheduler* iScheduler; + }; + +// Macros to automatically test error condition and report when test fails. +// Essentially same as TESTE(a,b) MACRO that base class uses, except error to check is also error that is reported. +#define TESTNOERROR(a) \ + {\ + TInt b = a;\ + TBool c = (b == KErrNone);\ + testBooleanTrueWithErrorCode((c), (b), (TText8*)__FILE__, __LINE__);\ + } + +#define TESTNOERRORL(a) \ + {\ + TInt b = a;\ + TBool c = (b == KErrNone);\ + testBooleanTrueWithErrorCodeL((c), (b), (TText8*)__FILE__, __LINE__);\ + } + +#define TESTWITHFILENAMEANDLINENUMBERL(a, f, l) \ + {\ + testBooleanTrueL((a), f, l); \ + } + +/** +Gets the size of the hardware display in pixels +@return TSize object containing the screen size +*/ +inline TSize GetDisplaySizeInPixels() + { + return TSize(150, 150); + } + +#endif