# HG changeset patch # User Maciej Seroka # Date 1257944662 0 # Node ID 09c37dab59b401ee900df87d2c9026b4a971d50c # Parent e13acd883fbe11620a838de22ed6421e8b8ada56 Added new smoketest diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/Group/bld.inf --- a/common/tools/ats/smoketest/Group/bld.inf Tue Nov 10 13:50:58 2009 +0000 +++ b/common/tools/ats/smoketest/Group/bld.inf Wed Nov 11 13:04:22 2009 +0000 @@ -27,3 +27,4 @@ #include "../notepad/group/bld.inf" #include "../appinstall/group/Bld.inf" #include "../lbs/group/bld.inf" +#include "../uiresources/group/bld.inf" diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/Group/smoketest.pl --- a/common/tools/ats/smoketest/Group/smoketest.pl Tue Nov 10 13:50:58 2009 +0000 +++ b/common/tools/ats/smoketest/Group/smoketest.pl Wed Nov 11 13:04:22 2009 +0000 @@ -62,5 +62,8 @@ copy($epoc . "release/winscw/udeb/TestNpdApi.dll", "temp/smoketest/winscw_udeb/TestNpdApi.dll"); copy($epoc . "data/c/smoketest/smoketest_notepad.cfg", "temp/smoketest/general/smoketest_notepad.cfg"); copy($epoc . "data/c/smoketest/ui_TestNpdApi.cfg", "temp/smoketest/general/ui_TestNpdApi.cfg"); +copy($epoc . "release/winscw/udeb/testsdkskins.dll", "temp/smoketest/winscw_udeb/testsdkskins.dll"); +copy($epoc . "data/c/smoketest/smoketest_uiresources.cfg", "temp/smoketest/general/smoketest_uiresources.cfg"); +copy($epoc . "data/c/smoketest/ui_testsdkskinsu.cfg", "temp/smoketest/general/ui_testsdkskinsu.cfg"); system("7z a -tzip smoketest.zip ./temp/*"); diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/Group/smoketest.xml --- a/common/tools/ats/smoketest/Group/smoketest.xml Tue Nov 10 13:50:58 2009 +0000 +++ b/common/tools/ats/smoketest/Group/smoketest.xml Wed Nov 11 13:04:22 2009 +0000 @@ -383,6 +383,33 @@ + + install + + + + + + + + + install + + + + + + + + + install + + + + + + + execute @@ -410,6 +437,15 @@ + + execute + + + + + + + @@ -459,5 +495,8 @@ smoketest/general/ui_TestNpdApi.cfg smoketest/winscw_udeb/AppInstallSmokeTestModule.dll smoketest/general/AppInstallSmokeTestModule.cfg + smoketest/winscw_udeb/testsdkskins.dll + smoketest/general/smoketest_uiresources.cfg + smoketest/general/ui_testsdkskinsu.cfg diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/bwins/testsdkskinsu.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/bwins/testsdkskinsu.def Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,3 @@ +EXPORTS + ?LibEntryL@@YAPAVCScriptBase@@AAVCTestModuleIf@@@Z @ 1 NONAME ; class CScriptBase * LibEntryL(class CTestModuleIf &) + diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/conf/smoketest_uiresources.cfg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/conf/smoketest_uiresources.cfg Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,5 @@ + +[Test] +title TestUSkinInstanceL +run testscripter c:\smoketest\ui_testsdkskinsu.cfg 6 +[Endtest] diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/conf/ui_testsdkskinsu.cfg --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/conf/ui_testsdkskinsu.cfg Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,457 @@ +[Test] +title PressKey +pause 2000 +presskey global EKeyDevice1 +[Endtest] + +//----------------------------------------------------------------------------------// +//------------------------------------AknsUtils.H-----------------------------------// +//----------------------------------------------------------------------------------// +// Test AknsUtils.H +// For test function: +// IMPORT_C static void InitSkinSupportL(); +[Test] +title TestUInitSkinSupportL +create testsdkskins test +bringtoforeground +test TestUInitSkinSupportL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static MAknsDataContext* CreateDataContextForContainerL(); +[Test] +title TestUCreateDataContextForContainerL +create testsdkskins test +bringtoforeground +test TestUCreateDataContextForContainerL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CAknsItemDef* CreateBitmapItemDefL( +// const TAknsItemID& aID, const TDesC& aFilename, +// const TInt aIndex ); +[Test] +title TestUCreateBitmapItemDefL +create testsdkskins test +bringtoforeground +test TestUCreateBitmapItemDefL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CAknsItemDef* CreateMaskedBitmapItemDefL( +// const TAknsItemID& aID, const TDesC& aFilename, +// const TInt aIndex, const TInt aMaskIndex ); +[Test] +title TestUCreateMaskedBitmapItemDefL +create testsdkskins test +bringtoforeground +test TestUCreateMaskedBitmapItemDefL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static MAknsSkinInstance* SkinInstance(); +[Test] +title TestUSkinInstanceL +create testsdkskins test +bringtoforeground +test TestUSkinInstanceL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static MAknsDataContext* DataContext( MObjectProvider* aMop ); +[Test] +title TestUDataContextL +create testsdkskins test +bringtoforeground +test TestUDataContextL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateIconL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, +// const TDesC& aFilename, +// const TInt aFileBitmapId, const TInt aFileMaskId ); +[Test] +title TestUCreateIconML +create testsdkskins test +bringtoforeground +test TestUCreateIconML +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateIconLC( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, +// const TDesC& aFilename, +// const TInt aFileBitmapId, const TInt aFileMaskId ); +[Test] +title TestUCreateIconMLC +create testsdkskins test +bringtoforeground +test TestUCreateIconMLC +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateIconL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// CFbsBitmap*& aBitmap, +// const TDesC& aFilename, +// const TInt aFileBitmapId ); +[Test] +title TestUCreateIconL +create testsdkskins test +bringtoforeground +test TestUCreateIconL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateIconLC( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// CFbsBitmap*& aBitmap, +// const TDesC& aFilename, +// const TInt aFileBitmapId ); +[Test] +title TestUCreateIconLC +create testsdkskins test +bringtoforeground +test TestUCreateIconLC +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CApaMaskedBitmap* CreateMaskedBitmapL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// const TDesC& aFilename, +// const TInt aFileIndex, const TInt aFileMaskIndex ); +[Test] +title TestUCreateMaskedBitmapL +create testsdkskins test +bringtoforeground +test TestUCreateMaskedBitmapL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CGulIcon* CreateGulIconL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// const TDesC& aFilename, +// const TInt aFileIndex, const TInt aFileMaskIndex ); +[Test] +title TestUCreateGulIconL +create testsdkskins test +bringtoforeground +test TestUCreateGulIconL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateAppIconLC( +// MAknsSkinInstance* aInstance, TUid aAppUid, +// TAknsAppIconType aType, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask ); +[Test] +title TestUCreateAppIconLC +create testsdkskins test +bringtoforeground +test TestUCreateAppIconLC +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C TInt OpenAppIconFile( +// MAknsSkinInstance* aInstance, TUid aAppUid, +// TAknsAppIconType aType, RFile& aFile ); +[Test] +title TestUOpenAppIconFileL +create testsdkskins test +bringtoforeground +test TestUOpenAppIconFileL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateColorIconL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// const TAknsItemID& aColorID, const TInt aColorIndex, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, +// const TDesC& aFilename, +// const TInt aFileBitmapId, const TInt aFileMaskId, +// const TRgb aDefaultColor ); +[Test] +title TestUCreateColorIconL +create testsdkskins test +bringtoforeground +test TestUCreateColorIconL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateColorIconLC( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// const TAknsItemID& aColorID, const TInt aColorIndex, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, +// const TDesC& aFilename, +// const TInt aFileBitmapId, const TInt aFileMaskId, +// const TRgb aDefaultColor ); +[Test] +title TestUCreateColorIconLC +create testsdkskins test +bringtoforeground +test TestUCreateColorIconLC +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateColorIconL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// const TAknsItemID& aColorID, const TInt aColorIndex, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, +// const TDesC& aFilename, +// const TInt aFileBitmapId, const TInt aFileMaskId, +// const TRgb aDefaultColor, +// const TSize& aSize, const TScaleMode aScaleMode ); +[Test] +title TestUCreateColorIconML +create testsdkskins test +bringtoforeground +test TestUCreateColorIconML +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void CreateColorIconLC( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// const TAknsItemID& aColorID, const TInt aColorIndex, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, +// const TDesC& aFilename, +// const TInt aFileBitmapId, const TInt aFileMaskId, +// const TRgb aDefaultColor, +// const TSize& aSize, const TScaleMode aScaleMode ); +[Test] +title TestUCreateColorIconMLC +create testsdkskins test +bringtoforeground +test TestUCreateColorIconMLC +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static TInt GetAppIcon( +// MAknsSkinInstance* aInstance, TUid aAppUid, TSize aSize, +// CApaMaskedBitmap& aAppBitmap ); +[Test] +title TestUGetAppIconL +create testsdkskins test +bringtoforeground +test TestUGetAppIconL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CFbsBitmap* CreateBitmapL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID ); +[Test] +title TestUCreateBitmapL +create testsdkskins test +bringtoforeground +test TestUCreateBitmapL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CApaMaskedBitmap* CreateMaskedBitmapL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID ); +[Test] +title TestUCreateMaskedBitmapIL +create testsdkskins test +bringtoforeground +test TestUCreateMaskedBitmapIL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CGulIcon* CreateGulIconL( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// const TBool aRequireMask ); +[Test] +title TestUCreateGulIconIL +create testsdkskins test +bringtoforeground +test TestUCreateGulIconIL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static CFbsBitmap* GetCachedBitmap( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID ); +[Test] +title TestUGetCachedBitmapL +create testsdkskins test +bringtoforeground +test TestUGetCachedBitmapL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void GetCachedMaskedBitmap( +// MAknsSkinInstance* aInstance, const TAknsItemID& aID, +// CFbsBitmap*& aBitmap, CFbsBitmap*& aMask ); +[Test] +title TestUGetCachedMaskedBitmapL +create testsdkskins test +bringtoforeground +test TestUGetCachedMaskedBitmapL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static TInt GetCachedColor( +// MAknsSkinInstance* aInstance, TRgb& aRgb, const TAknsItemID& aID, +// const TInt aIndex ); +[Test] +title TestUGetCachedColorL +create testsdkskins test +bringtoforeground +test TestUGetCachedColorL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static TBool BooleanPropertyL( MAknsSkinInstance* aInstance, +// const TAknsItemID& aID ); +[Test] +title TestUBooleanPropertyL +create testsdkskins test +bringtoforeground +test TestUBooleanPropertyL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void SetAvkonSkinEnabledL( const TBool aEnabled ); +[Test] +title TestUSetAvkonSkinEnabledL +create testsdkskins test +bringtoforeground +test TestUSetAvkonSkinEnabledL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static TBool AvkonSkinEnabled(); +[Test] +title TestUAvkonSkinEnabledL +create testsdkskins test +bringtoforeground +test TestUAvkonSkinEnabledL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void SetAvkonHighlightAnimationEnabledL( const TBool aEnabled ); +[Test] +title TestUSetAvkonHighlightAnimationEnabledL +create testsdkskins test +bringtoforeground +test TestUSetAvkonHighlightAnimationEnabledL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static TBool AvkonHighlightAnimationEnabled(); +[Test] +title TestUAvkonHighlightAnimationEnabledL +create testsdkskins test +bringtoforeground +test TestUAvkonHighlightAnimationEnabledL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void RegisterControlPosition( +// const CCoeControl* aControl ); +[Test] +title TestURegisterControlPositionL +create testsdkskins test +bringtoforeground +test TestURegisterControlPositionL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void RegisterControlPosition( +// const CCoeControl* aControl, const TPoint& aPoint ); +[Test] +title TestURegisterControlPositionPL +create testsdkskins test +bringtoforeground +test TestURegisterControlPositionPL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static void DeregisterControlPosition( +// const CCoeControl* aControl ); +[Test] +title TestUDeregisterControlPositionL +create testsdkskins test +bringtoforeground +test TestUDeregisterControlPositionL +delete test +sendtobackground +[Endtest] + +// For test function: +// IMPORT_C static TInt GetControlPosition( const CCoeControl* aControl, +// TPoint& aScreenPos ); +[Test] +title TestUGetControlPositionL +create testsdkskins test +bringtoforeground +test TestUGetControlPositionL +delete test +sendtobackground +[Endtest] + diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/eabi/testsdkskinsu.def --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/eabi/testsdkskinsu.def Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,7 @@ +EXPORTS + _Z9LibEntryLR13CTestModuleIf @ 1 NONAME + _ZTI20CTestSDKSkinsControl @ 2 NONAME ; ## + _ZTI27CTestSDKSkinsObjectProvider @ 3 NONAME ; ## + _ZTV20CTestSDKSkinsControl @ 4 NONAME ; ## + _ZTV27CTestSDKSkinsObjectProvider @ 5 NONAME ; ## + diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/group/bld.inf --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/group/bld.inf Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,41 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: test AknsBasicBackgroundControlContext.h AknsControlContext.h +* AknsDataContext.h AknsDrawUtils.h AknsItemData.h +* AknsFrameBackgroundControlContext.h AknsItemID.h +* AknsLayeredBackgroundControlContext.h +* AknsListBoxBackgroundControlContext.h +* AknsRlEffectContext.h AknsRlParameter.h +* AknsSkinInstance.h AknsUtils.h AknsWallpaperUtils.h +* +*/ + + + +PRJ_PLATFORMS +DEFAULT + +PRJ_TESTEXPORTS +../conf/smoketest_uiresources.cfg c:/smoketest/smoketest_uiresources.cfg +../conf/ui_testsdkskinsu.cfg c:/smoketest/ui_testsdkskinsu.cfg + +PRJ_EXPORTS + + +PRJ_TESTMMPFILES +testsdkskins.mmp + +PRJ_MMPFILES + +// End of File diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/group/testsdkskins.mmp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/group/testsdkskins.mmp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,86 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: test AknsBasicBackgroundControlContext.h AknsControlContext.h +* AknsDataContext.h AknsDrawUtils.h AknsItemData.h +* AknsFrameBackgroundControlContext.h AknsItemID.h +* AknsLayeredBackgroundControlContext.h +* AknsListBoxBackgroundControlContext.h +* AknsRlEffectContext.h AknsRlParameter.h +* AknsSkinInstance.h AknsUtils.h AknsWallpaperUtils.h +* +*/ + + +#include +#ifdef SBSV2 + #include +#else // SBSV2 not defined + #include +#endif // SBSV2 + +TARGET testsdkskins.dll +TARGETTYPE dll +UID 0x1000008D 0x2001CB80 + +CAPABILITY ALL -TCB + +DEFFILE testsdkskins.def + +#ifdef SBSV2 + USERINCLUDE ../inc + + MW_LAYER_SYSTEMINCLUDE + + SOURCEPATH ../src +#else // SBSV2 not defined +USERINCLUDE ../inc + +MW_LAYER_SYSTEMINCLUDE + +SOURCEPATH ../src +#endif // SBSV2 + +SOURCE testsdkskins.cpp +SOURCE testsdkskinsblocks.cpp +SOURCE testsdkskinsblocksbbcc.cpp +SOURCE testsdkskinsblockscc.cpp +SOURCE testsdkskinsblocksdc.cpp +SOURCE testsdkskinsblocksdu.cpp +SOURCE testsdkskinsobjectprovider.cpp +SOURCE testsdkskinscontrol.cpp +SOURCE testsdkskinsblocksfbcc.cpp +SOURCE testsdkskinsblocksid.cpp +SOURCE testsdkskinsblocksii.cpp +SOURCE testsdkskinsblockslbcc.cpp +SOURCE testsdkskinsblockslbbcc.cpp +SOURCE testsdkskinsblockswu.cpp +SOURCE testsdkskinsblocksu.cpp + +LIBRARY euser.lib +LIBRARY cone.lib +LIBRARY stiftestinterface.lib +LIBRARY stiftestengine.lib +LIBRARY aknskins.lib +LIBRARY aknskinsrv.lib +LIBRARY aknswallpaperutils.lib +LIBRARY eikcore.lib +LIBRARY fbscli.lib +LIBRARY bafl.lib +LIBRARY eikdlg.lib +LIBRARY apgrfx.lib +LIBRARY efsrv.lib + +LANG SC + +// End of File diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/inc/testsdkskins.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/inc/testsdkskins.h Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,1362 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: test AknsBasicBackgroundControlContext.h AknsControlContext.h +* AknsDataContext.h AknsDrawUtils.h AknsItemData.h +* AknsFrameBackgroundControlContext.h AknsItemID.h +* AknsLayeredBackgroundControlContext.h +* AknsListBoxBackgroundControlContext.h +* AknsRlEffectContext.h AknsRlParameter.h +* AknsSkinInstance.h AknsUtils.h AknsWallpaperUtils.h +* +*/ + + + +#ifndef C_TESTSDKSKINS_H +#define C_TESTSDKSKINS_H + +// INCLUDES +#include +#include +#include +#include + +// MACROS +#define TEST_CLASS_VERSION_MAJOR 0 +#define TEST_CLASS_VERSION_MINOR 0 +#define TEST_CLASS_VERSION_BUILD 0 + +// Logging path +_LIT( KtestsdkskinsLogPath, "\\logs\\testframework\\testsdkskins\\" ); +// Log file +_LIT( KtestsdkskinsLogFile, "testsdkskins.txt" ); +_LIT( KtestsdkskinsLogFileWithTitle, "testsdkskins_[%S].txt" ); + +/** +* CTestSDKSkins test class for STIF Test Framework TestScripter. +* @since S60 5.0 +*/ +NONSHARABLE_CLASS( CTestSDKSkins ) : public CScriptBase + { +public: // Constructors and destructor + + /** + * Two-phased constructor. + */ + static CTestSDKSkins* NewL( CTestModuleIf& aTestModuleIf ); + + /** + * Destructor. + */ + virtual ~CTestSDKSkins(); + +public: // Functions from base classes + + /** + * From CScriptBase Runs a script line. + * @since S60 5.0 + * @param aItem Script line containing method name and parameters + * @return Symbian OS error code + */ + virtual TInt RunMethodL( CStifItemParser& aItem ); + +private: + + /** + * C++ default constructor. + */ + CTestSDKSkins( CTestModuleIf& aTestModuleIf ); + + /** + * By default Symbian 2nd phase constructor is private. + */ + void ConstructL(); + + /** + * Method used to log version of test class + */ + void SendTestClassVersion(); + + /** + * Turn off ScreenSaver + * @since S60 5.0 + * @return Symbian OS error code. + */ + void TurnOffScreenSaver(); + + /** + * Restore ScreenSaver + * @since S60 5.0 + * @return Symbian OS error code. + */ + void RestoreScreenSaver(); + +private: // Test AknsBasicBackgroundControlContext.h +/* class CAknsBasicBackgroundControlContext */ + /** + * TestBBCCNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBBCCNewL( CStifItemParser& aItem ); + + /** + * TestBBCCSetBitmapL test function for testing the + * SetBitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBBCCSetBitmapL( CStifItemParser& aItem ); + + /** + * TestBBCCSetRectL test function for testing the + * SetRect function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBBCCSetRectL( CStifItemParser& aItem ); + + /** + * TestBBCCSetParentPosL test function for testing the + * SetParentPos function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBBCCSetParentPosL( CStifItemParser& aItem ); + + /** + * TestBBCCSetParentContextL test function for testing the + * SetParentContext function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBBCCSetParentContextL( CStifItemParser& aItem ); + +private: // Test AknsControlContext.h +/* class MAknsControlContext */ + /** + * TestCCSupplyMopObjectL test function for testing the + * SupplyMopObject function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestCCSupplyMopObjectL( CStifItemParser& aItem ); + +private: // Test AknsDataContext.h +/* class MAknsDataContext */ + /** + * TestDCSupplyMopObjectL test function for testing the + * SupplyMopObject function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDCSupplyMopObjectL( CStifItemParser& aItem ); + +private: // Test AknsDrawUtils.h +/* class AknsDrawUtils */ + /** + * TestDUControlContextL test function for testing the + * ControlContext function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUControlContextL( CStifItemParser& aItem ); + + /** + * TestDUControlContextOfParentL test function for testing the + * ControlContextOfParent function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUControlContextOfParentL( CStifItemParser& aItem ); + + /** + * TestDUBackgroundL test function for testing the + * Background function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUBackgroundL( CStifItemParser& aItem ); + + /** + * TestDUBackgroundFPL test function for testing the + * Background function with five parameters + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUBackgroundFPL( CStifItemParser& aItem ); + + /** + * TestDUBackgroundSPL test function for testing the + * Background function with six parameters + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUBackgroundSPL( CStifItemParser& aItem ); + + /** + * TestDUDrawBackgroundL test function for testing the + * DrawBackground function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUDrawBackgroundL( CStifItemParser& aItem ); + + /** + * TestDUBackgroundBetweenRectsFPL test function for testing the + * BackgroundBetweenRects function with five parameters + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUBackgroundBetweenRectsFPL( CStifItemParser& aItem ); + + /** + * TestDUBackgroundBetweenRectsL test function for testing the + * BackgroundBetweenRects function with six parameters + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUBackgroundBetweenRectsL( CStifItemParser& aItem ); + + /** + * TestDUBackgroundBetweenRectsSPL test function for testing the + * BackgroundBetweenRects function with seven parameters + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUBackgroundBetweenRectsSPL( CStifItemParser& aItem ); + + /** + * TestDUHasBitmapBackgroundL test function for testing the + * HasBitmapBackground function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUHasBitmapBackgroundL( CStifItemParser& aItem ); + + /** + * TestDUDrawCachedImageL test function for testing the + * DrawCachedImage function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUDrawCachedImageL( CStifItemParser& aItem ); + + /** + * TestDUDrawCachedImageFBSL test function for testing the + * ControlContext function with fbsbitgc + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUDrawCachedImageFBSL( CStifItemParser& aItem ); + + /** + * TestDUDrawFrameL test function for testing the + * DrawFrame function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUDrawFrameL( CStifItemParser& aItem ); + + /** + * TestDUPrepareFrameL test function for testing the + * PrepareFrame function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUPrepareFrameL( CStifItemParser& aItem ); + + /** + * TestDUDrawFrameSPL test function for testing the + * DrawFrame function with seven parameters + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUDrawFrameSPL( CStifItemParser& aItem ); + + /** + * TestDUDrawFrameFBSL test function for testing the + * DrawFrame function with fbsbitgc + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUDrawFrameFBSL( CStifItemParser& aItem ); + + /** + * TestDUDrawFramePartL test function for testing the + * DrawFramePart function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUDrawFramePartL( CStifItemParser& aItem ); + + /** + * TestDUIsListSeperatorLines test function for testing the + * IsListSeperatorLines function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUIsListSeperatorLines( CStifItemParser& aItem ); + + /** + * TestDUSlidingMode test function for testing the + * SlidingMode function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestDUSlidingMode( CStifItemParser& aItem ); + +private: // Test AknsDrawUtils.h +/* class AknsDrawUtils */ + /** + * TestFBCCNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestFBCCNewL( CStifItemParser& aItem ); + + /** + * TestFBCCSetFrameL test function for testing the + * SetFrame function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestFBCCSetFrameL( CStifItemParser& aItem ); + + /** + * TestFBCCSetFrameRectsL test function for testing the + * SetFrameRects function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestFBCCSetFrameRectsL( CStifItemParser& aItem ); + + /** + * TestFBCCSetCenterL test function for testing the + * SetCenter function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestFBCCSetCenterL( CStifItemParser& aItem ); + + /** + * TestFBCCSetFramePartRectL test function for testing the + * SetFramePartRect function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestFBCCSetFramePartRectL( CStifItemParser& aItem ); + +private: // Test AknsItemData.h +/* class CAknsItemData */ + /** + * TestIDTypeL test function for testing the + * Type function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIDTypeL( CStifItemParser& aItem ); + +/* class CAknsImageItemData */ + /** + * TestIIDSetAttributesL test function for testing the + * SetAttributesL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIIDSetAttributesL( CStifItemParser& aItem ); + + /** + * TestIIDAttributesL test function for testing the + * Attributes function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIIDAttributesL( CStifItemParser& aItem ); + + /** + * TestIIDSetParentIIDL test function for testing the + * SetParentIID function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIIDSetParentIIDL( CStifItemParser& aItem ); + + /** + * TestIIDSetDrawRectL test function for testing the + * SetDrawRect function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIIDSetDrawRectL( CStifItemParser& aItem ); + + /** + * TestIIDParentIIDL test function for testing the + * ParentIID function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIIDParentIIDL( CStifItemParser& aItem ); + + /** + * TestIIDDrawRectL test function for testing the + * DrawRect function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIIDDrawRectL( CStifItemParser& aItem ); + +private://AknsItemData.h +/* class CAknsBitmapItemData */ + /** + * TestBIDNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBIDNewL( CStifItemParser& aItem ); + + /** + * TestBIDSetBitmapL test function for testing the + * SetBitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBIDSetBitmapL( CStifItemParser& aItem ); + + /** + * TestBIDDestroyAndSetBitmapL test function for testing the + * DestroyAndSetBitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBIDDestroyAndSetBitmapL( CStifItemParser& aItem ); + + /** + * TestBIDBitmapL test function for testing the + * Bitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBIDBitmapL( CStifItemParser& aItem ); + +/* class CAknsMaskedBitmapItemData */ + /** + * TestMBIDNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestMBIDNewL( CStifItemParser& aItem ); + + /** + * TestMBIDSetMaskL test function for testing the + * SetMask function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestMBIDSetMaskL( CStifItemParser& aItem ); + + /** + * TestMBIDDestroyAndSetMaskL test function for testing the + * DestroyAndSetMask function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestMBIDDestroyAndSetMaskL( CStifItemParser& aItem ); + + /** + * TestMBIDMaskL test function for testing the + * Mask function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestMBIDMaskL( CStifItemParser& aItem ); + +/* class CAknsColorTableItemData */ + /** + * TestCTIDNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestCTIDNewL( CStifItemParser& aItem ); + + /** + * TestCTIDSetColorsL test function for testing the + * SetColorsL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestCTIDSetColorsL( CStifItemParser& aItem ); + + /** + * TestCTIDColorIndexedL test function for testing the + * ColorIndexed function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestCTIDColorIndexedL( CStifItemParser& aItem ); + + /** + * TestCTIDColorRgbL test function for testing the + * ColorRgb function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestCTIDColorRgbL( CStifItemParser& aItem ); + + /** + * TestCTIDGetColorL test function for testing the + * GetColorL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestCTIDGetColorL( CStifItemParser& aItem ); + +/* class CAknsImageTableItemData */ + /** + * TestITIDNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestITIDNewL( CStifItemParser& aItem ); + + /** + * TestITIDSetImagesL test function for testing the + * SetImagesL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestITIDSetImagesL( CStifItemParser& aItem ); + + /** + * TestITIDImageIIDL test function for testing the + * ImageIID function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestITIDImageIIDL( CStifItemParser& aItem ); + + /** + * TestITIDImagesL test function for testing the + * Images function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestITIDImagesL( CStifItemParser& aItem ); + + /** + * TestITIDNumberOfImagesL test function for testing the + * NumberOfImages function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestITIDNumberOfImagesL( CStifItemParser& aItem ); + +/* class CAknsBmpAnimItemData */ + /** + * TestBAIDNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDNewL( CStifItemParser& aItem ); + + /** + * TestBAIDSetFrameInfosL test function for testing the + * SetFrameInfosL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDSetFrameInfosL( CStifItemParser& aItem ); + + /** + * TestBAIDFrameInfosL test function for testing the + * FrameInfos function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDFrameInfosL( CStifItemParser& aItem ); + + /** + * TestBAIDSetLastFrameBackgroundL test function for testing the + * SetLastFrameBackground function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDSetLastFrameBackgroundL( CStifItemParser& aItem ); + + /** + * TestBAIDLastFrameBackgroundL test function for testing the + * LastFrameBackground function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDLastFrameBackgroundL( CStifItemParser& aItem ); + + /** + * TestBAIDSetFrameIntervalL test function for testing the + * SetFrameInterval function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDSetFrameIntervalL( CStifItemParser& aItem ); + + /** + * TestBAIDFrameIntervalL test function for testing the + * FrameInterval function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDFrameIntervalL( CStifItemParser& aItem ); + + /** + * TestBAIDSetPlayModeL test function for testing the + * SetPlayMode function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDSetPlayModeL( CStifItemParser& aItem ); + + /** + * TestBAIDPlayModeL test function for testing the + * PlayMode function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDPlayModeL( CStifItemParser& aItem ); + + /** + * TestBAIDSetFlashL test function for testing the + * SetFlash function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDSetFlashL( CStifItemParser& aItem ); + + /** + * TestBAIDFlashL test function for testing the + * Flash function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestBAIDFlashL( CStifItemParser& aItem ); + +/* class CAknsStringItemData */ + /** + * TestSIDNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestSIDNewL( CStifItemParser& aItem ); + + /** + * TestSIDSetStringL test function for testing the + * SetStringL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestSIDSetStringL( CStifItemParser& aItem ); + + /** + * TestSIDStringL test function for testing the + * String function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestSIDStringL( CStifItemParser& aItem ); + +/* class CAknsEffectCommand */ + /** + * TestECNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestECNewL( CStifItemParser& aItem ); + + /** + * TestECSetEffectUidL test function for testing the + * SetEffectUid function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestECSetEffectUidL( CStifItemParser& aItem ); + + /** + * TestECEffectUidL test function for testing the + * EffectUid function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestECEffectUidL( CStifItemParser& aItem ); + + /** + * TestECSetLayerConfL test function for testing the + * SetLayerConf function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestECSetLayerConfL( CStifItemParser& aItem ); + + /** + * TestECLayerConfL test function for testing the + * LayerConf function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestECLayerConfL( CStifItemParser& aItem ); + + /** + * TestECAppendParameterL test function for testing the + * AppendParameterL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestECAppendParameterL( CStifItemParser& aItem ); + + /** + * TestECCreateParameterIteratorL test function for testing the + * CreateParameterIteratorL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestECCreateParameterIteratorL( CStifItemParser& aItem ); + +/* class CAknsEffectQueueItemData */ + /** + * TestEQIDNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDNewL( CStifItemParser& aItem ); + + /** + * TestEQIDSetRefItemL test function for testing the + * SetRefItem function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDSetRefItemL( CStifItemParser& aItem ); + + /** + * TestEQIDRefItemL test function for testing the + * RefItem function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDRefItemL( CStifItemParser& aItem ); + + /** + * TestEQIDSetInputLayerL test function for testing the + * SetInputLayer function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDSetInputLayerL( CStifItemParser& aItem ); + + /** + * TestEQIDInputLayerL test function for testing the + * InputLayer function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDInputLayerL( CStifItemParser& aItem ); + + /** + * TestEQIDSetInputLayerModeL test function for testing the + * SetInputLayerMode function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDSetInputLayerModeL( CStifItemParser& aItem ); + + /** + * TestEQIDInputLayerModeL test function for testing the + * InputLayerMode function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDInputLayerModeL( CStifItemParser& aItem ); + + /** + * TestEQIDSetOutputLayerL test function for testing the + * SetOutputLayer function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDSetOutputLayerL( CStifItemParser& aItem ); + + /** + * TestEQIDOutputLayerL test function for testing the + * OutputLayer function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDOutputLayerL( CStifItemParser& aItem ); + + /** + * TestEQIDSetOutputLayerModeL test function for testing the + * SetOutputLayerMode function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDSetOutputLayerModeL( CStifItemParser& aItem ); + + /** + * TestEQIDOutputLayerModeL test function for testing the + * OutputLayerMode function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDOutputLayerModeL( CStifItemParser& aItem ); + + /** + * TestEQIDAppendCommandL test function for testing the + * AppendCommandL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDAppendCommandL( CStifItemParser& aItem ); + + /** + * TestEQIDCreateCommandIteratorL test function for testing the + * CreateCommandIteratorL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestEQIDCreateCommandIteratorL( CStifItemParser& aItem ); + +private://AknsItemID.h +/* class TAknsItemID */ + /** + * TestIILinearOrder test function for testing the + * LinearOrder function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestIILinearOrder( CStifItemParser& aItem ); + +private://AknsLayeredBackgroundControlContext.h +/* class CAknsLayeredBackgroundControlContext */ + /** + * TestLBCCNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBCCNewL( CStifItemParser& aItem ); + + /** + * TestLBCCSetLayerImageL test function for testing the + * SetLayerImage function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBCCSetLayerImageL( CStifItemParser& aItem ); + + /** + * TestLBCCSetLayerRectL test function for testing the + * SetLayerRect function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBCCSetLayerRectL( CStifItemParser& aItem ); + +private://AknsListBoxBackgroundControlContext.h +/* class CAknsListBoxBackgroundControlContext */ + /** + * TestLBBCCNewL test function for testing the + * NewL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBBCCNewL( CStifItemParser& aItem ); + + /** + * TestLBBCCSetTiledBitmapL test function for testing the + * SetTiledBitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBBCCSetTiledBitmapL( CStifItemParser& aItem ); + + /** + * TestLBBCCSetTiledRectL test function for testing the + * SetTiledRect function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBBCCSetTiledRectL( CStifItemParser& aItem ); + + /** + * TestLBBCCSetBottomBitmapL test function for testing the + * SetBottomBitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBBCCSetBottomBitmapL( CStifItemParser& aItem ); + + /** + * TestLBBCCSetBottomRectL test function for testing the + * SetBottomRect function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestLBBCCSetBottomRectL( CStifItemParser& aItem ); + +private://AknsWallpaperUtils.h +/* class AknsWallpaperUtils */ + /** + * TestWUSetIdleWallpaper test function for testing the + * SetIdleWallpaper function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestWUSetIdleWallpaper( CStifItemParser& aItem ); + + /** + * TestWUSetSlidesetWallpaperL test function for testing the + * SetSlidesetWallpaper function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestWUSetSlidesetWallpaperL( CStifItemParser& aItem ); + +private://AknsUtils.h +/* class AknsUtils */ + /** + * TestUInitSkinSupportL test function for testing the + * InitSkinSupportL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUInitSkinSupportL( CStifItemParser& aItem ); + + /** + * TestUCreateDataContextForContainerL test function for testing the + * CreateDataContextForContainerL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateDataContextForContainerL( CStifItemParser& aItem ); + + /** + * TestUCreateBitmapItemDefL test function for testing the + * CreateBitmapItemDefL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateBitmapItemDefL( CStifItemParser& aItem ); + + /** + * TestUCreateMaskedBitmapItemDefL test function for testing the + * CreateMaskedBitmapItemDefL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateMaskedBitmapItemDefL( CStifItemParser& aItem ); + + /** + * TestUSkinInstanceL test function for testing the + * SkinInstance function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUSkinInstanceL( CStifItemParser& aItem ); + + /** + * TestUDataContextL test function for testing the + * DataContext function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUDataContextL( CStifItemParser& aItem ); + + /** + * TestUCreateIconML test function for testing the + * CreateIconL function with mask + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateIconML( CStifItemParser& aItem ); + + /** + * TestUCreateIconMLC test function for testing the + * CreateIconLC function with mask + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateIconMLC( CStifItemParser& aItem ); + + /** + * TestUCreateIconL test function for testing the + * CreateIconL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateIconL( CStifItemParser& aItem ); + + /** + * TestUCreateIconLC test function for testing the + * CreateIconLC function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateIconLC( CStifItemParser& aItem ); + + /** + * TestUCreateMaskedBitmapL test function for testing the + * CreateMaskedBitmapL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateMaskedBitmapL( CStifItemParser& aItem ); + + /** + * TestUCreateGulIconL test function for testing the + * CreateGulIconL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateGulIconL( CStifItemParser& aItem ); + + /** + * TestUCreateAppIconLC test function for testing the + * CreateAppIconLC function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateAppIconLC( CStifItemParser& aItem ); + + /** + * TestUOpenAppIconFileL test function for testing the + * OpenAppIconFile function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUOpenAppIconFileL( CStifItemParser& aItem ); + + /** + * TestUCreateColorIconL test function for testing the + * CreateColorIconL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateColorIconL( CStifItemParser& aItem ); + + /** + * TestUCreateColorIconLC test function for testing the + * CreateColorIconLC function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateColorIconLC( CStifItemParser& aItem ); + + /** + * TestUCreateColorIconML test function for testing the + * InitSkinSupportL function with mode + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateColorIconML( CStifItemParser& aItem ); + + /** + * TestUCreateColorIconMLC test function for testing the + * CreateColorIconLC function with mode + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateColorIconMLC( CStifItemParser& aItem ); + + /** + * TestUGetAppIconL test function for testing the + * GetAppIcon function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUGetAppIconL( CStifItemParser& aItem ); + + /** + * TestUCreateBitmapL test function for testing the + * CreateBitmapL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateBitmapL( CStifItemParser& aItem ); + + /** + * TestUCreateMaskedBitmapIL test function for testing the + * CreateMaskedBitmapL function with instance + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateMaskedBitmapIL( CStifItemParser& aItem ); + + /** + * TestUCreateGulIconIL test function for testing the + * CreateGulIconL function with instance + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUCreateGulIconIL( CStifItemParser& aItem ); + + /** + * TestUGetCachedBitmapL test function for testing the + * GetCachedBitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUGetCachedBitmapL( CStifItemParser& aItem ); + + /** + * TestUGetCachedMaskedBitmapL test function for testing the + * GetCachedMaskedBitmap function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUGetCachedMaskedBitmapL( CStifItemParser& aItem ); + + /** + * TestUGetCachedColorL test function for testing the + * GetCachedColor function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUGetCachedColorL( CStifItemParser& aItem ); + + /** + * TestUBooleanPropertyL test function for testing the + * BooleanPropertyL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUBooleanPropertyL( CStifItemParser& aItem ); + + /** + * TestUSetAvkonSkinEnabledL test function for testing the + * SetAvkonSkinEnabledL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUSetAvkonSkinEnabledL( CStifItemParser& aItem ); + + /** + * TestUAvkonSkinEnabledL test function for testing the + * AvkonSkinEnabled function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUAvkonSkinEnabledL( CStifItemParser& aItem ); + + /** + * TestUSetAvkonHighlightAnimationEnabledL test function for testing the + * SetAvkonHighlightAnimationEnabledL function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUSetAvkonHighlightAnimationEnabledL( CStifItemParser& aItem ); + + /** + * TestUAvkonHighlightAnimationEnabledL test function for testing the + * AvkonHighlightAnimationEnabled function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUAvkonHighlightAnimationEnabledL( CStifItemParser& aItem ); + + /** + * TestURegisterControlPositionL test function for testing the + * RegisterControlPosition function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestURegisterControlPositionL( CStifItemParser& aItem ); + + /** + * TestURegisterControlPositionPL test function for testing the + * RegisterControlPosition function with point + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestURegisterControlPositionPL( CStifItemParser& aItem ); + + /** + * TestUDeregisterControlPositionL test function for testing the + * DeregisterControlPosition function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUDeregisterControlPositionL( CStifItemParser& aItem ); + + /** + * TestUGetControlPositionL test function for testing the + * GetControlPosition function + * @since S60 5.0 + * @param aItem never used + * @return Symbian OS error code. + */ + virtual TInt TestUGetControlPositionL( CStifItemParser& aItem ); +private: // Data + + /** + * ScreenSaver Property + */ + TInt iOldScreenSaverProperty; + + }; + +#endif // C_TESTSDKSKINS_H + +// End of File diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/inc/testsdkskinscontrol.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/inc/testsdkskinscontrol.h Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,94 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsDrawUtils.h +* +*/ + +#ifndef C_TESTSDKSKINSCONTROL_H +#define C_TESTSDKSKINSCONTROL_H + +// INCLUDES + +#include +#include +#include + + /** + * CTestSDKNotesNoteDialog test class for CAknNoteDialog protected API. + */ +class CTestSDKSkinsControl : public CCoeControl + { +public: + /** + * Two-phased constructor. + */ + static CTestSDKSkinsControl* NewL(); + + /** + * Destructor. + */ + ~CTestSDKSkinsControl(); + + /** + * fuction ActivateGc for test ActivateGc + */ + void ActivateGc(); + + /** + * fuction DeActivateGc for test DeActivateGc + */ + void DeactivateGc(); + +private: + + /** + * Constructor. + */ + CTestSDKSkinsControl(); + + /** + * By default Symbian 2nd phase constructor is private. + */ + void ConstructL(); + + /** + * Receive key events. + */ + TKeyResponse OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType); + + /** + * Draw control. + */ + void Draw(const TRect& aRect) const; + + /** + * Return number of controls in its window. + */ + TInt CountComponentControls() const; + + /** + * Controls in its window. + */ + CCoeControl* ComponentControl(TInt aIndex) const; + + /** + * Resize screen. + */ + void SizeChanged(); + + + }; + + +#endif /*C_TESTSDKSKINSCONTROL_H*/ diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/inc/testsdkskinsobjectprovider.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/inc/testsdkskinsobjectprovider.h Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,39 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsDrawUtils.h +* +*/ + +#ifndef C_TESTSDKSKINSOBJECTPROVIDER_H +#define C_TESTSDKSKINSOBJECTPROVIDER_H + +// INCLUDES + +#include + + /** + * CTestSDKNotesNoteDialog test class for CAknNoteDialog protected API. + */ +class CTestSDKSkinsObjectProvider : public CBase, + public MObjectProvider + { +public: + /** + * function MopSupplyObject from MObjectProvider + */ + TTypeUid::Ptr MopSupplyObject( TTypeUid aId ); + + }; + +#endif /*C_TESTSDKSKINSOBJECTPROVIDER_H*/ diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/init/testsdkskins.ini --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/init/testsdkskins.ini Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,201 @@ +# +# This is STIFTestFramework initialization file +# Comment lines start with '#'-character. +# See STIF TestFramework users guide.doc for instructions + +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- +# Set following test engine settings: +# - Set Test Reporting mode. TestReportMode's possible values are: +# + 'Summary': Summary of the tested test cases. +# + 'Environment': Hardware and software info. +# + 'TestCases': Test case report. +# + 'FullReport': Set of all above ones. +# + Example 'TestReportMode= Summary TestCases' +# +# - CreateTestReport setting controls report creation mode +# + YES, Test report will created. +# + NO, No Test report. +# +# - File path indicates the base path of the test report. +# - File name indicates the name of the test report. +# +# - File format indicates the type of the test report. +# + TXT, Test report file will be txt type, for example 'TestReport.txt'. +# + HTML, Test report will be html type, for example 'TestReport.html'. +# +# - File output indicates output source of the test report. +# + FILE, Test report logging to file. +# + RDEBUG, Test report logging to using rdebug. +# +# - File Creation Mode indicates test report overwriting if file exist. +# + OVERWRITE, Overwrites if the Test report file exist. +# + APPEND, Continue logging after the old Test report information if +# report exist. + +[Engine_Defaults] + +TestReportMode= FullReport # Possible values are: + # 'Summary', 'Environment', 'TestCases' or 'FullReport' + +CreateTestReport= YES # Possible values: YES or NO + +TestReportFilePath= C:\LOGS\TestFramework\ +TestReportFileName= TestReport + +TestReportFormat= TXT # Possible values: TXT or HTML +TestReportOutput= FILE # Possible values: FILE or RDEBUG +TestReportFileCreationMode= OVERWRITE # Possible values: OVERWRITE or APPEND +UITestingSupport= Yes +SeparateProcesses= YES +[End_Defaults] +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + + + +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- +# Module configurations start +# Modules are added between module tags +# tags. Module name is specified after ModuleName= tag, like +# ModuleName= testsdkskinstestsdkskinstestsdkskins +# Modules might have initialisation file, specified as +# IniFile= YYYYYY +# Modules might have several configuration files, like +# TestCaseFile= NormalCases.txt +# TestCaseFile= SmokeCases.txt +# TestCaseFile= ManualCases.txt + +# (TestCaseFile is synonym for old term ConfigFile) + +# Following case specifies demo module settings. Demo module +# does not read any settings from file, so tags +# IniFile and TestCaseFile are not used. +# In the simplest case it is enough to specify only the +# name of the test module when adding new test module + +[New_Module] +ModuleName= testcombiner +TestCaseFile= c:\testframework\tctestsdkskinsbbcc.cfg +TestCaseFile= c:\testframework\tctestsdkskinscc.cfg +TestCaseFile= c:\testframework\tctestsdkskinsdc.cfg +TestCaseFile= c:\testframework\tctestsdkskinsdu.cfg +TestCaseFile= c:\testframework\tctestsdkskinsfbcc.cfg +TestCaseFile= c:\testframework\tctestsdkskinsid.cfg +TestCaseFile= c:\testframework\tctestsdkskinsii.cfg +TestCaseFile= c:\testframework\tctestsdkskinslbbcc.cfg +TestCaseFile= c:\testframework\tctestsdkskinslbcc.cfg +TestCaseFile= c:\testframework\tctestsdkskinswu.cfg +TestCaseFile= c:\testframework\tctestsdkskinsu.cfg +[End_Module] + +#[New_Module] +#ModuleName= testscripter +#TestCaseFile= c:\testframework\ui_testsdkskinsbbcc.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinscc.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinsdc.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinsdu.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinsfbcc.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinsid.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinsii.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinslbbcc.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinslbcc.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinswu.cfg +#TestCaseFile= c:\testframework\ui_testsdkskinsu.cfg +#[End_Module] + +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + +#Load testmoduletestsdkskins, optionally with initialization file and/or test case files +#[New_Module] +#ModuleName= testmodulexxx + +#TestModuletestsdkskins used initialization file +#IniFile= init.txt + +#TestModuletestsdkskins used configuration file(s) +#TestCaseFile= testcases1.cfg +#TestCaseFile= testcases2.cfg +#TestCaseFile= manualtestcases.cfg + +#[End_Module] +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + + + +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- +# Set STIFTestFramework logging overwrite parameters for Logger. +# Hardware and emulator environment logging path and styles can +# be configured from here to overwrite the Logger's implemented values. +# +# Settings description: +# - Indicates option for creation log directory/directories. If log directory/directories +# is/are not created by user they will make by software. +# + YES, Create log directory/directories if not allready exist. +# + NO, Log directory/directories not created. Only created one is used. +# +# - Overwrite emulator path setting. +# + Example: If 'EmulatorBasePath= C:\LOGS\TestFramework\' and in code is defined +# Logger's path 'D:\\LOGS\\Module\\' with those definition the path +# will be 'C:\LOGS\TestFramework\LOGS\Module\' +# +# - Overwrite emulator's logging format. +# + TXT, Log file(s) will be txt type(s), for example 'Module.txt'. +# + HTML, Log file(s) will be html type(s), for example 'Module.html'. +# +# - Overwrited emulator logging output source. +# + FILE, Logging to file(s). +# + RDEBUG, Logging to using rdebug(s). +# +# - Overwrite hardware path setting (Same description as above in emulator path). +# - Overwrite hardware's logging format(Same description as above in emulator format). +# - Overwrite hardware's logging output source(Same description as above in emulator output). +# +# - File Creation Mode indicates file overwriting if file exist. +# + OVERWRITE, Overwrites if file(s) exist. +# + APPEND, Continue logging after the old logging information if file(s) exist. +# +# - Will thread id include to the log filename. +# + YES, Thread id to log file(s) name, Example filename 'Module_b9.txt'. +# + NO, No thread id to log file(s), Example filename 'Module.txt'. +# +# - Will time stamps include the to log file. +# + YES, Time stamp added to each line in log file(s). Time stamp is +# for example'12.Nov.2003 115958 LOGGING INFO' +# + NO, No time stamp(s). +# +# - Will line breaks include to the log file. +# + YES, Each logging event includes line break and next log event is in own line. +# + NO, No line break(s). +# +# - Will event ranking include to the log file. +# + YES, Event ranking number added to each line in log file(s). Ranking number +# depends on environment's tics, for example(includes time stamp also) +# '012 12.Nov.2003 115958 LOGGING INFO' +# + NO, No event ranking. +# + +[Logger_Defaults] + +#NOTE: If you want to set Logger using next setting(s) remove comment(s)'#' + +CreateLogDirectories= YES # Possible values: YES or NO + +EmulatorBasePath= C:\LOGS\TestFramework\ +EmulatorFormat= HTML # Possible values: TXT or HTML +EmulatorOutput= FILE # Possible values: FILE or RDEBUG + +#HardwareBasePath= D:\LOGS\TestFramework\ +#HardwareFormat= HTML # Possible values: TXT or HTML +#HardwareOutput= FILE # Possible values: FILE or RDEBUG + +FileCreationMode= OVERWRITE # Possible values: OVERWRITE or APPEND + +#ThreadIdToLogFile= YES # Possible values: YES or NO +#WithTimeStamp= YES # Possible values: YES or NO +#WithLineBreak= YES # Possible values: YES or NO +#WithEventRanking= YES # Possible values: YES or NO + +[End_Logger_Defaults] +# -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- -- + +# End of file diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskins.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskins.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,190 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: test AknsBasicBackgroundControlContext.h AknsControlContext.h +* AknsDataContext.h AknsDrawUtils.h AknsItemData.h +* AknsFrameBackgroundControlContext.h AknsItemID.h +* AknsLayeredBackgroundControlContext.h +* AknsListBoxBackgroundControlContext.h +* AknsRlEffectContext.h AknsRlParameter.h +* AknsSkinInstance.h AknsUtils.h AknsWallpaperUtils.h +* +*/ + + + +// INCLUDE FILES +#include +#include +#include +#include + +#include "testsdkskins.h" + +// CONSTANTS +_LIT( KModuleName, "testsdkskins.dll" ); + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::CTestSDKSkins +// C++ default constructor can NOT contain any code, that +// might leave. +// ----------------------------------------------------------------------------- +// +CTestSDKSkins::CTestSDKSkins( CTestModuleIf& aTestModuleIf ): + CScriptBase( aTestModuleIf ) + { + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::~CTestSDKSkins +// Destructor. +// ----------------------------------------------------------------------------- +// +CTestSDKSkins::~CTestSDKSkins() + { + // Delete logger + delete iLog; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::ConstructL +// Symbian 2nd phase constructor can leave. +// ----------------------------------------------------------------------------- +// +void CTestSDKSkins::ConstructL() + { + //Read logger settings to check whether test case name is to be + //appended to log file name. + RSettingServer settingServer; + CleanupClosePushL( settingServer ); + TInt ret = settingServer.Connect(); + if ( ret != KErrNone ) + { + User::Leave(ret); + } + // Struct to StifLogger settigs. + TLoggerSettings loggerSettings; + // Parse StifLogger defaults from STIF initialization file. + ret = settingServer.GetLoggerSettings( loggerSettings ); + if ( ret != KErrNone ) + { + User::Leave( ret ); + } + // Close Setting server session + settingServer.Close(); + CleanupStack::PopAndDestroy( &settingServer ); + + TFileName logFileName; + + if ( loggerSettings.iAddTestCaseTitle ) + { + TName title; + TestModuleIf().GetTestCaseTitleL( title ); + logFileName.Format( KtestsdkskinsLogFileWithTitle, &title ); + } + else + { + logFileName.Copy( KtestsdkskinsLogFile ); + } + + iLog = CStifLogger::NewL( KtestsdkskinsLogPath, + logFileName, + CStifLogger::ETxt, + CStifLogger::EFile, + EFalse ); + + SendTestClassVersion(); + + TurnOffScreenSaver(); + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::NewL +// Two-phased constructor. +// ----------------------------------------------------------------------------- +// +CTestSDKSkins* CTestSDKSkins::NewL( CTestModuleIf& aTestModuleIf ) + { + CTestSDKSkins* self = new( ELeave ) CTestSDKSkins( aTestModuleIf ); + + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + + return self; + + } + +//----------------------------------------------------------------------------- +// CTestSDKSkins::SendTestClassVersion +// Method used to send version of test class +//----------------------------------------------------------------------------- +// +void CTestSDKSkins::SendTestClassVersion() + { + TVersion moduleVersion; + moduleVersion.iMajor = TEST_CLASS_VERSION_MAJOR; + moduleVersion.iMinor = TEST_CLASS_VERSION_MINOR; + moduleVersion.iBuild = TEST_CLASS_VERSION_BUILD; + + TFileName moduleName; + moduleName = KModuleName; + + TBool newVersionOfMethod = ETrue; + TestModuleIf().SendTestModuleVersion( moduleVersion, moduleName, + newVersionOfMethod ); + } + +// ========================== OTHER EXPORTED FUNCTIONS ========================= + +// ----------------------------------------------------------------------------- +// LibEntryL is a polymorphic Dll entry point. +// Returns: CScriptBase: New CScriptBase derived object +// ----------------------------------------------------------------------------- +// +EXPORT_C CScriptBase* LibEntryL( + CTestModuleIf& aTestModuleIf ) // Backpointer to STIF Test Framework + { + return ( CScriptBase* ) CTestSDKSkins::NewL( aTestModuleIf ); + } + +// ----------------------------------------------------------------------------- +// Turn off ScreenSaver +// ----------------------------------------------------------------------------- +// +void CTestSDKSkins::TurnOffScreenSaver() + { + TInt err1 = RProperty::Get( KPSUidScreenSaver, KScreenSaverAllowScreenSaver, + iOldScreenSaverProperty ); + TInt err2 = RProperty::Set( KPSUidScreenSaver, KScreenSaverAllowScreenSaver, + KScreenSaverAllowScreenSaver ); + RDebug::Printf( "screensaver property=%d err1=%d err2=%d\n", + iOldScreenSaverProperty, err1, err2 ); + } + +// ----------------------------------------------------------------------------- +// Restore ScreenSaver +// ----------------------------------------------------------------------------- +// +void CTestSDKSkins::RestoreScreenSaver() + { + RProperty::Set( KPSUidScreenSaver, KScreenSaverAllowScreenSaver, + iOldScreenSaverProperty ); + User::ResetInactivityTime(); + } + + +// End of File diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocks.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocks.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,201 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: test AknsBasicBackgroundControlContext.h AknsControlContext.h +* AknsDataContext.h AknsDrawUtils.h AknsItemData.h +* AknsFrameBackgroundControlContext.h AknsItemID.h +* AknsLayeredBackgroundControlContext.h +* AknsListBoxBackgroundControlContext.h +* AknsRlEffectContext.h AknsRlParameter.h +* AknsSkinInstance.h AknsUtils.h AknsWallpaperUtils.h +* +*/ + + + +// [INCLUDE FILES] +#include +#include +#include + +#include "testsdkskins.h" + +// ============================ MEMBER FUNCTIONS =============================== + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::RunMethodL +// Run specified method. Contains also table of test mothods and their names. +// ----------------------------------------------------------------------------- +// +TInt CTestSDKSkins::RunMethodL( CStifItemParser& aItem ) + { + + static TStifFunctionInfo const KFunctions[] = + { + ENTRY( "TestBBCCNewL", CTestSDKSkins::TestBBCCNewL ), + ENTRY( "TestBBCCSetBitmapL", CTestSDKSkins::TestBBCCSetBitmapL ), + ENTRY( "TestBBCCSetRectL", CTestSDKSkins::TestBBCCSetRectL ), + ENTRY( "TestBBCCSetParentPosL", CTestSDKSkins::TestBBCCSetParentPosL ), + ENTRY( "TestBBCCSetParentContextL", CTestSDKSkins::TestBBCCSetParentContextL ), + + ENTRY( "TestCCSupplyMopObjectL", CTestSDKSkins::TestCCSupplyMopObjectL ), + + ENTRY( "TestDCSupplyMopObjectL", CTestSDKSkins::TestDCSupplyMopObjectL ), + + ENTRY( "TestDUControlContextL", CTestSDKSkins::TestDUControlContextL ), + ENTRY( "TestDUControlContextOfParentL", CTestSDKSkins::TestDUControlContextOfParentL ), + ENTRY( "TestDUBackgroundL", CTestSDKSkins::TestDUBackgroundL ), + ENTRY( "TestDUBackgroundFPL", CTestSDKSkins::TestDUBackgroundFPL ), + ENTRY( "TestDUBackgroundSPL", CTestSDKSkins::TestDUBackgroundSPL ), + ENTRY( "TestDUDrawBackgroundL", CTestSDKSkins::TestDUDrawBackgroundL ), + ENTRY( "TestDUBackgroundBetweenRectsFPL", CTestSDKSkins::TestDUBackgroundBetweenRectsFPL ), + ENTRY( "TestDUBackgroundBetweenRectsL", CTestSDKSkins::TestDUBackgroundBetweenRectsL ), + ENTRY( "TestDUBackgroundBetweenRectsSPL", CTestSDKSkins::TestDUBackgroundBetweenRectsSPL ), + ENTRY( "TestDUHasBitmapBackgroundL", CTestSDKSkins::TestDUHasBitmapBackgroundL ), + ENTRY( "TestDUDrawCachedImageL", CTestSDKSkins::TestDUDrawCachedImageL ), + ENTRY( "TestDUDrawCachedImageFBSL", CTestSDKSkins::TestDUDrawCachedImageFBSL ), + ENTRY( "TestDUDrawFrameL", CTestSDKSkins::TestDUDrawFrameL ), + ENTRY( "TestDUPrepareFrameL", CTestSDKSkins::TestDUPrepareFrameL ), + ENTRY( "TestDUDrawFrameSPL", CTestSDKSkins::TestDUDrawFrameSPL ), + ENTRY( "TestDUDrawFrameFBSL", CTestSDKSkins::TestDUDrawFrameFBSL ), + ENTRY( "TestDUDrawFramePartL", CTestSDKSkins::TestDUDrawFramePartL ), + ENTRY( "TestDUIsListSeperatorLines", CTestSDKSkins::TestDUIsListSeperatorLines ), + ENTRY( "TestDUSlidingMode", CTestSDKSkins::TestDUSlidingMode ), + + ENTRY( "TestFBCCNewL", CTestSDKSkins::TestFBCCNewL ), + ENTRY( "TestFBCCSetFrameL", CTestSDKSkins::TestFBCCSetFrameL ), + ENTRY( "TestFBCCSetFrameRectsL", CTestSDKSkins::TestFBCCSetFrameRectsL ), + ENTRY( "TestFBCCSetCenterL", CTestSDKSkins::TestFBCCSetCenterL ), + ENTRY( "TestFBCCSetFramePartRectL", CTestSDKSkins::TestFBCCSetFramePartRectL ), + + ENTRY( "TestIDTypeL", CTestSDKSkins::TestIDTypeL ), + ENTRY( "TestIIDSetAttributesL", CTestSDKSkins::TestIIDSetAttributesL ), + ENTRY( "TestIIDAttributesL", CTestSDKSkins::TestIIDAttributesL ), + ENTRY( "TestIIDSetParentIIDL", CTestSDKSkins::TestIIDSetParentIIDL ), + ENTRY( "TestIIDSetDrawRectL", CTestSDKSkins::TestIIDSetDrawRectL ), + ENTRY( "TestIIDParentIIDL", CTestSDKSkins::TestIIDParentIIDL ), + ENTRY( "TestIIDDrawRectL", CTestSDKSkins::TestIIDDrawRectL ), + ENTRY( "TestBIDNewL", CTestSDKSkins::TestBIDNewL ), + ENTRY( "TestBIDSetBitmapL", CTestSDKSkins::TestBIDSetBitmapL ), + ENTRY( "TestBIDDestroyAndSetBitmapL", CTestSDKSkins::TestBIDDestroyAndSetBitmapL ), + ENTRY( "TestBIDBitmapL", CTestSDKSkins::TestBIDBitmapL ), + ENTRY( "TestMBIDNewL", CTestSDKSkins::TestMBIDNewL ), + ENTRY( "TestMBIDSetMaskL", CTestSDKSkins::TestMBIDSetMaskL ), + ENTRY( "TestMBIDDestroyAndSetMaskL", CTestSDKSkins::TestMBIDDestroyAndSetMaskL ), + ENTRY( "TestMBIDMaskL", CTestSDKSkins::TestMBIDMaskL ), + ENTRY( "TestCTIDNewL", CTestSDKSkins::TestCTIDNewL ), + ENTRY( "TestCTIDSetColorsL", CTestSDKSkins::TestCTIDSetColorsL ), + ENTRY( "TestCTIDColorIndexedL", CTestSDKSkins::TestCTIDColorIndexedL ), + ENTRY( "TestCTIDColorRgbL", CTestSDKSkins::TestCTIDColorRgbL ), + ENTRY( "TestCTIDGetColorL", CTestSDKSkins::TestCTIDGetColorL ), + ENTRY( "TestITIDNewL", CTestSDKSkins::TestITIDNewL ), + ENTRY( "TestITIDSetImagesL", CTestSDKSkins::TestITIDSetImagesL ), + ENTRY( "TestITIDImageIIDL", CTestSDKSkins::TestITIDImageIIDL ), + ENTRY( "TestITIDImagesL", CTestSDKSkins::TestITIDImagesL ), + ENTRY( "TestITIDNumberOfImagesL", CTestSDKSkins::TestITIDNumberOfImagesL ), + ENTRY( "TestBAIDNewL", CTestSDKSkins::TestBAIDNewL ), + ENTRY( "TestBAIDSetFrameInfosL", CTestSDKSkins::TestBAIDSetFrameInfosL ), + ENTRY( "TestBAIDFrameInfosL", CTestSDKSkins::TestBAIDFrameInfosL ), + ENTRY( "TestBAIDSetLastFrameBackgroundL", CTestSDKSkins::TestBAIDSetLastFrameBackgroundL ), + ENTRY( "TestBAIDLastFrameBackgroundL", CTestSDKSkins::TestBAIDLastFrameBackgroundL ), + ENTRY( "TestBAIDSetFrameIntervalL", CTestSDKSkins::TestBAIDSetFrameIntervalL ), + ENTRY( "TestBAIDFrameIntervalL", CTestSDKSkins::TestBAIDFrameIntervalL ), + ENTRY( "TestBAIDSetPlayModeL", CTestSDKSkins::TestBAIDSetPlayModeL ), + ENTRY( "TestBAIDPlayModeL", CTestSDKSkins::TestBAIDPlayModeL ), + ENTRY( "TestBAIDSetFlashL", CTestSDKSkins::TestBAIDSetFlashL ), + ENTRY( "TestBAIDFlashL", CTestSDKSkins::TestBAIDFlashL ), + ENTRY( "TestSIDNewL", CTestSDKSkins::TestSIDNewL ), + ENTRY( "TestSIDSetStringL", CTestSDKSkins::TestSIDSetStringL ), + ENTRY( "TestSIDStringL", CTestSDKSkins::TestSIDStringL ), + ENTRY( "TestECNewL", CTestSDKSkins::TestECNewL ), + ENTRY( "TestECSetEffectUidL", CTestSDKSkins::TestECSetEffectUidL ), + ENTRY( "TestECEffectUidL", CTestSDKSkins::TestECEffectUidL ), + ENTRY( "TestECSetLayerConfL", CTestSDKSkins::TestECSetLayerConfL ), + ENTRY( "TestECLayerConfL", CTestSDKSkins::TestECLayerConfL ), + ENTRY( "TestECAppendParameterL", CTestSDKSkins::TestECAppendParameterL ), + ENTRY( "TestECCreateParameterIteratorL", CTestSDKSkins::TestECCreateParameterIteratorL ), + ENTRY( "TestEQIDNewL", CTestSDKSkins::TestEQIDNewL ), + ENTRY( "TestEQIDSetRefItemL", CTestSDKSkins::TestEQIDSetRefItemL ), + ENTRY( "TestEQIDRefItemL", CTestSDKSkins::TestEQIDRefItemL ), + ENTRY( "TestEQIDSetInputLayerL", CTestSDKSkins::TestEQIDSetInputLayerL ), + ENTRY( "TestEQIDInputLayerL", CTestSDKSkins::TestEQIDInputLayerL ), + ENTRY( "TestEQIDSetInputLayerModeL", CTestSDKSkins::TestEQIDSetInputLayerModeL ), + ENTRY( "TestEQIDInputLayerModeL", CTestSDKSkins::TestEQIDInputLayerModeL ), + ENTRY( "TestEQIDSetOutputLayerL", CTestSDKSkins::TestEQIDSetOutputLayerL ), + ENTRY( "TestEQIDOutputLayerL", CTestSDKSkins::TestEQIDOutputLayerL ), + ENTRY( "TestEQIDSetOutputLayerModeL", CTestSDKSkins::TestEQIDSetOutputLayerModeL ), + ENTRY( "TestEQIDOutputLayerModeL", CTestSDKSkins::TestEQIDOutputLayerModeL ), + ENTRY( "TestEQIDAppendCommandL", CTestSDKSkins::TestEQIDAppendCommandL ), + ENTRY( "TestEQIDCreateCommandIteratorL", CTestSDKSkins::TestEQIDCreateCommandIteratorL ), + + + ENTRY( "TestIILinearOrder", CTestSDKSkins::TestIILinearOrder ), + + ENTRY( "TestLBCCNewL", CTestSDKSkins::TestLBCCNewL ), + ENTRY( "TestLBCCSetLayerImageL", CTestSDKSkins::TestLBCCSetLayerImageL ), + ENTRY( "TestLBCCSetLayerRectL", CTestSDKSkins::TestLBCCSetLayerRectL ), + + ENTRY( "TestLBBCCNewL", CTestSDKSkins::TestLBBCCNewL ), + ENTRY( "TestLBBCCSetTiledBitmapL", CTestSDKSkins::TestLBBCCSetTiledBitmapL ), + ENTRY( "TestLBBCCSetTiledRectL", CTestSDKSkins::TestLBBCCSetTiledRectL ), + ENTRY( "TestLBBCCSetBottomBitmapL", CTestSDKSkins::TestLBBCCSetBottomBitmapL ), + ENTRY( "TestLBBCCSetBottomRectL", CTestSDKSkins::TestLBBCCSetBottomRectL ), + + ENTRY( "TestWUSetIdleWallpaper", CTestSDKSkins::TestWUSetIdleWallpaper ), + ENTRY( "TestWUSetSlidesetWallpaperL", CTestSDKSkins::TestWUSetSlidesetWallpaperL ), + + ENTRY( "TestUInitSkinSupportL", CTestSDKSkins::TestUInitSkinSupportL ), + ENTRY( "TestUCreateDataContextForContainerL", CTestSDKSkins::TestUCreateDataContextForContainerL ), + ENTRY( "TestUCreateBitmapItemDefL", CTestSDKSkins::TestUCreateBitmapItemDefL ), + ENTRY( "TestUCreateMaskedBitmapItemDefL", CTestSDKSkins::TestUCreateMaskedBitmapItemDefL ), + ENTRY( "TestUSkinInstanceL", CTestSDKSkins::TestUSkinInstanceL ), + ENTRY( "TestUDataContextL", CTestSDKSkins::TestUDataContextL ), + ENTRY( "TestUCreateIconML", CTestSDKSkins::TestUCreateIconML ), + ENTRY( "TestUCreateIconMLC", CTestSDKSkins::TestUCreateIconMLC ), + ENTRY( "TestUCreateIconL", CTestSDKSkins::TestUCreateIconL ), + ENTRY( "TestUCreateIconLC", CTestSDKSkins::TestUCreateIconLC ), + ENTRY( "TestUCreateMaskedBitmapL", CTestSDKSkins::TestUCreateMaskedBitmapL ), + ENTRY( "TestUCreateGulIconL", CTestSDKSkins::TestUCreateGulIconL ), + ENTRY( "TestUCreateAppIconLC", CTestSDKSkins::TestUCreateAppIconLC ), + ENTRY( "TestUOpenAppIconFileL", CTestSDKSkins::TestUOpenAppIconFileL ), + ENTRY( "TestUCreateColorIconL", CTestSDKSkins::TestUCreateColorIconL ), + ENTRY( "TestUCreateColorIconLC", CTestSDKSkins::TestUCreateColorIconLC ), + ENTRY( "TestUCreateColorIconML", CTestSDKSkins::TestUCreateColorIconML ), + ENTRY( "TestUCreateColorIconMLC", CTestSDKSkins::TestUCreateColorIconMLC ), + ENTRY( "TestUGetAppIconL", CTestSDKSkins::TestUGetAppIconL ), + ENTRY( "TestUCreateBitmapL", CTestSDKSkins::TestUCreateBitmapL ), + ENTRY( "TestUCreateMaskedBitmapIL", CTestSDKSkins::TestUCreateMaskedBitmapIL ), + ENTRY( "TestUCreateGulIconIL", CTestSDKSkins::TestUCreateGulIconIL ), + ENTRY( "TestUGetCachedBitmapL", CTestSDKSkins::TestUGetCachedBitmapL ), + ENTRY( "TestUGetCachedMaskedBitmapL", CTestSDKSkins::TestUGetCachedMaskedBitmapL ), + ENTRY( "TestUGetCachedColorL", CTestSDKSkins::TestUGetCachedColorL ), + ENTRY( "TestUBooleanPropertyL", CTestSDKSkins::TestUBooleanPropertyL ), + ENTRY( "TestUSetAvkonSkinEnabledL", CTestSDKSkins::TestUSetAvkonSkinEnabledL ), + ENTRY( "TestUAvkonSkinEnabledL", CTestSDKSkins::TestUAvkonSkinEnabledL ), + ENTRY( "TestUSetAvkonHighlightAnimationEnabledL", CTestSDKSkins::TestUSetAvkonHighlightAnimationEnabledL ), + ENTRY( "TestUAvkonHighlightAnimationEnabledL", CTestSDKSkins::TestUAvkonHighlightAnimationEnabledL ), + ENTRY( "TestURegisterControlPositionL", CTestSDKSkins::TestURegisterControlPositionL ), + ENTRY( "TestURegisterControlPositionPL", CTestSDKSkins::TestURegisterControlPositionPL ), + ENTRY( "TestUDeregisterControlPositionL", CTestSDKSkins::TestUDeregisterControlPositionL ), + ENTRY( "TestUGetControlPositionL", CTestSDKSkins::TestUGetControlPositionL ), + }; + + const TInt count = sizeof( KFunctions ) / sizeof( TStifFunctionInfo ); + + return RunInternalL( KFunctions, count, aItem ); + + } + + + +// [End of File] diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksbbcc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksbbcc.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,132 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsBasicBackgroundControlContext.h +* +*/ + + +#include + +#include "testsdkskins.h" + +const TInt KLength = 10; +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBBCCNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBBCCNewL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + + STIF_ASSERT_NOT_NULL( context ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBBCCSetBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBBCCSetBitmapL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetBitmap( itemID ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBBCCSetRectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBBCCSetRectL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetRect( rect ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBBCCSetParentPosL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBBCCSetParentPosL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetParentPos( pointBR ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBBCCSetParentContextL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBBCCSetParentContextL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetParentContext( context ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblockscc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblockscc.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,50 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsControlContext.h +* +*/ + + +#include +#include + +#include "testsdkskins.h" + +const TInt KLength = 10; +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestCCSupplyMopObjectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestCCSupplyMopObjectL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + TTypeUid::Ptr ptr = TTypeUid::Null(); + ptr = context->SupplyMopObject( MAknsControlContext::ETypeId, context ); + CAknsBasicBackgroundControlContext* point = + static_cast ( ptr.Pointer() ); + STIF_ASSERT_NOT_NULL( point ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksdc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksdc.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,43 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsDataContext.h +* +*/ + + +#include +#include + +#include "testsdkskins.h" + +// ============================ MEMBER FUNCTIONS =============================== +//------------------------------------------------------------------------------ +// CTestSDKSkins::TestDCSupplyMopObjectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDCSupplyMopObjectL( CStifItemParser& /*aItem*/ ) + { + MAknsDataContext* context = AknsUtils::CreateDataContextForContainerL(); + STIF_ASSERT_NOT_NULL( context ); + + TTypeUid::Ptr ptr = TTypeUid::Null(); + ptr = context->SupplyMopObject( MAknsDataContext::ETypeId, context ); + MAknsDataContext* point = static_cast ( ptr.Pointer() ); + STIF_ASSERT_NOT_NULL( point ); + + delete context; + context = NULL; + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksdu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksdu.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,642 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsDrawUtils.h +* +*/ + + +#include +#include + +#include "testsdkskins.h" +#include "testsdkskinsobjectprovider.h" +#include "testsdkskinscontrol.h" + +const TInt KLength = 10; + +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUControlContextL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUControlContextL( CStifItemParser& /*aItem*/ ) + { + CTestSDKSkinsObjectProvider* provider = new (ELeave) CTestSDKSkinsObjectProvider; + CleanupStack::PushL( provider ); + STIF_ASSERT_NOT_NULL( provider ); + + MAknsControlContext* context = AknsDrawUtils::ControlContext( provider ); + CleanupStack::PushL( context ); + + CleanupStack::PopAndDestroy( context ); + CleanupStack::PopAndDestroy( provider ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUControlContextOfParentL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUControlContextOfParentL( CStifItemParser& /*aItem*/ ) + { + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + + MAknsControlContext* context = AknsDrawUtils::ControlContextOfParent( control ); + CleanupStack::PushL( context ); + + CleanupStack::PopAndDestroy( context ); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUBackgroundL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUBackgroundL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + + TBool draw = AknsDrawUtils::Background( instance, + context, + gc, + rect ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUBackgroundFPL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUBackgroundFPL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + + TBool draw = AknsDrawUtils::Background( instance, + context, + control, + gc, + rect ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUBackgroundSPL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUBackgroundSPL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + control->ActivateGc(); + + TBool draw = AknsDrawUtils::Background( instance, + context, + control, + gc, + rect, + KAknsDrawParamDefault ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUDrawBackgroundL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUDrawBackgroundL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + + control->ActivateGc(); + + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + + TBool draw = AknsDrawUtils::DrawBackground( instance, + context, + control, + gc, + pointTL, + rect, + KAknsDrawParamDefault ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUBackgroundBetweenRectsFPL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUBackgroundBetweenRectsFPL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + + control->ActivateGc(); + + TBool draw = AknsDrawUtils::BackgroundBetweenRects( AknsUtils::SkinInstance(), + context, + gc, + outRect, + inRect ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUBackgroundBetweenRectsL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUBackgroundBetweenRectsL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + TBool draw = AknsDrawUtils::BackgroundBetweenRects( AknsUtils::SkinInstance(), + context, + control, + gc, + outRect, + inRect ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUBackgroundBetweenRectsSPL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUBackgroundBetweenRectsSPL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + TBool draw = AknsDrawUtils::BackgroundBetweenRects( AknsUtils::SkinInstance(), + context, + control, + gc, + outRect, + inRect, + KAknsDrawParamDefault ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUHasBitmapBackgroundL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUHasBitmapBackgroundL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsBasicBackgroundControlContext* context = + CAknsBasicBackgroundControlContext::NewL( itemID, rect, ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + TBool draw = AknsDrawUtils::HasBitmapBackground( AknsUtils::SkinInstance(), + context ); + STIF_ASSERT_TRUE( draw ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUDrawCachedImageL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUDrawCachedImageL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint pointTL( 0, 0 ); + TPoint outPoint( KOutPoint, KOutPoint ); + TRect outRect( pointTL, outPoint ); + + AknsDrawUtils::DrawCachedImage( AknsUtils::SkinInstance(), + gc, + outRect, + itemID ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUDrawCachedImageFBSL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUDrawCachedImageFBSL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + CFbsBitGc* gc = NULL; + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint pointTL( 0, 0 ); + TPoint outPoint( KOutPoint, KOutPoint ); + TRect outRect( pointTL, outPoint ); + + AknsDrawUtils::DrawCachedImage( AknsUtils::SkinInstance(), + *gc, + outRect, + itemID ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUDrawFrameL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUDrawFrameL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID frameID; + TAknsItemID centerID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + TBool draw = AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), + gc, + outRect, + inRect, + frameID, + centerID ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUPrepareFrameL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUPrepareFrameL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID frameID; + TAknsItemID centerID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + TBool draw = AknsDrawUtils::PrepareFrame( AknsUtils::SkinInstance(), + outRect, + inRect, + frameID, + centerID ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUDrawFrameSPL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUDrawFrameSPL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID frameID; + TAknsItemID centerID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + + CFbsBitGc* gc = NULL; + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + TBool draw = AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), + *gc, + outRect, + inRect, + frameID, + centerID, + KAknsDrawParamDefault ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUDrawFrameFBSL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUDrawFrameFBSL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID frameID; + TAknsItemID centerID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + + CFbsBitGc* gc = NULL; + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + TBool draw = AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), + *gc, + outRect, + inRect, + frameID, + centerID ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUDrawFramePartL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUDrawFramePartL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + + CWindowGc& gc = CCoeEnv::Static()->SystemGc(); + + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + control->ActivateGc(); + + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + TRect rect( pointTL, outPoint ); + + TBool draw = AknsDrawUtils::DrawFramePart( AknsUtils::SkinInstance(), + gc, + rect, + itemID, + EAknsFrameIndexTl ); + + control->DeactivateGc(); + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUIsListSeperatorLines +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUIsListSeperatorLines( CStifItemParser& /*aItem*/ ) + { + TBool seperator = AknsDrawUtils::IsListSeperatorLines( AknsUtils::SkinInstance() ); + STIF_ASSERT_TRUE( seperator ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestDUSlidingMode +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestDUSlidingMode( CStifItemParser& /*aItem*/ ) + { + TSlidingMode mode = AknsDrawUtils::SlidingMode( AknsUtils::SkinInstance() ); + STIF_ASSERT_TRUE( mode == ESlidingDisabled ); + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksfbcc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksfbcc.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,181 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsFrameBackgroundControlContext.h +* +*/ + + +#include + +#include "testsdkskins.h" + +const TInt KLength = 10; +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestFBCCNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestFBCCNewL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + CAknsFrameBackgroundControlContext* context = + CAknsFrameBackgroundControlContext::NewL( itemID, + outRect, + inRect, + ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestFBCCSetFrameL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestFBCCSetFrameL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + CAknsFrameBackgroundControlContext* context = + CAknsFrameBackgroundControlContext::NewL( itemID, + outRect, + inRect, + ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetFrame( itemID ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestFBCCSetFrameRectsL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestFBCCSetFrameRectsL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + CAknsFrameBackgroundControlContext* context = + CAknsFrameBackgroundControlContext::NewL( itemID, + outRect, + inRect, + ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetFrameRects( outRect, inRect ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestFBCCSetCenterL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestFBCCSetCenterL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + CAknsFrameBackgroundControlContext* context = + CAknsFrameBackgroundControlContext::NewL( itemID, + outRect, + inRect, + ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetCenter( itemID ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestFBCCSetFramePartRectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestFBCCSetFramePartRectL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + const TInt KOutPoint = 50; + TPoint outPoint( KOutPoint, KOutPoint ); + const TInt KInPoint = 40; + TPoint inPoint( KInPoint, KInPoint ); + TRect outRect( pointTL, outPoint ); + TRect inRect( pointBR, inPoint ); + + CAknsFrameBackgroundControlContext* context = + CAknsFrameBackgroundControlContext::NewL( itemID, + outRect, + inRect, + ETrue ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetFramePartRect( outRect, EAknsFrameIndexTl ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksid.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksid.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,978 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsItemData.h +* +*/ + + +#include +#include +#include +#include +#include + +#include "testsdkskins.h" + +const TInt KLength = 10; +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIDTypeL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIDTypeL( CStifItemParser& /*aItem*/ ) + { + CAknsBitmapItemData* itemData = CAknsBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsItemType typeGet = itemData->Type(); + STIF_ASSERT_TRUE( typeGet == EAknsITBitmap ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIIDSetAttributesL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIIDSetAttributesL( CStifItemParser& /*aItem*/ ) + { + CAknsBitmapItemData* itemData = CAknsBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsImageAttributeData attributeData; + itemData->SetAttributesL( attributeData ); + STIF_ASSERT_NOT_NULL( itemData->Attributes() ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIIDAttributesL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIIDAttributesL( CStifItemParser& aItem ) + { + return TestIIDSetAttributesL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIIDSetParentIIDL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIIDSetParentIIDL( CStifItemParser& /*aItem*/ ) + { + CAknsBitmapItemData* itemData = CAknsBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsItemID itemID; + itemData->SetParentIID( itemID ); + STIF_ASSERT_TRUE( itemID.iMajor == itemData->ParentIID().iMajor ); + STIF_ASSERT_TRUE( itemID.iMinor == itemData->ParentIID().iMinor ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIIDSetDrawRectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIIDSetDrawRectL( CStifItemParser& /*aItem*/ ) + { + CAknsBitmapItemData* itemData = CAknsBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + itemData->SetDrawRect( rect ); + STIF_ASSERT_TRUE( rect == itemData->DrawRect() ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIIDParentIIDL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIIDParentIIDL( CStifItemParser& aItem ) + { + return TestIIDSetParentIIDL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIIDDrawRectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIIDDrawRectL( CStifItemParser& aItem ) + { + return TestIIDSetDrawRectL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBIDNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBIDNewL( CStifItemParser& /*aItem*/ ) + { + CAknsBitmapItemData* itemData = CAknsBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBIDSetBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBIDSetBitmapL( CStifItemParser& /*aItem*/ ) + { + CAknsBitmapItemData* itemData = CAknsBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CFbsBitmap* bitMap = new (ELeave) CFbsBitmap; + CleanupStack::PushL( bitMap ); + itemData->SetBitmap( bitMap ); + + STIF_ASSERT_TRUE( bitMap == itemData->Bitmap() ); + + CleanupStack::Pop( bitMap ); + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBIDDestroyAndSetBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBIDDestroyAndSetBitmapL( CStifItemParser& /*aItem*/ ) + { + CAknsBitmapItemData* itemData = CAknsBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CFbsBitmap* bitMap = new (ELeave) CFbsBitmap; + CleanupStack::PushL( bitMap ); + itemData->DestroyAndSetBitmap( bitMap ); + + CleanupStack::Pop( bitMap ); + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBIDBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBIDBitmapL( CStifItemParser& aItem ) + { + return TestBIDSetBitmapL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestMBIDNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestMBIDNewL( CStifItemParser& /*aItem*/ ) + { + CAknsMaskedBitmapItemData* itemData = CAknsMaskedBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestMBIDSetMaskL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestMBIDSetMaskL( CStifItemParser& /*aItem*/ ) + { + CAknsMaskedBitmapItemData* itemData = CAknsMaskedBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CFbsBitmap* bitMapMask = new (ELeave) CFbsBitmap; + CleanupStack::PushL( bitMapMask ); + itemData->SetMask( bitMapMask ); + + STIF_ASSERT_TRUE( bitMapMask == itemData->Mask() ); + + CleanupStack::Pop( bitMapMask ); + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestMBIDDestroyAndSetMaskL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestMBIDDestroyAndSetMaskL( CStifItemParser& /*aItem*/ ) + { + CAknsMaskedBitmapItemData* itemData = CAknsMaskedBitmapItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CFbsBitmap* bitMapMask = new (ELeave) CFbsBitmap; + CleanupStack::PushL( bitMapMask ); + itemData->DestroyAndSetBitmap( bitMapMask ); + + CleanupStack::Pop( bitMapMask ); + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestMBIDMaskL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestMBIDMaskL( CStifItemParser& aItem ) + { + return TestMBIDSetMaskL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestCTIDNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestCTIDNewL( CStifItemParser& /*aItem*/ ) + { + CAknsColorTableItemData* itemData = CAknsColorTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestCTIDSetColorsL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestCTIDSetColorsL( CStifItemParser& /*aItem*/ ) + { + CAknsColorTableItemData* itemData = CAknsColorTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsColorTableEntry* color = new (ELeave) TAknsColorTableEntry[1]; + color->iIndex = 0; + color->iRgb = 0x00020408; + itemData->SetColorsL( 1, color ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestCTIDColorIndexedL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestCTIDColorIndexedL( CStifItemParser& /*aItem*/ ) + { + CAknsColorTableItemData* itemData = CAknsColorTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsColorTableEntry* color = new (ELeave) TAknsColorTableEntry[1]; + color->iIndex = 0; + color->iRgb = 0x00020408; + itemData->SetColorsL( 1, color ); + + TInt value = itemData->ColorIndexed( 0 ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestCTIDColorRgbL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestCTIDColorRgbL( CStifItemParser& /*aItem*/ ) + { + CAknsColorTableItemData* itemData = CAknsColorTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsColorTableEntry* color = new (ELeave) TAknsColorTableEntry[1]; + color->iIndex = 0; + color->iRgb = 0x00020408; + itemData->SetColorsL( 1, color ); + + TRgb rgb = itemData->ColorRgb( 0 ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestCTIDGetColorL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestCTIDGetColorL( CStifItemParser& /*aItem*/ ) + { + CAknsColorTableItemData* itemData = CAknsColorTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsColorTableEntry* color = new (ELeave) TAknsColorTableEntry[1]; + color->iIndex = 0; + color->iRgb = 0x00020408; + itemData->SetColorsL( 1, color ); + + TRgb rgb; + itemData->GetColorL( 0, rgb ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestITIDNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestITIDNewL( CStifItemParser& /*aItem*/ ) + { + CAknsImageTableItemData* itemData = CAknsImageTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestITIDSetImagesL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestITIDSetImagesL( CStifItemParser& /*aItem*/ ) + { + CAknsImageTableItemData* itemData = CAknsImageTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsItemID itemID; + itemData->SetImagesL( 1, &itemID ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestITIDImageIIDL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestITIDImageIIDL( CStifItemParser& /*aItem*/ ) + { + CAknsImageTableItemData* itemData = CAknsImageTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsItemID itemID; + itemData->SetImagesL( 1, &itemID ); + TAknsItemID itemIDGet = itemData->ImageIID( 0 ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestITIDImagesL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestITIDImagesL( CStifItemParser& /*aItem*/ ) + { + CAknsImageTableItemData* itemData = CAknsImageTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsItemID itemID; + itemData->SetImagesL( 1, &itemID ); + TAknsItemID* item = itemData->Images(); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestITIDNumberOfImagesL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestITIDNumberOfImagesL( CStifItemParser& /*aItem*/ ) + { + CAknsImageTableItemData* itemData = CAknsImageTableItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsItemID itemID; + itemData->SetImagesL( 1, &itemID ); + TInt num = itemData->NumberOfImages(); + STIF_ASSERT_TRUE( 1 == num ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDNewL( CStifItemParser& /*aItem*/ ) + { + CAknsBmpAnimItemData* itemData = CAknsBmpAnimItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDSetFrameInfosL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDSetFrameInfosL( CStifItemParser& /*aItem*/ ) + { + CAknsBmpAnimItemData* itemData = CAknsBmpAnimItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsBmpAnimFrameInfo info; + itemData->SetFrameInfosL( &info ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDFrameInfosL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDFrameInfosL( CStifItemParser& /*aItem*/ ) + { + CAknsBmpAnimItemData* itemData = CAknsBmpAnimItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsBmpAnimFrameInfo info; + itemData->SetFrameInfosL( &info ); + TAknsBmpAnimFrameInfo* infoGet = itemData->FrameInfos(); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDSetLastFrameBackgroundL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDSetLastFrameBackgroundL( CStifItemParser& /*aItem*/ ) + { + CAknsBmpAnimItemData* itemData = CAknsBmpAnimItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetLastFrameBackground( ETrue ); + STIF_ASSERT_TRUE( itemData->LastFrameBackground() ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDLastFrameBackgroundL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDLastFrameBackgroundL( CStifItemParser& aItem ) + { + return TestBAIDSetLastFrameBackgroundL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDSetFrameIntervalL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDSetFrameIntervalL( CStifItemParser& /*aItem*/ ) + { + CAknsBmpAnimItemData* itemData = CAknsBmpAnimItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetFrameInterval( 1 ); + STIF_ASSERT_TRUE( 1 == itemData->FrameInterval() ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDFrameIntervalL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDFrameIntervalL( CStifItemParser& aItem ) + { + return TestBAIDSetFrameIntervalL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDSetPlayModeL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDSetPlayModeL( CStifItemParser& /*aItem*/ ) + { + CAknsBmpAnimItemData* itemData = CAknsBmpAnimItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetPlayMode( 1 ); + STIF_ASSERT_TRUE( 1 == itemData->PlayMode() ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDPlayModeL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDPlayModeL( CStifItemParser& aItem ) + { + return TestBAIDSetPlayModeL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDSetFlashL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDSetFlashL( CStifItemParser& /*aItem*/ ) + { + CAknsBmpAnimItemData* itemData = CAknsBmpAnimItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetFlash( ETrue ); + STIF_ASSERT_TRUE( itemData->Flash() ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestBAIDFlashL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestBAIDFlashL( CStifItemParser& aItem ) + { + return TestBAIDSetFlashL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestSIDNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestSIDNewL( CStifItemParser& /*aItem*/ ) + { + CAknsStringItemData* itemData = CAknsStringItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestSIDSetStringL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestSIDSetStringL( CStifItemParser& /*aItem*/ ) + { + CAknsStringItemData* itemData = CAknsStringItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + _LIT( KString, "string" ); + TBuf string( KString ); + itemData->SetStringL( string ); + TBuf stringGet = itemData->String(); + STIF_ASSERT_TRUE( 0 == stringGet.Compare( string ) ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestSIDStringL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestSIDStringL( CStifItemParser& aItem ) + { + return TestSIDSetStringL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestECNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestECNewL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectCommand* itemData = CAknsEffectCommand::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestECSetEffectUidL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestECSetEffectUidL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectCommand* itemData = CAknsEffectCommand::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TUid uid = TUid::Uid( 0 ); + itemData->SetEffectUid( uid ); + STIF_ASSERT_TRUE( uid == itemData->EffectUid() ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestECEffectUidL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestECEffectUidL( CStifItemParser& aItem ) + { + return TestECSetEffectUidL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestECSetLayerConfL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestECSetLayerConfL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectCommand* itemData = CAknsEffectCommand::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsRlRenderOpParam param; + param.iInputLayerAIndex = KLength; + itemData->SetLayerConf( param ); + TAknsRlRenderOpParam paramGet = itemData->LayerConf(); + STIF_ASSERT_TRUE( param.iInputLayerAIndex == paramGet.iInputLayerAIndex ); + STIF_ASSERT_TRUE( param.iInputLayerAStatus == paramGet.iInputLayerAStatus ); + STIF_ASSERT_TRUE( param.iInputLayerBIndex == paramGet.iInputLayerBIndex ); + STIF_ASSERT_TRUE( param.iInputLayerBStatus == paramGet.iInputLayerBStatus ); + STIF_ASSERT_TRUE( param.iOutputLayerIndex == paramGet.iOutputLayerIndex ); + STIF_ASSERT_TRUE( param.iOutputLayerStatus == paramGet.iOutputLayerStatus ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestECLayerConfL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestECLayerConfL( CStifItemParser& aItem ) + { + return TestECSetLayerConfL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestECAppendParameterL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestECAppendParameterL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectCommand* itemData = CAknsEffectCommand::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsRlParameterData parameterData; + _LIT( KName, "parameter" ); + TBuf name( KName ); + parameterData.iName = &name; + itemData->AppendParameterL( parameterData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestECCreateParameterIteratorL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestECCreateParameterIteratorL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectCommand* itemData = CAknsEffectCommand::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + MAknsRlParameterIterator* iterator = itemData->CreateParameterIteratorL(); + STIF_ASSERT_NOT_NULL( iterator ); + + delete iterator; + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDNewL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDSetRefItemL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDSetRefItemL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + TAknsItemID itemID( KAknsIIDQsnCpScrollBgTop ); + itemData->SetRefItem( itemID ); + TAknsItemID itemIDGet = itemData->RefItem(); + STIF_ASSERT_TRUE( itemID.iMajor == itemID.iMajor ); + STIF_ASSERT_TRUE( itemID.iMinor == itemID.iMinor ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDRefItemL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDRefItemL( CStifItemParser& aItem ) + { + return TestEQIDSetRefItemL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDSetInputLayerL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDSetInputLayerL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetInputLayer( 1 ); + TInt inputLayerGet = itemData->InputLayer(); + STIF_ASSERT_TRUE( 1 == inputLayerGet ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDInputLayerL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDInputLayerL( CStifItemParser& aItem ) + { + return TestEQIDSetInputLayerL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDSetInputLayerModeL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDSetInputLayerModeL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetInputLayerMode( 1 ); + TInt modeGet = itemData->InputLayerMode(); + STIF_ASSERT_TRUE( 1 == modeGet ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDInputLayerModeL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDInputLayerModeL( CStifItemParser& aItem ) + { + return TestEQIDSetInputLayerModeL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDSetOutputLayerL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDSetOutputLayerL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetOutputLayer( 1 ); + TInt outputLayerGet = itemData->OutputLayer(); + STIF_ASSERT_TRUE( 1 == outputLayerGet ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDOutputLayerL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDOutputLayerL( CStifItemParser& aItem ) + { + return TestEQIDSetOutputLayerL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDSetOutputLayerModeL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDSetOutputLayerModeL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + itemData->SetOutputLayerMode( 1 ); + TInt outputLayerModeGet = itemData->OutputLayerMode(); + STIF_ASSERT_TRUE( 1 == outputLayerModeGet ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDOutputLayerModeL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDOutputLayerModeL( CStifItemParser& aItem ) + { + return TestEQIDSetOutputLayerModeL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDAppendCommandL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDAppendCommandL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + CAknsEffectCommand* command = CAknsEffectCommand::NewL(); + CleanupStack::PushL( command ); + STIF_ASSERT_NOT_NULL( command ); + + itemData->AppendCommandL( command ); + + CleanupStack::Pop( command ); + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestEQIDCreateCommandIteratorL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestEQIDCreateCommandIteratorL( CStifItemParser& /*aItem*/ ) + { + CAknsEffectQueueItemData* itemData = CAknsEffectQueueItemData::NewL(); + CleanupStack::PushL( itemData ); + STIF_ASSERT_NOT_NULL( itemData ); + + MAknsRlCommandIterator* iterator = itemData->CreateCommandIteratorL(); + STIF_ASSERT_NOT_NULL( iterator ); + + CleanupStack::PopAndDestroy( itemData ); + + return KErrNone; + + } + diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksii.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksii.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,36 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsItemID.h +* +*/ + + +#include + +#include "testsdkskins.h" + +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestIILinearOrder +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestIILinearOrder( CStifItemParser& /*aItem*/ ) + { + TAknsItemID firstItemID; + TAknsItemID secondItemID; + TInt order = TAknsItemID::LinearOrder( firstItemID, secondItemID ); + STIF_ASSERT_TRUE( 0 == order ); + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblockslbbcc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblockslbbcc.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,153 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsListBoxBackgroundControlContext.h +* +*/ + + +#include + +#include "testsdkskins.h" + +const TInt KLength = 10; +const TInt KTiledLength = 20; +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBBCCNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBBCCNewL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TAknsItemID tileditemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TPoint pointSBR( KTiledLength, KTiledLength ); + TRect rect( pointTL, pointBR ); + TRect rectTiled( pointBR, pointSBR ); + + CAknsListBoxBackgroundControlContext* context = + CAknsListBoxBackgroundControlContext::NewL( itemID, rect, ETrue, tileditemID, rectTiled ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBBCCSetTiledBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBBCCSetTiledBitmapL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TAknsItemID tileditemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TPoint pointSBR( KTiledLength, KTiledLength ); + TRect rect( pointTL, pointBR ); + TRect rectTiled( pointBR, pointSBR ); + + CAknsListBoxBackgroundControlContext* context = + CAknsListBoxBackgroundControlContext::NewL( itemID, rect, ETrue, tileditemID, rectTiled ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetTiledBitmap( tileditemID ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBBCCSetTiledRectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBBCCSetTiledRectL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TAknsItemID tileditemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TPoint pointSBR( KTiledLength, KTiledLength ); + TRect rect( pointTL, pointBR ); + TRect rectTiled( pointBR, pointSBR ); + + CAknsListBoxBackgroundControlContext* context = + CAknsListBoxBackgroundControlContext::NewL( itemID, rect, ETrue, tileditemID, rectTiled ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetTiledRect( rectTiled ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBBCCSetBottomBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBBCCSetBottomBitmapL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TAknsItemID tileditemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TPoint pointSBR( KTiledLength, KTiledLength ); + TRect rect( pointTL, pointBR ); + TRect rectTiled( pointBR, pointSBR ); + + CAknsListBoxBackgroundControlContext* context = + CAknsListBoxBackgroundControlContext::NewL( itemID, rect, ETrue, tileditemID, rectTiled ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetBottomBitmap( tileditemID ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBBCCSetBottomRectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBBCCSetBottomRectL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TAknsItemID tileditemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TPoint pointSBR( KTiledLength, KTiledLength ); + TRect rect( pointTL, pointBR ); + TRect rectTiled( pointBR, pointSBR ); + + CAknsListBoxBackgroundControlContext* context = + CAknsListBoxBackgroundControlContext::NewL( itemID, rect, ETrue, tileditemID, rectTiled ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetBottomRect( rectTiled ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblockslbcc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblockslbcc.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,88 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsLayeredBackgroundControlContext.h +* +*/ + + +#include + +#include "testsdkskins.h" + +const TInt KLength = 10; + +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBCCNewL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBCCNewL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsLayeredBackgroundControlContext* context = + CAknsLayeredBackgroundControlContext::NewL( itemID, rect, ETrue, 1 ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBCCSetLayerImageL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBCCSetLayerImageL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsLayeredBackgroundControlContext* context = + CAknsLayeredBackgroundControlContext::NewL( itemID, rect, ETrue, 1 ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetLayerImage( 0, itemID ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestLBCCSetLayerRectL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestLBCCSetLayerRectL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + TPoint pointTL( 0, 0 ); + TPoint pointBR( KLength, KLength ); + TRect rect( pointTL, pointBR ); + CAknsLayeredBackgroundControlContext* context = + CAknsLayeredBackgroundControlContext::NewL( itemID, rect, ETrue, 1 ); + CleanupStack::PushL( context ); + STIF_ASSERT_NOT_NULL( context ); + + context->SetLayerRect( 0, rect ); + + CleanupStack::PopAndDestroy( context ); + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblocksu.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,706 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsUtils.h +* +*/ + + +#include +#include +#include +#include +#include + +#include "testsdkskins.h" +#include "testsdkskinscontrol.h" + +const TInt KLength = 10; +_LIT( KMapfile, "z:\\resource\\apps\\avkon2.mbm" ); + +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUInitSkinSupportL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUInitSkinSupportL( CStifItemParser& /*aItem*/ ) + { + AknsUtils::InitSkinSupportL(); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateDataContextForContainerL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateDataContextForContainerL( CStifItemParser& /*aItem*/ ) + { + MAknsDataContext* context = AknsUtils::CreateDataContextForContainerL(); + STIF_ASSERT_NOT_NULL( context ); + + delete context; + context = NULL; + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateBitmapItemDefL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateBitmapItemDefL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + CAknsItemDef* def = AknsUtils::CreateBitmapItemDefL( itemID, KMapfile, 0 ); + CleanupStack::PushL( def ); + STIF_ASSERT_NOT_NULL( def ); + + CleanupStack::PopAndDestroy( def ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateMaskedBitmapItemDefL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateMaskedBitmapItemDefL( CStifItemParser& /*aItem*/ ) + { + TAknsItemID itemID; + CAknsItemDef* def = AknsUtils::CreateMaskedBitmapItemDefL( itemID, KMapfile, 1, 2 ); + CleanupStack::PushL( def ); + STIF_ASSERT_NOT_NULL( def ); + + CleanupStack::PopAndDestroy( def ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUSkinInstanceL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUSkinInstanceL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + STIF_ASSERT_NOT_NULL( instance ); + + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUDataContextL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUDataContextL( CStifItemParser& /*aItem*/ ) + { + CEikDialog* dialog = new (ELeave) CEikDialog; + CleanupStack::PushL( dialog ); + STIF_ASSERT_NOT_NULL( dialog ); + + MAknsDataContext* context = AknsUtils::DataContext( dialog ); + STIF_ASSERT_NOT_NULL( context ); + + CleanupStack::PopAndDestroy( dialog ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateIconML +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateIconML( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + AknsUtils::CreateIconL( instance, itemID, bitMap, bitMapMask, KMapfile, + EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask ); + CleanupStack::PushL( bitMap ); + CleanupStack::PushL( bitMapMask ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::Pop( bitMapMask ); + CleanupStack::Pop( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateIconMLC +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateIconMLC( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + AknsUtils::CreateIconLC( instance, itemID, bitMap, bitMapMask, KMapfile, + EMbmAvkonQgn_indi_mic, EMbmAvkonQgn_indi_mic_mask ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::Pop( bitMapMask ); + CleanupStack::Pop( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateIconL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateIconL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + CFbsBitmap* bitMap = NULL; + + AknsUtils::CreateIconL( instance, itemID, bitMap, KMapfile, EMbmAvkonQgn_indi_mic ); + CleanupStack::PushL( bitMap ); + + STIF_ASSERT_NOT_NULL( bitMap ); + + CleanupStack::Pop( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateIconLC +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateIconLC( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + CFbsBitmap* bitMap = NULL; + + AknsUtils::CreateIconLC( instance, itemID, bitMap, KMapfile, EMbmAvkonQgn_indi_mic ); + + STIF_ASSERT_NOT_NULL( bitMap ); + + CleanupStack::Pop( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateMaskedBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateMaskedBitmapL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + + CApaMaskedBitmap* bitMap = AknsUtils::CreateMaskedBitmapL( instance, itemID, KMapfile, 1, 2 ); + CleanupStack::PushL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMap ); + + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateGulIconL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateGulIconL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + + CGulIcon* guiIcon = AknsUtils::CreateGulIconL( instance, itemID, KMapfile, 1, 2 ); + CleanupStack::PushL( guiIcon ); + STIF_ASSERT_NOT_NULL( guiIcon ); + + CleanupStack::PopAndDestroy( guiIcon ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateAppIconLC +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateAppIconLC( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + TUid uid = TUid::Uid( 0x2001CB80 ); + AknsUtils::CreateAppIconLC( instance, uid, EAknsAppIconTypeContext, bitMap, bitMapMask ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::PopAndDestroy( bitMapMask ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUOpenAppIconFileL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUOpenAppIconFileL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + _LIT( KAppIconFile, "C:\\appicon.txt" ); + RFs rfs; + CleanupClosePushL( rfs ); + User::LeaveIfError( rfs.Connect() ); + RFile file; + CleanupClosePushL( file ); + file.Replace( rfs, KAppIconFile, EFileWrite ); + + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + TUid uid = TUid::Uid( 0x2001CB80 ); + AknsUtils::CreateAppIconLC( instance, uid, EAknsAppIconTypeContext, bitMap, bitMapMask ); + + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::PopAndDestroy( bitMapMask ); + + AknsUtils* util = NULL; + + TInt flag = util->OpenAppIconFile( instance, uid, EAknsAppIconType3D, file ); + STIF_ASSERT_TRUE( KErrNotSupported == flag ); + + CleanupStack::PopAndDestroy( &file ); + CleanupStack::PopAndDestroy( &rfs ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateColorIconL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateColorIconL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + TAknsItemID colorID; + + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + TRgb rgb = 0x00020408; + + AknsUtils::CreateColorIconL( instance, itemID, colorID, 0, bitMap, bitMapMask, KMapfile, 1, 2, rgb ); + CleanupStack::PushL( bitMap ); + CleanupStack::PushL( bitMapMask ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::PopAndDestroy( bitMapMask ); + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateColorIconLC +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateColorIconLC( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + TAknsItemID colorID; + + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + TRgb rgb = 0x00020408; + + AknsUtils::CreateColorIconLC( instance, itemID, colorID, 0, bitMap, + bitMapMask, KMapfile, 1, 2, rgb ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::PopAndDestroy( bitMapMask ); + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateColorIconML +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateColorIconML( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + TAknsItemID colorID; + + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + TRgb rgb = 0x00020408; + + TSize size( KLength, KLength ); + + AknsUtils::CreateColorIconL( instance, itemID, colorID, 0, bitMap, bitMapMask, + KMapfile, 1, 2, rgb, size, EAspectRatioPreserved ); + CleanupStack::PushL( bitMap ); + CleanupStack::PushL( bitMapMask ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::PopAndDestroy( bitMapMask ); + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateColorIconMLC +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateColorIconMLC( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + TAknsItemID itemID; + TAknsItemID colorID; + + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + TRgb rgb = 0x00020408; + + TSize size( KLength, KLength ); + + AknsUtils::CreateColorIconLC( instance, itemID, colorID, 0, bitMap, bitMapMask, + KMapfile, 1, 2, rgb, size, EAspectRatioPreserved ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::PopAndDestroy( bitMapMask ); + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUGetAppIconL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUGetAppIconL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + CApaMaskedBitmap* bitMapMask = CApaMaskedBitmap::NewLC(); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + TUid uid = TUid::Uid( 0x2001CB80 ); + TSize size( KLength, KLength ); + + TInt flag = AknsUtils::GetAppIcon( instance, uid, size, *bitMapMask ); + + CleanupStack::PopAndDestroy( bitMapMask ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateBitmapL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + CFbsBitmap* bitMap = AknsUtils::CreateBitmapL( instance, KAknsIIDQsnCpScrollBgTop ); + CleanupStack::PushL( bitMap ); + + STIF_ASSERT_NOT_NULL( bitMap ); + + CleanupStack::PopAndDestroy( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateMaskedBitmapIL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateMaskedBitmapIL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + TRAP_IGNORE( AknsUtils::CreateMaskedBitmapL( instance, KAknsIIDQsnCpScrollBgTop ) ); + + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUCreateGulIconIL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUCreateGulIconIL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + CGulIcon* icon = AknsUtils::CreateGulIconL( instance, KAknsIIDQsnCpScrollBgTop, EFalse ); + CleanupStack::PushL( icon ); + STIF_ASSERT_NOT_NULL( icon ); + + CleanupStack::PopAndDestroy( icon ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUGetCachedBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUGetCachedBitmapL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + CFbsBitmap* bitMap = AknsUtils::GetCachedBitmap( instance, KAknsIIDQsnCpScrollBgTop ); + + STIF_ASSERT_NOT_NULL( bitMap ); + + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUGetCachedMaskedBitmapL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUGetCachedMaskedBitmapL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + CFbsBitmap* bitMap = NULL; + CFbsBitmap* bitMapMask = NULL; + + AknsUtils::GetCachedMaskedBitmap( instance, KAknsIIDQsnCpScrollBgTop, bitMap, bitMapMask ); + CleanupStack::PushL( bitMap ); + CleanupStack::PushL( bitMapMask ); + + STIF_ASSERT_NOT_NULL( bitMap ); + STIF_ASSERT_NOT_NULL( bitMapMask ); + + CleanupStack::Pop( bitMapMask ); + CleanupStack::Pop( bitMap ); + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUGetCachedColorL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUGetCachedColorL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + TRgb rgb; + + TInt flag = AknsUtils::GetCachedColor( instance, rgb, KAknsIIDQsnComponentColors, 1 ); + STIF_ASSERT_TRUE( KErrNone == flag ); + + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUBooleanPropertyL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUBooleanPropertyL( CStifItemParser& /*aItem*/ ) + { + MAknsSkinInstance* instance = AknsUtils::SkinInstance(); + CleanupStack::PushL( instance ); + + TRAPD( err, AknsUtils::BooleanPropertyL( instance, KAknsIIDPropertyMessageHeaderLines ) ); + STIF_ASSERT_TRUE( err == KErrNotFound ); + + CleanupStack::Pop( instance ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUSetAvkonSkinEnabledL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUSetAvkonSkinEnabledL( CStifItemParser& /*aItem*/ ) + { + AknsUtils::SetAvkonSkinEnabledL( ETrue ); + TBool skin = AknsUtils::AvkonSkinEnabled(); + STIF_ASSERT_TRUE( skin ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUAvkonSkinEnabledL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUAvkonSkinEnabledL( CStifItemParser& aItem ) + { + return TestUSetAvkonSkinEnabledL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUSetAvkonHighlightAnimationEnabledL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUSetAvkonHighlightAnimationEnabledL( CStifItemParser& /*aItem*/ ) + { + AknsUtils::SetAvkonHighlightAnimationEnabledL( ETrue ); + TBool skin = AknsUtils::AvkonHighlightAnimationEnabled(); + STIF_ASSERT_TRUE( skin ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUAvkonHighlightAnimationEnabledL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUAvkonHighlightAnimationEnabledL( CStifItemParser& aItem ) + { + return TestUSetAvkonHighlightAnimationEnabledL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestURegisterControlPositionL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestURegisterControlPositionL( CStifItemParser& /*aItem*/ ) + { + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + + AknsUtils::RegisterControlPosition( control ); + AknsUtils::DeregisterControlPosition( control ); + + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestURegisterControlPositionPL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestURegisterControlPositionPL( CStifItemParser& /*aItem*/ ) + { + CTestSDKSkinsControl* control = CTestSDKSkinsControl::NewL(); + CleanupStack::PushL( control ); + STIF_ASSERT_NOT_NULL( control ); + + TPoint point( KLength, KLength ); + TPoint pointGet; + + AknsUtils::RegisterControlPosition( control, point ); + TInt flag = AknsUtils::GetControlPosition( control, pointGet ); + STIF_ASSERT_TRUE( flag == KErrNone ); + STIF_ASSERT_TRUE( point == pointGet ); + AknsUtils::DeregisterControlPosition( control ); + + CleanupStack::PopAndDestroy( control ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUDeregisterControlPositionL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUDeregisterControlPositionL( CStifItemParser& aItem ) + { + return TestURegisterControlPositionL( aItem ); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestUGetControlPositionL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestUGetControlPositionL( CStifItemParser& aItem ) + { + return TestURegisterControlPositionPL( aItem ); + + } + + diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsblockswu.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsblockswu.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,59 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsWallpaperUtils.h +* +*/ + + +#include +#include + +#include "testsdkskins.h" + +const TInt KLength = 20; + +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestWUSetIdleWallpaper +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestWUSetIdleWallpaper( CStifItemParser& /*aItem*/ ) + { + _LIT( KFileName, "wallpaperutils" ); + TBuf fileName( KFileName ); + AknsWallpaperUtils::SetIdleWallpaper( fileName, CCoeEnv::Static() ); + + return KErrNone; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkins::TestWUSetSlidesetWallpaperL +// ----------------------------------------------------------------------------- +TInt CTestSDKSkins::TestWUSetSlidesetWallpaperL( CStifItemParser& /*aItem*/ ) + { + _LIT( KFileName, "wallpaperutils" ); + TBuf fileName( KFileName ); + + CDesCArray* array = new (ELeave) CDesCArrayFlat(1); + CleanupStack::PushL( array ); + STIF_ASSERT_NOT_NULL( array ); + + array->AppendL( fileName ); + AknsWallpaperUtils::SetSlidesetWallpaper( *array, CCoeEnv::Static() ); + + CleanupStack::PopAndDestroy( array ); + + return KErrNone; + + } diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinscontrol.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinscontrol.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,128 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsDrawUtils.h +* +*/ + + +#include +#include + +#include "testsdkskinscontrol.h" + + +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::NewL +// ----------------------------------------------------------------------------- +// +CTestSDKSkinsControl* CTestSDKSkinsControl::NewL() + { + CTestSDKSkinsControl* self = new (ELeave) CTestSDKSkinsControl; + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::~CTestSDKSkinsControl +// ----------------------------------------------------------------------------- +// +CTestSDKSkinsControl::~CTestSDKSkinsControl() + { + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::CTestSDKSkinsControl +// ----------------------------------------------------------------------------- +// +CTestSDKSkinsControl::CTestSDKSkinsControl(){}; + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::ConstructL +// ----------------------------------------------------------------------------- +// +void CTestSDKSkinsControl::ConstructL() + { + CreateWindowL(); + SetRect(CEikonEnv::Static()->EikAppUi()->ClientRect()); + ActivateL(); + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::OfferKeyEventL +// ----------------------------------------------------------------------------- +// +TKeyResponse CTestSDKSkinsControl::OfferKeyEventL(const TKeyEvent& /*aKeyEvent*/, + TEventCode /*aType*/) + { + return EKeyWasConsumed; + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::Draw +// ----------------------------------------------------------------------------- +// +void CTestSDKSkinsControl::Draw(const TRect& /*aRect*/) const + { + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::CountComponentControls +// ----------------------------------------------------------------------------- +// +TInt CTestSDKSkinsControl::CountComponentControls() const + { + return 0; + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::ComponentControl +// ----------------------------------------------------------------------------- +// +CCoeControl* CTestSDKSkinsControl::ComponentControl(TInt /*aIndex*/) const + { + return NULL; + + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::SizeChanged +// ----------------------------------------------------------------------------- +// +void CTestSDKSkinsControl::SizeChanged() + { + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::SizeChanged +// ----------------------------------------------------------------------------- +// +void CTestSDKSkinsControl::ActivateGc() + { + CCoeControl::ActivateGc(); + } + +// ----------------------------------------------------------------------------- +// CTestSDKSkinsControl::SizeChanged +// ----------------------------------------------------------------------------- +// +void CTestSDKSkinsControl::DeactivateGc() + { + CCoeControl::DeactivateGc(); + } + diff -r e13acd883fbe -r 09c37dab59b4 common/tools/ats/smoketest/uiresources/src/testsdkskinsobjectprovider.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/common/tools/ats/smoketest/uiresources/src/testsdkskinsobjectprovider.cpp Wed Nov 11 13:04:22 2009 +0000 @@ -0,0 +1,32 @@ +/* +* Copyright (c) 2002 - 2007 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of the License "Symbian Foundation License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: Test AknsDrawUtils.h +* +*/ + + +#include +#include + +#include "testsdkskinsobjectprovider.h" + + +// ============================ MEMBER FUNCTIONS =============================== +// ----------------------------------------------------------------------------- +// CTestSDKSkinsObjectProvider::MopSupplyObject +// ----------------------------------------------------------------------------- +TTypeUid::Ptr CTestSDKSkinsObjectProvider::MopSupplyObject( TTypeUid /*aId*/ ) + { + return TTypeUid::Null(); + }