diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/tredrawstoreperf.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicstest/uibench/src/tredrawstoreperf.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,401 @@ +// 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 + @test + @internalComponent - Internal Symbian test code +*/ + +#include "tredrawstoreperf.h" + +const TInt KIterationsToTest = 100; // Number of iterations to run tests +TRect seg1; +TRect seg2; +TRect seg3; +TRect seg4; +TRect seg5; +TRect seg6; + +CTRedrawstorePerf::CTRedrawstorePerf() + { + SetTestStepName(KTRedrawstorePerf); + } + +CTRedrawstorePerf::~CTRedrawstorePerf() + { + delete iGc; + delete iScreenDevice; + iWin.Close(); + iWinGroup.Close(); + iWs.Close(); + } + +void CTRedrawstorePerf::CreateRWindowL() + { + iWin = RWindow(iWs); + User::LeaveIfError(iWin.Construct(iWinGroup, 2)); + User::LeaveIfError(iWin.SetTransparencyAlphaChannel()); + iWin.SetBackgroundColor(TRgb(255,255,255,128 )); + iWin.Activate(); + Init(); + } + +void CTRedrawstorePerf::Init() + { + // Create RedrawStore segments + seg1=TRect( TSize( iWin.Size() ) ); + seg2=TRect( TPoint(50,0), seg1.Center()-TPoint(20,20) ); + seg3=TRect( TPoint(seg1.Width()/2 + 20, 0), TPoint(seg1.Width()-50, seg1.Height()/2 -20 ) ); + seg4=TRect( TPoint(50, seg1.Height()/2 + 20 ), TPoint(seg1.Width()/2 - 20, seg1.Height() ) ); + seg5=TRect( seg1.Center()+TPoint(20,20), TPoint( seg1.Width()-50, seg1.Height()) ); + seg6=TRect( seg1.Center()-TPoint(75,75), TSize(150,150) ); + } + +/** +Override of base class virtual + +@return - TVerdict code +*/ +TVerdict CTRedrawstorePerf::doTestStepPreambleL() + { + CTe_graphicsperformanceSuiteStepBase::doTestStepPreambleL(); + return TestStepResult(); + } + +/** +Override of base class pure virtual +Our implementation only gets called if the base class doTestStepPreambleL() did +not leave. That being the case, the current test result value will be EPass. + +@return TVerdict code +*/ +TVerdict CTRedrawstorePerf::doTestStepL() + { + User::LeaveIfError(iWs.Connect()); + iScreenDevice = new(ELeave) CWsScreenDevice(iWs); + User::LeaveIfError(iScreenDevice->Construct(0)); // screen number (0 is first screen) + iGc = new(ELeave) CWindowGc(iScreenDevice); + User::LeaveIfError(iGc->Construct()); + iWinGroup = RWindowGroup(iWs); + User::LeaveIfError(iWinGroup.Construct(1, EFalse)); + + SetTestStepID(_L("GRAPHICS-UI-BENCH-0137")); + TestStoreWithFewRectsL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0167")); + TestStoreWithManyRectsL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0139")); + TestPlaybackWithFewRectsL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0168")); + TestPlaybackWithManyRectsL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0141")); + TestStoreAndPlaybackWithFewRectsL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0142")); + TestStoreAndPlaybackWithManyRectsL(); + RecordTestResultL(); + + return TestStepResult(); + } + +void CTRedrawstorePerf::TestStoringL(const TDesC& aTestName, TRedrawstoreTestCase aTestCase) + { + iProfiler->InitResults(); + for (TInt count=0; countActivate(iWin); + iProfiler->StartTimer(); + if (aTestCase==EFragmentStore) + { + PopulateRedrawStore(); + } + else if (aTestCase==EFragmentStoreWithManyRects) + { + PopulateRedrawStoreWithManyRects(); + } + iProfiler->MarkResultSetL(); + iGc->Deactivate(); + iWin.Close(); + } + iProfiler->ResultsAnalysis(aTestName, 0, 0, iScreenDevice->DisplayMode(), KIterationsToTest); + } + +void CTRedrawstorePerf::TestPlayingbackL(const TDesC& aTestName, TRedrawstoreTestCase aTestCase) + { + iProfiler->InitResults(); + for (TInt count=0; countActivate(iWin); + if (aTestCase==EFragmentStore) + { + PopulateRedrawStore(); + } + else if (aTestCase==EFragmentStoreWithManyRects) + { + PopulateRedrawStoreWithManyRects(); + } + iWin.SetVisible( EFalse ); + iWs.Finish(); + iProfiler->StartTimer(); + iWin.SetVisible( ETrue ); // Make iWin visible to trigger playing back of redraw cmds + iWs.Finish(); + iProfiler->MarkResultSetL(); + iGc->Deactivate(); + iWin.Close(); + } + iProfiler->ResultsAnalysis(aTestName, 0, 0, iScreenDevice->DisplayMode(), KIterationsToTest); + } + +void CTRedrawstorePerf::TestStoringAndPlayingbackL(const TDesC& aTestName, TRedrawstoreTestCase aTestCase) + { + iProfiler->InitResults(); + for (TInt count=0; countActivate(iWin); + iProfiler->StartTimer(); + if (aTestCase==EFragmentStore) + { + PopulateRedrawStore(); + } + else if (aTestCase==EFragmentStoreWithManyRects) + { + PopulateRedrawStoreWithManyRects(); + } + iWs.Finish(); + iProfiler->MarkResultSetL(); + iGc->Deactivate(); + iWin.Close(); + } + iProfiler->ResultsAnalysis(aTestName, 0, 0, iScreenDevice->DisplayMode(), KIterationsToTest); + } + + +// Fragments the fullscreen window by creating segments and drawing overlaping rects across the whole window +void CTRedrawstorePerf::PopulateRedrawStoreWithManyRects() + { + iWin.Invalidate(); + iWin.BeginRedraw(); + iGc->SetBrushColor(KRgbCyan); + iGc->Clear(); + iWin.EndRedraw(); + + TInt x=0; + TBool offset=EFalse; + for(TInt y=0; y<=seg1.Height(); y+=20) + { + if (offset) + { + x=x+20; + offset=EFalse; + } + else + { + offset=ETrue; + } + + for(; x<=seg1.Width(); x+=40) + { + TRect seg(TPoint(x,y),TSize(30,30)); + iWin.Invalidate(seg); + iWin.BeginRedraw(seg); + iGc->SetPenColor(KRgbRed); + iGc->DrawRect(seg); + iWin.EndRedraw(); + } + x=0; + } + } + +void CTRedrawstorePerf::PopulateRedrawStore() + { + iWin.Invalidate(seg1); + iWin.BeginRedraw(); + iGc->SetPenColor(KRgbBlack); + iGc->Reset(); + iGc->DrawRect(seg1); + iWin.EndRedraw(); + + iWin.Invalidate(seg2); + iWin.BeginRedraw(seg2); + iGc->SetPenColor(KRgbBlack); + iGc->DrawRect(seg2); + iWin.EndRedraw(); + + iWin.Invalidate(seg3); + iWin.BeginRedraw(seg3); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(KRgbBlue); + iGc->DrawRect(seg3); + iWin.EndRedraw(); + + iWin.Invalidate(seg4); + iWin.BeginRedraw(seg4); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(KRgbGreen); + iGc->DrawRect(seg4); + iWin.EndRedraw(); + + iWin.Invalidate(seg5); + iWin.BeginRedraw(seg5); + iGc->SetBrushStyle(CGraphicsContext::ESolidBrush); + iGc->SetBrushColor(KRgbRed); + iGc->DrawRect(seg5); + iWin.EndRedraw(); + + iWin.Invalidate(seg6); + iWin.BeginRedraw(seg6); + iGc->Reset(); + iGc->DrawRect(seg6); + iWin.EndRedraw(); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0137 + + @SYMTestCaseDesc + The test case mesures the time it takes to store redraw commands + + @SYMTestActions + A fullscreen window(RWindow) is created and made invisible. The window is then segmented + 6 times, drawn to storing the corresponding Redraw Commands and destroyed. + + @SYMTestExpectedResults + Test should pass and display average test time per iteration +*/ +void CTRedrawstorePerf::TestStoreWithFewRectsL() + { + _LIT(KTestName, "TestStoreWithFewRectsL"); + TestStoringL(KTestName,EFragmentStore); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0167 + + @SYMTestCaseDesc + A pathological test case. It measures the time it takes to store Redraw commands corresponding to + hundereds of overlapping segments + + @SYMTestActions + A fullscreen window(RWindow) is created and made invisible. The window is then segmented + a few hundered times, drawn to storing the corresponding Redraw Commands and destroyed. + + @SYMTestExpectedResults + Test should pass and display average test time per iteration +*/ +void CTRedrawstorePerf::TestStoreWithManyRectsL() + { + _LIT(KTestName, "TestStoreWithManyRectsL"); + TestStoringL(KTestName,EFragmentStoreWithManyRects); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0139 + + @SYMTestCaseDesc + This test case measures the time it takes to play back the commands from the RedrawStore + + @SYMTestActions + A fullscreen window(RWindow) is created, segmented 6 times and drawn to storing the corresponding + Redraw Commands. It is made invisible and then visible again which triggers the playing back of + commands.The time is measured between when the window is made visible and the screen has been rendered. + The time is logged and window is destroyed. + + @SYMTestExpectedResults + Test should pass and display average test time per iteration +*/ +void CTRedrawstorePerf::TestPlaybackWithFewRectsL() + { + _LIT(KTestName, "TestPlaybackWithFewRectsL"); + TestPlayingbackL(KTestName,EFragmentStore); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0168 + + @SYMTestCaseDesc + A pathological test case. It measures the time it takes to play back the commands corresponding to + hundereds of overlapping segments, from the RedrawStore + + @SYMTestActions + A fullscreen window(RWindow) is created, segmented a few hundered times and drawn to storing the + corresponding Redraw Commands. It is made invisible and then visible again which triggers the playing + back of commands.The time is measured between when the window is made visible and the screen has been + rendered. The time is logged and window is destroyed. + + @SYMTestExpectedResults + Test should pass and display average test time per iteration +*/ +void CTRedrawstorePerf::TestPlaybackWithManyRectsL() + { + _LIT(KTestName, "TestPlaybackWithManyRectsL"); + TestPlayingbackL(KTestName,EFragmentStoreWithManyRects); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0141 + + @SYMTestCaseDesc + This test cases measures the time it takes to store and play back redraw commands from the RedrawStore + + @SYMTestActions + A fullscreen window(RWindow) is created, segmented 6 times and drawn to storing the corresponding + Redraw Commands. Finish() is called then to trigger the playing back from RedrawStore. The time it takes + to store and play back commands is logged and window is destroyed. + + @SYMTestExpectedResults + Test should pass and display average test time per iteration +*/ +void CTRedrawstorePerf::TestStoreAndPlaybackWithFewRectsL() + { + _LIT(KTestName, "TestStoreAndPlaybackWithFewRectsL"); + TestStoringAndPlayingbackL(KTestName,EFragmentStore); + } + +/** + @SYMTestCaseID + GRAPHICS-UI-BENCH-0142 + + @SYMTestCaseDesc + A pathological test case. It measures the time it takes to store and playback commands corresponding to + hundereds of overlapping segments, from RedrawStore + + @SYMTestActions + A fullscreen window(RWindow) is created, segmented a few hundered times and drawn to storing the + corresponding Redraw Commands. Finish() is called then to render the screen by playing back the + commands from the RedrawStore. The time it takes to store and play back commands is logged and window + is destroyed. + + @SYMTestExpectedResults + Test should pass and display average test time per iteration +*/ +void CTRedrawstorePerf::TestStoreAndPlaybackWithManyRectsL() + { + _LIT(KTestName, "TestStoreAndPlaybackWithManyRectsL"); + TestStoringAndPlayingbackL(KTestName,EFragmentStoreWithManyRects); + }