diff -r 000000000000 -r 5d03bc08d59c graphicstest/uibench/src/tsimpledrawing_directgdi.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/graphicstest/uibench/src/tsimpledrawing_directgdi.cpp Tue Feb 02 01:47:50 2010 +0200 @@ -0,0 +1,621 @@ +// 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 "tsimpledrawing_directgdi.h" + +#include + +// The number of iterations to perform for each test. All but the line drawing tests +// will use this figure. Line tests use the figure below as more repetition is needed. +const TInt KIterationsToTest = 200; + +// This value must not be greater than the extents of the pixmap, otherwise +// line-drawing tests will get clipped and results will be distorted. +const TInt KLineDrawingIterationsToTest = 750; + +// Number of iterations for all text-rendering tests. +const TInt KTextDrawingIterationsToTest = 2000; + +_LIT(KTestBitmap, "z:\\system\\data\\uibench_24bit.mbm"); + +// The following constants should match those in tsimpledrawing.cpp for a like-for-like +// comparison. +// +_LIT(KTextPhrase, "abcdefABCDEF0123456789"); +const TInt KTextPhraseLength = KTextPhrase().Length(); + +CTSimpleDrawingDirectGdi::CTSimpleDrawingDirectGdi() + { + SetTestStepName(KTSimpleDrawingPerfDirectGdi); + } + +CTSimpleDrawingDirectGdi::~CTSimpleDrawingDirectGdi() + { + } + +TVerdict CTSimpleDrawingDirectGdi::doTestStepPreambleL() + { + CTDirectGdiTestBase::doTestStepPreambleL(); + + iBitmap = new(ELeave) CFbsBitmap; + TInt ret = iBitmap->Load(KTestBitmap, 0, EFalse); + TESTL(ret == KErrNone); + INFO_PRINTF3(_L("Size of bitmap: %d x %d"), iBitmap->SizeInPixels().iWidth, iBitmap->SizeInPixels().iHeight); + + iScreenRect = TRect(1,1,GetPixmapSizeInPixels().iWidth, GetPixmapSizeInPixels().iHeight); + + 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 CTSimpleDrawingDirectGdi::doTestStepL() + { + // Perform all tests for each display mode. + for(TInt dispModeIndex = 0; dispModeIndex < iTargetPixelFormatArray.Count(); ++dispModeIndex) + { + iDisplayMode = TDisplayModeMapping::MapPixelFormatToDisplayMode(iTargetPixelFormatArray[dispModeIndex]); + if(SetTargetPixelFormatL(iDisplayMode)) + { + SetTestStepID(_L("GRAPHICS-UI-BENCH-0098")); + ClearingL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0099")); + LineDrawingL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0103")); + VerticalLinesL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0104")); + HorizontalLinesL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0101")); + CopyRectL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0102")); + DrawRectL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0100")); + ThickLinesL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0105")); + TextDrawingL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0171")); + TextDrawingAntiAliasedL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0106")); + TextDrawingWithOverheadL(); + RecordTestResultL(); + SetTestStepID(_L("GRAPHICS-UI-BENCH-0107")); + LargeTextDrawingL(); + RecordTestResultL(); + } + } + + CloseTMSGraphicsStep(); + return TestStepResult(); + } + +TVerdict CTSimpleDrawingDirectGdi::doTestStepPostambleL() + { + delete iBitmap; + iBitmap = NULL; + return CTDirectGdiTestBase::doTestStepPostambleL(); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0098 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measures the performance of Clear(). + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +For KIterationsToTest, clear the entire contents of the screen, and Finish(). +Calculate and log the results as a pixel rate. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::ClearingL() + { + _LIT (KTestName, "DirectGdi Clear Screen"); + + // Erase the target + iContext->Clear(); + iDGdiDriver->Finish(); + + iProfiler->InitResults (); + for (TInt count = 0; count < KIterationsToTest; count++) + { + iContext->Clear (iScreenRect); + iDGdiDriver->Finish (); + } + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + + iProfiler->ResultsAnalysisPixelRate(KTestName, 0, 0, iDisplayMode, KIterationsToTest, iScreenRect.Width()*iScreenRect.Height() ); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0099 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measures the performance of DrawLine(). +Draws a diagonal one pixel line. With each iteration, the left edge of the line is moved down +whilst the right edge is moved up, so that varying diagonals are tested. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +For KLineDrawingIterationsToTest, a line is drawn from from the left edge to the right edge of the +target. With each iteration, the left edge is moved down and the right edge is moved up to cover +varying angles of line. The lines are drawn with a pen size 1,1. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::LineDrawingL() + { + _LIT(KTestName, "DirectGdi Line Drawing"); + + DoLineDrawingL(KTestName(), TSize(1,1)); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0100 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measures the performance of DrawLine(). +Draws a diagonal thick line. With each iteration, the left edge is moved down and the right edge is +moved up so that varying angles are tested. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +For KLineDrawingIterationsToTest, a line is drawn from from the left edge to the right edge of the +target. With each iteration, the left edge is moved down and the right edge is moved up to cover +varying angles of line. The lines are drawn with a pen size 10,10. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::ThickLinesL() + { + _LIT(KTestName, "DirectGdi Draw Thick Lines"); + + DoLineDrawingL(KTestName(), TSize(10,10)); + + // Reset the pensize. + iContext->SetPenSize(TSize(1, 1)); + } + +/** +Helper method. Used by diagonal line drawing tests. +@param aName The test name. +@param aPenSize The pen size. +*/ +void CTSimpleDrawingDirectGdi::DoLineDrawingL(TPtrC aName, const TSize& aPenSize) + { + // Erase the target + iContext->Clear(); + iDGdiDriver->Finish(); + + TRect rect(iScreenRect); + iContext->SetPenSize(aPenSize); + iProfiler->InitResults(); + for (TInt count = KLineDrawingIterationsToTest; count > 0 ; --count) + { + iContext->DrawLine(rect.iTl, rect.iBr); + ++rect.iTl.iY; + --rect.iBr.iY; + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + WriteTargetOutput(aName); + + iProfiler->ResultsAnalysisPixelRate(aName, 0, 0, iDisplayMode, KLineDrawingIterationsToTest, rect.Width()*aPenSize.iHeight); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0101 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measure the performance of CopyRect(), by copying a rectangle from one part of the screen to another. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +For KIterationsToTest, the entire screen contents to a location 2 pixels away in X/Y. +Call Finish() to force the drawing to complete, before logging the time. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::CopyRectL() + { + _LIT(KTestName, "DirectGdi CopyRect"); + + // Erase the target + iContext->Clear(); + iDGdiDriver->Finish(); + + iProfiler->InitResults(); + for (TInt count = 0; count < KIterationsToTest; count++) + { + iContext->CopyRect(TPoint(2,2), iScreenRect); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + WriteTargetOutput(KTestName()); + + iProfiler->ResultsAnalysisPixelRate(KTestName, 0, 0, iDisplayMode, KIterationsToTest, iScreenRect.Width()*iScreenRect.Height()); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0102 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measure the performance of DrawRect(), with a patterned fill. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +Set bitmap as brush and draw rectangle using this brush for KIterationsToTest. +Call Finish() to force the drawing to complete, before logging the time. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::DrawRectL() + { + _LIT(KTestName, "DirectGdi DrawRect"); + TEST(iBitmap->Handle() != 0); + + // Erase the target + iContext->Clear(); + iDGdiDriver->Finish(); + + iContext->SetBrushPattern(*iBitmap); + iContext->SetBrushStyle(DirectGdi::EPatternedBrush); + iProfiler->InitResults(); + for (TInt count = 0; count < KIterationsToTest; count++) + { + iContext->DrawRect(iScreenRect); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + WriteTargetOutput(KTestName()); + + iProfiler->ResultsAnalysisPixelRate(KTestName, 0, 0, iDisplayMode, KIterationsToTest, iScreenRect.Width() * iScreenRect.Height()); + iContext->SetBrushStyle(DirectGdi::ENullBrush); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0103 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measures the performance of DrawLine(), drawing vertical lines. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +For KLineDrawingIterationsToTest, draw a vertical line from the far left of the target to the right. +Call Finish() to force the drawing to complete, before logging the time. +The pen size is 1,1. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::VerticalLinesL() + { + _LIT(KTestName, "DirectGdi Vertical Lines"); + + // Erase the target + iContext->Clear(); + iDGdiDriver->Finish(); + + iContext->SetPenSize(TSize(1, 1)); + iProfiler->InitResults(); + for (TInt count = 0; count < KLineDrawingIterationsToTest; ++count) + { + iContext->DrawLine(TPoint(iScreenRect.iTl.iX+count, iScreenRect.iTl.iY), TPoint(iScreenRect.iTl.iX+count, iScreenRect.iBr.iY)); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + WriteTargetOutput(KTestName()); + + iProfiler->ResultsAnalysisPixelRate(KTestName, 0, 0, iDisplayMode, KLineDrawingIterationsToTest, iScreenRect.Height()); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0104 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measures the performance of DrawLine(), drawing horizontal lines. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +For KLineDrawingIterationsToTest, draw a horizontal line from the top of the target to the bottom. +Call Finish() to force the drawing to complete, before logging the time. The pen size is 1,1. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::HorizontalLinesL() + { + _LIT(KTestName, "DirectGdi Horizontal Lines"); + + // Erase the target + iContext->Clear(); + iDGdiDriver->Finish(); + + iContext->SetPenSize(TSize(1, 1)); + iProfiler->InitResults(); + for (TInt count = 0; count < KLineDrawingIterationsToTest; ++count) + { + iContext->DrawLine(TPoint(iScreenRect.iTl.iX, iScreenRect.iTl.iY+count), TPoint(iScreenRect.iBr.iX, iScreenRect.iTl.iY+count)); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + WriteTargetOutput(KTestName()); + + iProfiler->ResultsAnalysisPixelRate(KTestName, 0, 0, iDisplayMode, KLineDrawingIterationsToTest, iScreenRect.Width()); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0105 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measure the performance of DrawText() when rendering monochrome text. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +Set the font. +Call DrawText() once to force the glyphs into the cache. +For KTextDrawingIterationsToTest, draw the same string of text. +Call Finish() to force the drawing to complete, before logging the time. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::TextDrawingL() + { + _LIT(KTestName, "DirectGdi Text Drawing"); + // Erase the target + iContext->Clear(); + iContext->SetFont(iFont); + iDGdiDriver->Finish(); + + // Draw the text once so that we aren't timing the time to load it into the cache. + iContext->DrawText(KTextPhrase,NULL,TPoint(10,100)); + + iProfiler->InitResults(); + for(TInt count = KTextDrawingIterationsToTest; count > 0; --count) + { + iContext->DrawText(KTextPhrase,NULL,TPoint(10,100)); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + iProfiler->ResultsAnalysisCharacterRate(KTestName, 0, 0, iDisplayMode, KTextDrawingIterationsToTest, KTextPhraseLength); + + WriteTargetOutput(KTestName()); + iContext->ResetFont(); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0171 + +@SYMDEF 135375 + +@SYMTestCaseDesc +Measure the performance of DrawText() when rendering anti-aliased text. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +Set the font. +Call DrawText() once to force the glyphs into the cache. +For KTextDrawingIterationsToTest, draw the same string of text. +Call Finish() to force the drawing to complete, before logging the time. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::TextDrawingAntiAliasedL() + { + _LIT(KTestName, "DirectGdi Text Drawing Antialiased"); + // Erase the target + iContext->Clear(); + CFont* font = NULL; + TFontSpec fs(KFontTypeface, KFontSize); + fs.iFontStyle.SetBitmapType(EAntiAliasedGlyphBitmap); + TESTL(iTs->GetNearestFontToDesignHeightInPixels(font, fs) == KErrNone); + iContext->SetFont(font); + iDGdiDriver->Finish(); + + // Draw the text once so that we aren't timing the time to load it into the cache. + iContext->DrawText(KTextPhrase,NULL,TPoint(10,100)); + + iProfiler->InitResults(); + for(TInt count = KTextDrawingIterationsToTest; count > 0; --count) + { + iContext->DrawText(KTextPhrase,NULL,TPoint(10,100)); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + + TEST(iDGdiDriver->GetError() == KErrNone); + iProfiler->ResultsAnalysisCharacterRate(KTestName, 0, 0, iDisplayMode, KTextDrawingIterationsToTest, KTextPhrase().Length()); + + WriteTargetOutput(KTestName()); + iContext->ResetFont(); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0106 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measure the performance of DrawText(), with other overhead. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +Set the font. +Call DrawText() once to force the glyphs into the cache. +For KTextDrawingIterationsToTest, calculate the text width in pixels, the ascent in pixels, and finally draw the text. +Call Finish() to force the drawing to complete, before logging the time. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::TextDrawingWithOverheadL() + { + _LIT(KTestName, "DirectGdi Text Drawing With Overhead"); + // Erase the target + iContext->Clear(); + iContext->SetFont(iFont); + iDGdiDriver->Finish(); + + // Draw the text once so that we aren't timing the time to load it into the cache. + iContext->DrawText(KTextPhrase,NULL,TPoint(10,100)); + + iProfiler->InitResults(); + for(TInt count = KTextDrawingIterationsToTest; count > 0; --count) + { + (void)iFont->TextWidthInPixels(KTextPhrase); //do nothing with this, just need the overhead + (void)iFont->AscentInPixels(); //more typical overhead in a drawtext operation + iContext->DrawText(KTextPhrase,NULL,TPoint(10,100)); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + iProfiler->ResultsAnalysisCharacterRate(KTestName, 0, 0, iDisplayMode, KTextDrawingIterationsToTest, KTextPhraseLength); + + WriteTargetOutput(KTestName()); + iContext->ResetFont(); + } + +/** +@SYMTestCaseID +GRAPHICS-UI-BENCH-0107 + +@SYMPREQ PREQ39 + +@SYMREQ REQ9236 +@SYMREQ REQ9237 + +@SYMTestCaseDesc +Measure the performance of DrawText() when using a large font. + +@SYMTestActions +Clear the target, call Finish() so that when the timer begins all outstanding drawing has finished. +Set the large font. +For KTextDrawingIterationsToTest, draw the same string of text. +Call Finish() to force the drawing to complete, before logging the time. + +@SYMTestExpectedResults +The performance to be logged as a pixel rate. +*/ +void CTSimpleDrawingDirectGdi::LargeTextDrawingL() + { + _LIT(KTestName, "DirectGdi Large Text Drawing"); + // Erase the target + iContext->Clear(); + iDGdiDriver->Finish(); + iContext->SetFont(iLargeFont); + // Draw the text once so that we aren't timing the time to load it into the cache. + iContext->DrawText(KTextPhrase,NULL,TPoint(10,100)); + + iProfiler->InitResults(); + for(TInt count=0;countDrawText(KTextPhrase,NULL,TPoint(10,100)); + } + iDGdiDriver->Finish(); + iProfiler->MarkResultSetL(); + TEST(iDGdiDriver->GetError() == KErrNone); + + iProfiler->ResultsAnalysisCharacterRate(KTestName, 0, 0, iDisplayMode, KTextDrawingIterationsToTest, KTextPhraseLength); + WriteTargetOutput(KTestName()); + iContext->ResetFont(); + }