diff -r 000000000000 -r 5d03bc08d59c windowing/windowserver/tcsc/cwsgcecsc.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/windowing/windowserver/tcsc/cwsgcecsc.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,656 @@ +// Copyright (c) 2008-2009 Nokia Corporation and/or its subsidiary(-ies). +// All rights reserved. +// This component and the accompanying materials are made available +// under the terms of "Eclipse Public License v1.0" +// which accompanies this distribution, and is available +// at the URL "http://www.eclipse.org/legal/epl-v10.html". +// +// Initial Contributors: +// Nokia Corporation - initial contribution. +// +// Contributors: +// +// Description: +// @file +// +// + +#include +#include +#include "cwsgcecsc.h" +#include "extendtef.h" +#include "teflogextensions.h" +#include "testscreencapture.h" + + +#if defined(__X86GCC__) +extern "C" TInt atexit(void (*function)(void)) + { + return KErrNone; + } +#endif + +void TefUnitFailLeaveL() + { + User::Leave(KErrTEFUnitFail); + } + +CWSGceCsc::CWSGceCsc() + { + } + +CWSGceCsc::~CWSGceCsc() + { + } + +/** +Common set up code for all tests. + +Creates the session and window group for further windows, plus a simple white +background to obscure any unwanted stuff behind the test. Sets up the surface +update session and surface manager, to work with surfaces. Creates a screen +device for use in the tests. +*/ +void CWSGceCsc::SetupL() + { + CWsGceCscBase::SetupL(); + } + +/** +Common tear down code for all tests. + +Windows, group and session created are closed. Screen device is destroyed. +Surfaces, manager and update session are closed. +*/ +void CWSGceCsc::TearDownL() + { + CWsGceCscBase::TearDownL(); + } + +CTestSuite* CWSGceCsc::CreateSuiteL( const TDesC& aName) + { + SUB_SUITE; + ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_101L); + ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_102L); + ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_103L); + ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_104L); + ADD_WSGCE_TEST_STEP(CWSGceCsc, GRAPHICS_WSERV_CSC_105L); + END_SUITE; + } + +/** + @SYMTestCaseID GRAPHICS_WSERV_CSC_101L + + @SYMTestCaseDesc Compare the screen composition using the new and legacy API + + @SYMPREQ CSC + + @SYMTestStatus Implemented + + @SYMTestPriority 1 + + @SYMTestPurpose To check that the screen composition retrieved using the new and legacy APIs + + @SYMTestActions Initialization. + Construct a background opaque window. + Create two bitmaps with the size equal with the composition. + Draw something on the screen. + Use legacy API CopyScreenToBitmap() to copy the screen to first bitmap. + Use the the new API to copy the composition of the screen. + Compare the results. + + @SYMTestExpectedResults The bitmap should be identical +*/ +void CWSGceCsc::GRAPHICS_WSERV_CSC_101L() + { + TRect screen(iScreenDevice->SizeInPixels()); + RWindow nonSurfacedWindow(iSession); + iTestName.Format(_L("GRAPHICS_WSERV_CSC_101L")); + + INFO_PRINTF2(_L("%S"),&iTestName); + iDisplayMode = iScreenDevice->DisplayMode(); // Get default display mode + + ConstructOpaqueWindowLC(nonSurfacedWindow, + iCyan, + 0, + TPoint(0, 0), + screen.Size()); + iSession.Flush(); + Pause(1000); + + MTestScreenCapture* csc = static_cast (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf)); + ASSERT_NOT_NULL(csc); + + TSize compositionScreenSize; + + User::LeaveIfError(csc->GetCompositedSize(compositionScreenSize)); + + CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp1); + User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU)); + + CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp2); + User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor16MU)); + + iSession.Flush(); + Pause(200); + + iScreenDevice->CopyScreenToBitmap(bmp1); + User::LeaveIfError(csc->ComposeScreen(*bmp2)); + + SetBackgroundColorWindow(nonSurfacedWindow, iRed); + iSession.Flush(); + + Pause(500); + + iGc->Activate(nonSurfacedWindow); + iGc->BitBlt(TPoint(0, 0), bmp1); + iGc->Deactivate(); + iSession.Flush(); + Pause(500); + + SetBackgroundColorWindow(nonSurfacedWindow, iWhite); + iSession.Flush(); + Pause(500); + + iGc->Activate(nonSurfacedWindow); + iGc->BitBlt(TPoint(0, 0), bmp2); + iGc->Deactivate(); + iSession.Flush(); + Pause(500); + + ASSERT_TRUE(Compare(*bmp1, *bmp2)); + + if (GCEIsSupported()) + { + iUtility->DestroyAll(); + } + + CleanupStack::PopAndDestroy(bmp2); + CleanupStack::PopAndDestroy(bmp1); + CleanupStack::PopAndDestroy(&nonSurfacedWindow); + iSession.Flush(); + Pause(1000); + } + +void CWSGceCsc::DrawBasicPattern (RWindow& aWin) + { + TSize rectSize(100, 100); + aWin.Invalidate(); + aWin.BeginRedraw(); + iGc->Activate(aWin); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(KRgbDarkRed); + iGc->DrawRect(TRect(TPoint(35, 5), rectSize)); + iGc->SetBrushColor(KRgbBlack); + iGc->DrawRect(TRect(TPoint(55, 15), rectSize)); + iGc->SetBrushColor(KRgbDarkBlue); + iGc->DrawRect(TRect(TPoint(75, 35), rectSize)); + iGc->SetBrushColor(KRgbYellow); + iGc->DrawRect(TRect(TPoint(95, 55), rectSize)); + iGc->Deactivate(); + aWin.EndRedraw(); + iSession.Flush(); + Pause(500); + } + +/** + @SYMTestCaseID GRAPHICS_WSERV_CSC_102L + + @SYMTestCaseDesc Compare the screen composition using the new and legacy API + + @SYMPREQ CSC + + @SYMTestStatus Implemented + + @SYMTestPriority 1 + + @SYMTestPurpose To check that the screen composition retrieved using the new and legacy APIs + + @SYMTestActions Initialization. + Draw a pattern on the screen + Retrieve to a bitmap the UI content using the legacy API + Blank the screen. + Display the retrieved content to a surface + Retrieve the composited content + Compare the UI content with the composited content + NOTE:assumes current screen mode is at 0 offset + + @SYMTestExpectedResults The UI content should be identical with the composited content +*/ +void CWSGceCsc::GRAPHICS_WSERV_CSC_102L() + { + TRect screen(iScreenDevice->SizeInPixels()); + RWindow testWindow(iSession); + RWindow surfacedTestWindow(iSession); + TSurfaceId surfaceID; + + MTestScreenCapture* csc = static_cast (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf)); + ASSERT_NOT_NULL(csc); + + TSize compositionScreenSize; + User::LeaveIfError(csc->GetCompositedSize(compositionScreenSize)); + + iTestName.Format(_L("GRAPHICS_WSERV_CSC_102")); + INFO_PRINTF2(_L("%S"),&iTestName); + + iDisplayMode = iScreenDevice->DisplayMode(); + + TRAPD(err, surfaceID = iUtility->CreateSurfaceL(compositionScreenSize, + KSurfaceFormat, + compositionScreenSize.iWidth * KBytesPerPixel)); + ASSERT_EQUALS(err,KErrNone); + + ConstructOpaqueWindowLC(testWindow, + iWhite, + 0, + TPoint(0, 0), + compositionScreenSize); + + iSession.Flush(); + Pause(100); + + CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp1); + User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU)); + + CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp2); + User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor16MU)); + + iSession.Flush(); + Pause(500); + + SetBackgroundColorWindow(testWindow, iWhite); + DrawBasicPattern (testWindow); + + iScreenDevice->CopyScreenToBitmap(bmp1); + iSession.Flush(); + Pause(100); + + ConstructOpaqueSurfacedWindowLC(surfacedTestWindow, + iRed, + 0, + TPoint(0, 0), + compositionScreenSize, + surfaceID); + + TRAP(err,iUtility->FillSurfaceL(surfaceID, iCyan)); + ASSERT_EQUALS(err,KErrNone); + iSession.Flush(); + Pause(500); + + TRAP(err, iUtility->CopyBitmapToSurfaceL(surfaceID, *bmp1)); + ASSERT_EQUALS(err,KErrNone); + iSession.Flush(); + Pause(500); + + User::LeaveIfError(csc->ComposeScreen(*bmp2)); + + ASSERT_TRUE(Compare(*bmp1, *bmp2)); + + iUtility->DestroyAll(); + CleanupStack::PopAndDestroy(&surfacedTestWindow); + CleanupStack::PopAndDestroy(bmp2); + CleanupStack::PopAndDestroy(bmp1); + CleanupStack::PopAndDestroy(&testWindow); + iSession.Flush(); + Pause(1000); + } + +/** + @SYMTestCaseID GRAPHICS_WSERV_CSC_103L + + @SYMTestCaseDesc Test TranslateExtent + + @SYMPREQ CSC + + @SYMTestStatus Implemented + + @SYMTestPriority 1 + + @SYMTestPurpose To check that the correct translated extent is returned to the client + + @SYMTestActions Initialization + Change to app mode with offset and 90 degrees rotation + Translate a rectangle corresponding to the original app mode + Compare the expected rectangle with the translated rectangle + + @SYMTestExpectedResults The translated rectangle should take into account the offset and rotation + and be equal to the expected rectangle +*/ +void CWSGceCsc::GRAPHICS_WSERV_CSC_103L() + { + TRect screen(iScreenDevice->SizeInPixels()); + RWindow testWindow(iSession); + + iTestName.Format(_L("GRAPHICS_WSERV_CSC_103L")); + INFO_PRINTF2(_L("%S"),&iTestName); + + iDisplayMode = iScreenDevice->DisplayMode(); + + ConstructOpaqueWindowLC(testWindow, + iWhite, + 0, + TPoint(0, 0), + screen.Size()); + iSession.Flush(); + Pause(1000); + + // Get the screen modes + RArray modeList; + TInt err = iScreenDevice->GetScreenSizeModeList(&modeList); + ASSERT_TRUE(err > 1); //2 modes expected + ASSERT_TRUE(modeList.Count() > 1); //2 modes expected + + // The initial extent and the expected translated extent + TRect initial(TPoint(10,10), TSize(20,30)); + TRect extent(initial); + TRect expected(TPoint(15,15), TSize(20,30)); + + // Change app mode to 5 pixels offset + iScreenDevice->SetAppScreenMode(modeList[1]); + iScreenDevice->SetScreenMode(modeList[1]); + iSession.Flush(); + Pause(100); + + TPoint origin = iScreenDevice->GetCurrentScreenModeScaledOrigin(); + if(origin != TPoint(0,0)) + { + // Calculate the new extent + MTestScreenCapture* csc = static_cast (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf)); + ASSERT_NOT_NULL(csc); + csc->TranslateExtent(initial, extent); + ASSERT_TRUE(extent == expected); + } + else + { + INFO_PRINTF1(_L("Non zero offset not supported")); + } + // Change app mode + iScreenDevice->SetAppScreenMode(modeList[0]); + iScreenDevice->SetScreenMode(modeList[0]); + iSession.Flush(); + Pause(100); + + modeList.Close(); + CleanupStack::PopAndDestroy(&testWindow); + iSession.Flush(); + Pause(1000); + } + +/** + @SYMTestCaseID GRAPHICS_WSERV_CSC_104L + + @SYMTestCaseDesc Compare the screen composition using bitmaps with different display modes + + @SYMPREQ CSC + + @SYMTestStatus Implemented + + @SYMTestPriority 1 + + @SYMTestPurpose To check that bitmaps with different display modes + + @SYMTestActions Initialization. + Draw a pattern on the screen + Retrieve to a bitmap the UI content using the legacy API + Blank the screen. + Display the retrieved content to a surface + Retrieve the composited content to a 2nd bitmap + Compare the UI content with the composited content + + @SYMTestExpectedResults The bitmaps format should not match and should return KErrArgument +*/ +void CWSGceCsc::GRAPHICS_WSERV_CSC_104L() + { + TRect screen(iScreenDevice->SizeInPixels()); + RWindow testWindow(iSession); + RWindow surfacedTestWindow(iSession); + TSurfaceId surfaceID; + + MTestScreenCapture* csc = static_cast (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf)); + ASSERT_NOT_NULL(csc); + + TSize compositionScreenSize; + User::LeaveIfError(csc->GetCompositedSize(compositionScreenSize)); + + iTestName.Format(_L("GRAPHICS_WSERV_CSC_102")); + INFO_PRINTF2(_L("%S"),&iTestName); + + iDisplayMode = iScreenDevice->DisplayMode(); + + TRAPD(err, surfaceID = iUtility->CreateSurfaceL(compositionScreenSize, + KSurfaceFormat, + compositionScreenSize.iWidth * KBytesPerPixel)); + ASSERT_EQUALS(err,KErrNone); + + ConstructOpaqueWindowLC(testWindow, + iWhite, + 0, + TPoint(0, 0), + compositionScreenSize); + + iSession.Flush(); + Pause(100); + + CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp1); + User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU)); + + // Invalid bitmap display mode + CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp2); + User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor256)); + + iSession.Flush(); + Pause(500); + + // Draw a pattern using WServ + SetBackgroundColorWindow(testWindow, iWhite); + + TSize rectSize(100, 100); + testWindow.Invalidate(); + testWindow.BeginRedraw(); + iGc->Activate(testWindow); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(KRgbDarkRed); + iGc->DrawRect(TRect(TPoint(35, 5), rectSize)); + iGc->SetBrushColor(KRgbBlack); + iGc->DrawRect(TRect(TPoint(55, 15), rectSize)); + iGc->SetBrushColor(KRgbDarkBlue); + iGc->DrawRect(TRect(TPoint(75, 35), rectSize)); + iGc->SetBrushColor(KRgbYellow); + iGc->DrawRect(TRect(TPoint(95, 55), rectSize)); + iGc->Deactivate(); + testWindow.EndRedraw(); + iSession.Flush(); + Pause(500); + + iScreenDevice->CopyScreenToBitmap(bmp1); + iSession.Flush(); + Pause(100); + + ConstructOpaqueSurfacedWindowLC(surfacedTestWindow, + iRed, + 0, + TPoint(0, 0), + compositionScreenSize, + surfaceID); + + TRAP(err,iUtility->FillSurfaceL(surfaceID, iCyan)); + ASSERT_EQUALS(err,KErrNone); + iSession.Flush(); + Pause(500); + + TRAP(err, iUtility->CopyBitmapToSurfaceL(surfaceID, *bmp1)); + ASSERT_EQUALS(err,KErrNone); + iSession.Flush(); + Pause(500); + + // negative test, it should fail wit KErrArgument + TInt ret = csc->ComposeScreen(*bmp2); + ASSERT_EQUALS(ret, KErrArgument); + + iUtility->DestroyAll(); + CleanupStack::PopAndDestroy(&surfacedTestWindow); + CleanupStack::PopAndDestroy(bmp2); + CleanupStack::PopAndDestroy(bmp1); + CleanupStack::PopAndDestroy(&testWindow); + iSession.Flush(); + Pause(1000); + } + +/** + @SYMTestCaseID GRAPHICS_WSERV_CSC_105L + @SYMTestCaseDesc Correct bitmap size returned when in small screen mode + @SYMDEF DEF139191 + @SYMPREQ CSC + @SYMTestStatus Implemented + @SYMTestPriority 1 + @SYMTestPurpose Checking GetCompositedSize is correct on gce & acceptable behaviour in non gce mode + @SYMTestActions For every available screen mode + Get size from GetCompositedSize + Draw some coloured rectangles on screen + If gce, do a full screen surface, and paste the coloured rectangles into the surface + ComposeScreen - bitmap 1 should be the same as bitmap 2 + Note - non GCE mode - GetCompositedSize returns unrotated appmode size, so only + compares the intersection of that with actual screen size + Note - gce mode - GetCompositedSize returns actual rotated screen size, so + does a complete screen comparison + @SYMTestExpectedResults All asserts should complete. Comparison should succeed! +*/ +void CWSGceCsc::GRAPHICS_WSERV_CSC_105L() + { + iTestName.Format(_L("GRAPHICS_WSERV_CSC_105")); + INFO_PRINTF2(_L("%S"),&iTestName); + TInt err; + //get list of modes + RArray screenModes; + err = iScreenDevice->GetScreenSizeModeList(&screenModes); + ASSERT_TRUE (err > 0); + //get first mode info + TPixelsAndRotation firstModeInfo; + iScreenDevice->GetScreenModeSizeAndRotation(screenModes[0],firstModeInfo); + + //make sure csc is available + MTestScreenCapture* csc = static_cast (iScreenDevice->GetInterface(MTestScreenCapture::KUidTestScreenCaptureIf)); + ASSERT_NOT_NULL(csc); + + TBool differentSizes = EFalse; + TSizeMode currentModeInfo; + TSize compositionScreenSize; + //for every screen mode + for (TInt ii = 0; ii < screenModes.Count(); ++ii && !differentSizes) + { + //set mode + iScreenDevice->SetAppScreenMode(screenModes[ii]); + iScreenDevice->SetScreenMode(screenModes[ii]); + iSession.Flush(); + Pause(100); + //get mode info + currentModeInfo = iScreenDevice->GetCurrentScreenModeAttributes(); + if (currentModeInfo.iScreenSize.iWidth != firstModeInfo.iPixelSize.iWidth || + currentModeInfo.iScreenSize.iHeight != firstModeInfo.iPixelSize.iHeight || + currentModeInfo.iRotation != firstModeInfo.iRotation) + { //note that we have modes of different sizes / rotations + differentSizes = ETrue; + } + + RWindow testWindow(iSession); + RWindow surfacedTestWindow(iSession); + TSurfaceId surfaceID; + + err = csc->GetCompositedSize(compositionScreenSize); + ASSERT_EQUALS (err,KErrNone); + iDisplayMode = iScreenDevice->DisplayMode(); + + if (GCEIsSupported()) + { //create a surface + TRAP(err, surfaceID = iUtility->CreateSurfaceL(compositionScreenSize, + KSurfaceFormat, + compositionScreenSize.iWidth * KBytesPerPixel)); + ASSERT_EQUALS(err,KErrNone); + } + + //create a basic window + ConstructOpaqueWindowLC(testWindow, + iWhite, + 0, + -currentModeInfo.iOrigin, + compositionScreenSize); //negative origin to ensure it fills screen, not app mode area + iSession.Flush(); + Pause(100); + + //bitmap 1 to compare against + CFbsBitmap *bmp1 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp1); + User::LeaveIfError(bmp1->Create(compositionScreenSize, EColor16MU)); + //bitmap 2 to pass into csc + CFbsBitmap *bmp2 = new (ELeave) CFbsBitmap; + CleanupStack::PushL(bmp2); + User::LeaveIfError(bmp2->Create(compositionScreenSize, EColor16MU)); + + //draw coloured rectangles in the test window + SetBackgroundColorWindow(testWindow, iWhite); + DrawBasicPattern (testWindow); + + //copy screen to bitmap 1 + err = iScreenDevice->CopyScreenToBitmap(bmp1); + ASSERT_EQUALS (err,KErrNone); + iSession.Flush(); + Pause(100); + + if (GCEIsSupported()) + { //place a window with a surface into the screen + ConstructOpaqueSurfacedWindowLC(surfacedTestWindow, + iRed, + 0, + -currentModeInfo.iOrigin, + compositionScreenSize, + surfaceID); //negative origin to ensure it fills screen,not app mode area + + //make surface boring cyan + TRAP(err,iUtility->FillSurfaceL(surfaceID, iCyan)); + ASSERT_EQUALS(err,KErrNone); + iSession.Flush(); + Pause(300); + + //paste bitmap 1 contents into the surface + TRAP(err, iUtility->CopyBitmapToSurfaceL(surfaceID, *bmp1)); + ASSERT_EQUALS(err,KErrNone); + iSession.Flush(); + Pause(300); + } + + //use csc to get a copy of the screen + err = csc->ComposeScreen(*bmp2); + ASSERT_EQUALS (err, KErrNone); + + //should match the original bitmap copy of the screen + ASSERT_TRUE(Compare(*bmp1, *bmp2)); + + if (GCEIsSupported()) + { + iUtility->DestroyAll(); + CleanupStack::PopAndDestroy(&surfacedTestWindow); + } + else + { + surfacedTestWindow.Close(); + } + CleanupStack::PopAndDestroy(bmp2); + CleanupStack::PopAndDestroy(bmp1); + CleanupStack::PopAndDestroy(&testWindow); + iSession.Flush(); + Pause(300); + } + if (!differentSizes) + { + INFO_PRINTF1(_L("Didn't find screen modes of different sizes - test inconclusive")); + } + iScreenDevice->SetAppScreenMode(screenModes[0]); + iScreenDevice->SetScreenMode(screenModes[0]); + screenModes.Close(); + }