Modifed eglbringuptest to compile against S^3 SDK; added a pkg file
The S^3 SDK lacks libopenvgu.lib. Since this test app does not require
that library, it is simply removed from the .mmp file.
// Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include "tdrawshapes.h"
#include <e32math.h>
CTDrawShapes::CTDrawShapes()
{
SetTestStepName(KTDirectGdiDrawShapeStep);
}
CTDrawShapes::~CTDrawShapes()
{
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0001
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test shape drawing with basic parameters.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Test various shape drawing methods:
void Plot(const TPoint& aPoint)
- Draw points on the destination surface in various colours (use colours from
COLOR_TABLE), increasing the distance between the points.
void DrawLine(const TPoint& aStart, const TPoint& aEnd)
- Draw lines with various colours (use colours from COLOR_TABLE).
- Draw line from top-left to bottom-right corner. Move starting point to the right
and ending point to the left and draw again. Repeat increasing the distance between
the previous and next starting and ending points, until reaching a position outside
the destination surface.
- Draw line from top-left to bottom-right corner. Move starting point down and ending
point up and draw again. Repeat increasing the distance between the previous and next
starting and ending points, until reaching a position outside the destination surface.
void DrawLineTo(const TPoint& aPoint)
- Draw lines with various colours (use colours from COLOR_TABLE).
- Draw line from top-left corner to the bottom of the drawing area. Now draw a line
in opposite direction, moving the end point a little to the right. Repeat, increasing
the distance, by which the end point is moved right, until reaching a position outside
the destination surface.
void DrawLineBy(const TPoint& aVector)
- Draw lines with various colours (use colours from COLOR_TABLE).
- Draw line from top-left corner to the right end of the drawing area. Now draw a line
in opposite direction, moving the end point a little down. Repeat, increasing the distance,
by which the end point is moved down, until reaching a position outside the destination surface.
void DrawRect(const TRect& aRect)
- Draw empty and filled rectangles.
- Draw rectangles with various colours (pen & brush colours; use colours from COLOR_TABLE).
- Draw rectangle with size of the whole drawing area, shrink it and repeat until rectangle
size reaches 0.
void DrawRoundRect(const TRect& aRect, const TSize& aEllipse)
- Draw empty and filled rectangles.
- Draw rectangles with various colours (pen & brush colours; use colours from COLOR_TABLE).
- Draw rectangle with size of the whole drawing area, shrink it, increase the round corners
size and repeat until rectangle size reaches 0.
void DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)
- Draw arcs with various colours (use colours from COLOR_TABLE).
- Draw an arc within the rectangle size of entire drawing area.
- Shrink the rectangle.
- Repeat until rectangle size reaches zero, move arc's start and end points.
void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)
- Draw empty and filled pies.
- Draw pies with various colours (pen & brush colours; use colours from COLOR_TABLE).
- Draw a pie within the rectangle size of entire drawing area.
- Shrink the rectangle.
- Repeat until rectangle size reaches zero, move pie's start and end points.
void DrawPolyLine(const TArray<TPoint>& aPointList)
void DrawPolyLineNoEndPoint(const TArray<TPoint>& aPointList)
- Draw a poly line in the target area, constructed from a large number of points.
void DrawPolygon(const TArray<TPoint>& aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate)
- Draw a polygon on the target area, constructed from a large number of points.
void DrawEllipse(const TRect& aRect)
- Draw empty and filled ellipses.
- Draw ellipses with various colours (pen & brush colours; use colours from COLOR_TABLE).
- Use rectangle (aRect) with size of the whole drawing area, shrink it and repeat until
rectangle size reaches zero.
@SYMTestExpectedResults
All graphic operations completed successfully without errors. Individual shapes should
be drawn in the target area. Valid bitmap should be created. This bitmap should be
the same as a reference one.
*/
void CTDrawShapes::TestBasicDrawShapeL()
{
_LIT(KTestName, "ShapeDrawing-Basic");
if(!iRunningOomTests)
{
INFO_PRINTF1(KTestName);
}
ResetGc();
TSize size(iGdiTarget->SizeInPixels().iWidth/4,
iGdiTarget->SizeInPixels().iHeight/4);
for(TInt i=0; i<17; i++)
{
TPoint pos(size.iWidth*(i%4), size.iHeight*(i/4));
iGc->Reset();
switch(i)
{
case 0: // void Plot(const TPoint& aPoint)
{
TInt step = 0;
for(TInt y=0; y<size.iHeight; y+=step)
{
for(TInt x=0; x<size.iWidth; x+=step)
{
iGc->SetPenColor(KColor16Table[step%16]);
iGc->SetPenStyle(DirectGdi::ENullPen);
iGc->Plot(TPoint(x, y)+pos);
TESTNOERRORL(iGc->GetError());
iGc->SetPenStyle(DirectGdi::ESolidPen);
for(TInt penSize = 0; penSize <= 2; penSize++)
{
iGc->SetPenSize(TSize(penSize,penSize));
iGc->Plot(TPoint(x, y)+pos);
TESTNOERRORL(iGc->GetError());
}
step++;
}
}
break;
}
case 1: // void DrawLine(const TPoint& aStart, const TPoint& aEnd)
{
TInt step = 0;
for(TInt x1=0,x2=size.iWidth-1; x1<size.iWidth; x1+=step,x2-=step)
{
iGc->SetPenColor(KColor16Table[step%16]);
iGc->DrawLine(TPoint(x1, 0)+pos, TPoint(x2, size.iHeight-1)+pos);
TESTNOERRORL(iGc->GetError());
step++;
}
step = 0;
for(TInt y1=0,y2=size.iHeight-1; y1<size.iHeight; y1+=step,y2-=step)
{
iGc->SetPenColor(KColor16Table[step%16]);
iGc->DrawLine(TPoint(0, y1)+pos, TPoint(size.iWidth-1, y2)+pos);
TESTNOERRORL(iGc->GetError());
step++;
}
break;
}
case 2: // void DrawLineTo(const TPoint& aPoint), void DrawLineBy(const TPoint& aVector)
{
iGc->MoveTo(pos);
for(TInt x1=1,a=1,s=1; x1<size.iWidth; a++,x1+=a,s=-s)
{
iGc->SetPenColor(KColor16Table[a%16]);
iGc->DrawLineTo(TPoint(x1, (s>0)*(size.iHeight-1))+pos);
TESTNOERRORL(iGc->GetError());
}
iGc->MoveTo(pos);
for(TInt y1=1,a=1,s=1; y1<size.iHeight; a++,y1+=a,s=-s)
{
iGc->SetPenColor(KColor16Table[a%16]);
iGc->DrawLineBy(TPoint(s*(size.iWidth-1), a));
TESTNOERRORL(iGc->GetError());
}
break;
}
case 4: // void DrawRect(const TRect& aRect), filled
{
iGc->SetBrushStyle(DirectGdi::ESolidBrush);
}
case 3: // void DrawRect(const TRect& aRect)
{
TRect rect(pos, size);
for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 3))
{
iGc->SetPenColor(KColor16Table[a%16]);
iGc->SetBrushColor(KColor16Table[(a+2)%16]);
iGc->DrawRect(rect);
TESTNOERRORL(iGc->GetError());
}
break;
}
case 6: // void DrawRoundRect(const TRect& aRect, const TSize& aEllipse), filled
{
iGc->SetBrushStyle(DirectGdi::ESolidBrush);
}
case 5: // void DrawRoundRect(const TRect& aRect, const TSize& aEllipse)
{
TRect rect(pos, size);
TSize csize(1, 1);
for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(5, 5),csize+=TSize(2, 2))
{
iGc->SetPenColor(KColor16Table[a%16]);
iGc->SetBrushColor(KColor16Table[(a+2)%16]);
for(TInt penSize = 0; penSize <= 1; penSize++)
{
iGc->SetPenSize(TSize(penSize,penSize));
iGc->SetPenStyle(DirectGdi::ENullPen);
iGc->DrawRoundRect(rect, csize);
TESTNOERRORL(iGc->GetError());
iGc->SetPenStyle(DirectGdi::ESolidPen);
iGc->DrawRoundRect(rect, csize);
TESTNOERRORL(iGc->GetError());
iGc->SetPenStyle(DirectGdi::EDottedPen);
iGc->DrawRoundRect(rect, csize);
TESTNOERRORL(iGc->GetError());
}
}
break;
}
case 7: // void DrawArc(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)
{
TRect rect(pos, size);
TPoint pos2(pos);
pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center
TReal start = KPiBy2;
TReal end = 0.0;
for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 3),start+=0.3,end+=0.2)
{
TReal ss;
TReal cc;
Math::Sin(ss, start);
Math::Cos(cc, start);
TInt32 startX;
TInt32 startY;
Math::Int(startX, cc*100);
Math::Int(startY, ss*100);
Math::Sin(ss, end);
Math::Cos(cc, end);
TInt32 endX;
TInt32 endY;
Math::Int(endX, cc*100);
Math::Int(endY, ss*100);
iGc->SetPenColor(KColor16Table[a%16]);
iGc->DrawArc(rect, TPoint(startX, startY)+pos2, TPoint(endX, endY)+pos2);
TESTNOERRORL(iGc->GetError());
}
break;
}
case 9: // void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd), filled
{
iGc->SetBrushStyle(DirectGdi::ESolidBrush);
}
case 8: // void DrawPie(const TRect& aRect, const TPoint& aStart, const TPoint& aEnd)
{
TRect rect(pos, size);
TPoint pos2(pos);
pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center
TReal start = 0.0;
TReal end = 0.1;
for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(4, 4),start+=end,end+=0.04)
{
TReal ss;
TReal cc;
Math::Sin(ss, start+end);
Math::Cos(cc, start+end);
TInt32 startX;
TInt32 startY;
Math::Int(startX, cc*100);
Math::Int(startY, ss*100);
Math::Sin(ss, start);
Math::Cos(cc, start);
TInt32 endX;
TInt32 endY;
Math::Int(endX, cc*100);
Math::Int(endY, ss*100);
iGc->SetPenColor(KColor16Table[a%16]);
iGc->SetBrushColor(KColor16Table[(a+2)%16]);
iGc->DrawPie(rect, TPoint(startX, startY)+pos2, TPoint(endX, endY)+pos2);
TESTNOERRORL(iGc->GetError());
}
break;
}
case 10: // void DrawPolyLine(const TArray<TPoint>* aPointList)
case 11: // void DrawPolyLineNoEndPoint(const TArray<TPoint>* aPointList)
{
TInt numPoints = 60;
CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(numPoints);
CleanupStack::PushL(array);
TPoint pos2(pos);
pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center
TReal angle = 0.0;
for(TInt r=numPoints; r>0; r--,angle+=0.47)
{
TReal ss;
TReal cc;
Math::Sin(ss, angle);
Math::Cos(cc, angle);
TInt32 x;
TInt32 y;
Math::Int(x, cc*r);
Math::Int(y, ss*r);
array->AppendL(TPoint(x, y)+pos2);
}
if(i == 10)
{
for(TInt penSize = 0; penSize <= 1; penSize++)
{
iGc->SetPenSize(TSize(penSize,penSize));
iGc->DrawPolyLine(*array);
}
}
else //if(i == 11)
{
iGc->DrawPolyLineNoEndPoint(*array);
}
TESTNOERRORL(iGc->GetError());
CleanupStack::PopAndDestroy(array);
break;
}
case 13:// TInt DrawPolygon(const TArray<TPoint>* aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate), filled
{
iGc->SetBrushStyle(DirectGdi::ESolidBrush);
iGc->SetBrushColor(KColor16Table[1]);
}
case 12:// TInt DrawPolygon(const TArray<TPoint>* aPointList, CGraphicsContext::TFillRule aFillRule=CGraphicsContext::EAlternate)
{
TInt numPoints = 20;
CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(numPoints);
CleanupStack::PushL(array);
TPoint pos2(pos);
pos2 += TPoint(size.iWidth/2, size.iHeight/2); // center
TReal angle = 0.0;
for(TInt r=60; r>0; r-=3,angle+=0.47)
{
TReal ss;
TReal cc;
Math::Sin(ss, angle);
Math::Cos(cc, angle);
TInt32 x;
TInt32 y;
Math::Int(x, cc*r);
Math::Int(y, ss*r);
array->AppendL(TPoint(x, y)+pos2);
}
iGc->DrawPolygon(*array, DirectGdi::EAlternate);
TESTNOERRORL(iGc->GetError());
CleanupStack::PopAndDestroy(array);
break;
}
case 15: // void DrawEllipse(const TRect& aRect), filled
{
iGc->SetBrushStyle(DirectGdi::ESolidBrush);
}
case 14: // void DrawEllipse(const TRect& aRect)
{
TRect rect(pos, size);
for(TInt a=0; (rect.Size().iWidth>0) && (rect.Size().iHeight>0); a++,rect.Shrink(3, 5))
{
iGc->SetPenColor(KColor16Table[a%16]);
iGc->SetBrushColor(KColor16Table[(a+2)%16]);
iGc->DrawEllipse(rect);
TESTNOERRORL(iGc->GetError());
}
break;
}
}
TESTNOERRORL(iGc->GetError());
}
TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0002
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test line drawing with basic parameters.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Set default pen.
- Draw lines in all directions.
- Draw lines starting or/and ending outside the target surface.
Call functions with valid parameters.
void DrawLine(const TPoint& aStart, const TPoint& aEnd)
The test is implemented the following way: lines will be drawn from a little
distance from the centre (to avoid lines overlapping) to a point outside of the surface
(testing surface boundary clipping). The next line will be drawn in opposite direction
(from outside to the centre) at a slightly incremented angle.
void DrawLineBy(const TPoint& aVector)
Test for DrawLineBy() is implemented in a similar way, with checking the continuity
of line drawing (drawing the next line from the end of the previous one).
void DrawLineTo(const TPoint& aPoint)
Test for DrawLineTo() is implemented in a similar way, with checking the continuity
of line drawing (drawing the next line from the end of the previous one).
@SYMTestExpectedResults
Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.
*/
void CTDrawShapes::TestDrawLineL(TDrawShapeAPI aApi)
{
_LIT(KDrawLine, "ShapeDrawing-DrawLine");
_LIT(KDrawLineTo, "ShapeDrawing-DrawLineTo");
_LIT(KDrawLineBy, "ShapeDrawing-DrawLineBy");
TBuf<30> testName;
if(aApi == EDrawLine)
testName = KDrawLine();
else if(aApi == EDrawLineTo)
testName = KDrawLineTo();
else if(aApi == EDrawLineBy)
testName = KDrawLineBy();
else
ASSERT(EFalse); // test not supported for shapes other than those above
if(!iRunningOomTests)
{
INFO_PRINTF1(testName);
}
ResetGc();
TPoint center(iGdiTarget->SizeInPixels().iWidth/2,
iGdiTarget->SizeInPixels().iHeight/2);
TInt steps = 180;
TReal radius1 = 400.0;
TReal radius2 = 70.0;
TPoint pp;
if(aApi != EDrawLine)
{
const TInt radius = 200;
radius1 = radius;
radius2 = 90.0;
pp = center;
pp.iX += radius;
iGc->MoveTo(pp);
}
for(TInt i=0; i<steps; i++)
{
TReal angle = KPi*2.0*i/steps;
TReal angleSin, angleCos;
Math::Sin(angleSin, angle);
Math::Cos(angleCos, angle);
TPoint p1(static_cast<TInt>(angleCos*radius1), static_cast<TInt>(angleSin*radius1));
p1 += center;
TPoint p2(static_cast<TInt>(angleCos*radius2), static_cast<TInt>(angleSin*radius2));
p2 += center;
if(i&1)
{
TPoint pp = p1;
p1 = p2;
p2 = pp;
}
if(aApi == EDrawLine)
{
for(TInt penSize = 0; penSize <= 1; penSize ++)
{
iGc->SetPenSize(TSize(penSize,penSize));
iGc->SetPenStyle(DirectGdi::ESolidPen);
iGc->DrawLine(p1, p2);
}
}
else if(aApi == EDrawLineTo)
{
iGc->DrawLineTo(p1);
iGc->DrawLineTo(p2);
}
else // if(aApi == EDrawLineBy)
{
iGc->DrawLineBy(p1-pp);
iGc->DrawLineBy(p2-p1);
pp = p2;
}
}
TESTNOERRORL(iGc->GetError());
TESTNOERROR(WriteTargetOutput(iTestParams, testName));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test correctness of size and position reproduction of rectangle, ellipse, arc, and pie.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Set default pen and brush.
- Draw shapes at various positions and sizes.
- Test position and size outside the target surface.
- Test boundary positions and sizes.
Call functions with valid parameters:
void DrawRect(const TRect& aRect)
The size of bounding rectangle (aRect) will be iterated over (both height and width),
each time calling the appropriate drawing method.
For DrawArc() and DrawPie also the starting and ending points will be changing.
@SYMTestExpectedResults
Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.
*/
void CTDrawShapes::TestDrawShapePositionAndSizeL(TDrawShapeAPI aApi,
DirectGdi::TPenStyle aPenStyle,
DirectGdi::TBrushStyle aBrushStyle)
{
_LIT(KDrawRectPositionAndSize, "ShapeDrawing-DrawRect-PositionAndSize");
_LIT(KDrawRoundRectPositionAndSize, "ShapeDrawing-DrawRoundRect-PositionAndSize");
_LIT(KDrawEllipsePositionAndSize, "ShapeDrawing-DrawEllipse-PositionAndSize");
_LIT(KDrawPiePositionAndSize, "ShapeDrawing-DrawPie-PositionAndSize");
_LIT(KDrawArcPositionAndSize, "ShapeDrawing-DrawArc-PositionAndSize");
TBuf<70> testName;
if(aApi == EDrawRect)
testName = KDrawRectPositionAndSize();
else if(aApi == EDrawRoundRect)
testName = KDrawRoundRectPositionAndSize();
else if(aApi == EDrawEllipse)
testName = KDrawEllipsePositionAndSize();
else if(aApi == EDrawPie)
testName = KDrawPiePositionAndSize();
else if(aApi == EDrawArc)
testName = KDrawArcPositionAndSize();
else
ASSERT(EFalse); // test not supported for shapes other than those above
if(aPenStyle == DirectGdi::ENullPen)
{
testName.Append(KSeparator);
testName.Append(KPenNameNull);
}
if(aBrushStyle != DirectGdi::ENullBrush)
{
testName.Append(KSeparator);
testName.Append(KBrushStyleTableNames[aBrushStyle]);
}
if(!iRunningOomTests)
{
INFO_PRINTF1(testName);
}
ResetGc();
TInt width = iGdiTarget->SizeInPixels().iWidth;
TInt height = iGdiTarget->SizeInPixels().iHeight;
TInt rectWidth = 0;
TInt rectHeight = 0;
TInt step = 0;
iGc->SetPenStyle(aPenStyle);
iGc->SetBrushStyle(aBrushStyle);
for(TInt y=-45, offsetY=0; y<height+30; y+=rectHeight+1, offsetY++, rectHeight++)
{
rectWidth = 0;
for(TInt x=-45, offsetX=0; x<width+30; x+=rectWidth+1, offsetX++, rectWidth++)
{
TRect rect(TPoint(x+offsetY, y+offsetX), TSize(rectWidth, rectHeight));
iGc->SetBrushColor(KColor16Table[step%16]);
step++;
if(aApi == EDrawRect)
{
iGc->DrawRect(rect);
}
else if(aApi == EDrawRoundRect)
{
iGc->DrawRoundRect(rect, TSize(offsetX/3, offsetY/3));
}
else if(aApi == EDrawEllipse)
{
iGc->DrawEllipse(rect);
}
else
{
TReal angle1 = offsetX*0.2;
TReal angle2 = angle1-(offsetY+1)*0.18;
TReal angleSin, angleCos;
Math::Sin(angleSin, angle1);
Math::Cos(angleCos, angle1);
TPoint p1(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));
Math::Sin(angleSin, angle2);
Math::Cos(angleCos, angle2);
TPoint p2(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));
p1 += rect.Center();
p2 += rect.Center();
if(aApi == EDrawPie)
{
iGc->DrawPie(rect, p1, p2);
}
else //if(aApi == EDrawArc)
{
iGc->DrawArc(rect, p1, p2);
}
}
TESTNOERRORL(iGc->GetError());
}
}
TESTNOERROR(WriteTargetOutput(iTestParams, testName));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test functions behaviour after calling with invalid parameters.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Test shape drawing methods invalid parameters handling.
Set default pen and brush.
Set valid parameters (see ShapeDrawing-Basic).
Replace valid parameters with invalid ones:
negative size
aRect.iTl = ( -30, -30 ) ; aRect.iBr = ( -10, -10 )
aRect.iTl = ( 30, 30 ) ; aRect.iBr = ( 10, 10 )
aEllipse.iWidth = -30
aEllipse.iHeight = -30
zero size
aRect.iTl = ( -30, -30 ) ; aRect.iBr = ( -30, -30 )
aRect.iTl = ( 30, 30 ) ; aRect.iBr = ( 30, 30 )
Trect(10,50,10,80)
TRect(80,90,140,90)
aEllipse.iWidth = 0
aEllipse.iHeight = 0
@SYMTestExpectedResults
Function shall detect invalid parameters and return. Nothing will be drawn on the target surface.
*/
void CTDrawShapes::TestDrawShapeInvalidParametersL(TDrawShapeAPI aApi)
{
_LIT(KDrawRectInvalidParameters, "ShapeDrawing-DrawRect-InvalidParameters");
_LIT(KDrawRoundRectInvalidParameters, "ShapeDrawing-DrawRoundRect-InvalidParameters");
_LIT(KDrawEllipseInvalidParameters, "ShapeDrawing-DrawEllipse-InvalidParameters");
_LIT(KDrawPieInvalidParameters, "ShapeDrawing-DrawPie-InvalidParameters");
_LIT(KDrawArcInvalidParameters, "ShapeDrawing-DrawArc-InvalidParameters");
_LIT(KDrawPolygonInvalidParameters, "ShapeDrawing-DrawPolygon-InvalidParameters");
TBuf<70> testName;
if(aApi == EDrawRect)
testName = KDrawRectInvalidParameters();
else if(aApi == EDrawRoundRect)
testName = KDrawRoundRectInvalidParameters();
else if(aApi == EDrawEllipse)
testName = KDrawEllipseInvalidParameters();
else if(aApi == EDrawPie)
testName = KDrawPieInvalidParameters();
else if(aApi == EDrawArc)
testName = KDrawArcInvalidParameters();
else if(aApi == EDrawPolygon)
testName = KDrawPolygonInvalidParameters();
else
ASSERT(EFalse); // test not supported for shapes other than those above
if(!iRunningOomTests)
{
INFO_PRINTF1(testName);
}
ResetGc();
RArray<TRect> rects;
CleanupClosePushL(rects);
RArray<TSize> sizes;
CleanupClosePushL(sizes);
// negative rect size
rects.AppendL(TRect(-30, -30, -10, -10));
rects.AppendL(TRect(30, 30, 10, 10));
rects.AppendL(TRect(100, 30, 120, 10));
rects.AppendL(TRect(30, 100, 10, 120));
// negative ellipse size
sizes.AppendL(TSize(-30, 30));
sizes.AppendL(TSize(30, -30));
sizes.AppendL(TSize(-30, -30));
// zero rect size
rects.AppendL(TRect(-30, -30, -30, -30));
rects.AppendL(TRect(30, 30, 30, 30));
rects.AppendL(TRect(10, 50, 10, 80));
rects.AppendL(TRect(80, 90, 140, 90));
// zero ellipse size
sizes.AppendL(TSize(0, 30));
sizes.AppendL(TSize(30, 0));
sizes.AppendL(TSize(0, 0));
switch(aApi)
{
case EDrawRect:
{
for(TInt i=0; i<rects.Count(); i++)
{
for(TInt penSize = 0; penSize <= 1; penSize++)
{
iGc->SetPenSize(TSize(penSize,penSize));
iGc->DrawRect(rects[i]);
TESTNOERRORL(iGc->GetError());
}
}
break;
}
case EDrawRoundRect:
{
for(TInt i=0; i<rects.Count(); i++)
{
for(TInt j=0; j<sizes.Count(); j++)
{
iGc->DrawRoundRect(rects[i], sizes[j]);
TESTNOERRORL(iGc->GetError());
}
}
break;
}
case EDrawEllipse:
{
for(TInt i=0; i<rects.Count(); i++)
{
iGc->DrawEllipse(rects[i]);
TESTNOERRORL(iGc->GetError());
}
break;
}
case EDrawPie:
{
for(TInt i=0; i<rects.Count(); i++)
{
TPoint pos(rects[i].Center());
iGc->SetPenStyle(DirectGdi::ENullPen);
iGc->DrawPie(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);
iGc->SetPenStyle(DirectGdi::ESolidPen);
for(TInt penSize = 0; penSize <= 1; penSize ++)
{
iGc->SetPenSize(TSize(penSize,penSize));
iGc->DrawPie(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);
TESTNOERRORL(iGc->GetError());
}
}
break;
}
case EDrawArc:
{
for(TInt i=0; i<rects.Count(); i++)
{
TPoint pos(rects[i].Center());
iGc->SetPenStyle(DirectGdi::ENullPen);
iGc->DrawArc(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);
iGc->DrawArc(rects[i], TPoint(0, -100)+pos, TPoint(100, 0)+pos);
iGc->SetPenStyle(DirectGdi::ESolidPen);
for(TInt penSize = 0; penSize <= 1; penSize ++)
{
iGc->SetPenSize(TSize(penSize,penSize));
iGc->DrawArc(rects[i], TPoint(100, 0)+pos, TPoint(0, -100)+pos);
}
TESTNOERRORL(iGc->GetError());
}
break;
}
case EDrawPolygon:
{
// Try to draw a polygon with 0 points, and a polygon with an invalid fill argument
CArrayFixFlat<TPoint> *tmpArray = new (ELeave)CArrayFixFlat<TPoint>(1);
iGc->DrawPolygon(*tmpArray, DirectGdi::EAlternate);
TESTNOERROR(iGc->GetError());
iGc->DrawPolygon(*tmpArray, static_cast<DirectGdi::TFillRule>(-1));
if (iUseDirectGdi)
{
TEST(iGc->GetError() == KErrArgument);
}
delete tmpArray;
break;
}
}
iGc->Reset();
CleanupStack::PopAndDestroy(&sizes);
CleanupStack::PopAndDestroy(&rects);
// test if target is still clear
TBool pass = TestTargetL(KRgbWhite);
if(!pass)
{
// write target only if test failed
TEST(KErrNone == WriteTargetOutput(iTestParams, testName));
}
TEST(pass);
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0005
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test a few round rectangles, some of which have corners larger than the width
or height or the rectangles.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
The tests is implemented the following way: the rectangles' corners' width and height
will be iterated over, and for each iteration a set of rounded rectangles will be drawn.
The test will be repeated with a solid brush.
@SYMTestExpectedResults
Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.
*/
void CTDrawShapes::TestDrawRoundRectL(DirectGdi::TBrushStyle aBrushStyle)
{
_LIT(KDrawRoundRect, "ShapeDrawing-DrawRoundRect");
TBuf<50> testName;
testName = KDrawRoundRect();
if(aBrushStyle != DirectGdi::ENullBrush)
{
testName.Append(KSeparator);
testName.Append(KBrushStyleTableNames[aBrushStyle]);
}
if(!iRunningOomTests)
{
INFO_PRINTF1(testName);
}
ResetGc();
TInt width = iGdiTarget->SizeInPixels().iWidth;
TInt height = iGdiTarget->SizeInPixels().iHeight;
const TInt xRectNum = 16;
const TInt yRectNum = 16;
TInt step = 0;
iGc->SetBrushStyle(aBrushStyle);
for(TInt i=0; i<yRectNum; i++)
{
for(TInt j=0; j<xRectNum; j++)
{
TRect rect(TPoint(j*width/xRectNum, i*height/yRectNum), TSize(width/xRectNum, height/yRectNum));
// draw many concentric rectangles, each smaller than previous
while((rect.Size().iWidth > 2) && (rect.Size().iHeight > 2))
{
iGc->SetBrushColor(KColor16Table[step%16]);
step++;
iGc->DrawRoundRect(rect, TSize(j, i));
TESTNOERRORL(iGc->GetError());
rect.Shrink(3, 3);
}
}
}
TESTNOERROR(WriteTargetOutput(iTestParams, testName));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0006
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test drawing arc functionality.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Set default pen and brush.
Draw various chunks of arc.
Call functions with valid parameters.
The tests is implemented the following way: the arc's starting angle will be
iterated over, and for each iteration a set of arcs with different end angles will be drawn.
@SYMTestExpectedResults
Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.
*/
void CTDrawShapes::TestDrawArcL()
{
_LIT(KTestName, "ShapeDrawing-DrawArc");
if(!iRunningOomTests)
{
INFO_PRINTF1(KTestName);
}
ResetGc();
TInt width = iGdiTarget->SizeInPixels().iWidth;
TInt height = iGdiTarget->SizeInPixels().iHeight;
const TInt xRectNum = 8;
const TInt yRectNum = 8;
const TReal angleStep = 2.0*KPi/11.0;
for(TInt i=0; i<yRectNum; i++)
{
for(TInt j=0; j<xRectNum; j++)
{
TRect rect(TPoint(j*width/xRectNum, i*height/yRectNum), TSize(width/xRectNum, height/yRectNum));
TReal angle1 =(i*xRectNum+j)*2.0*KPi/(xRectNum*yRectNum);
TReal angleSin, angleCos;
Math::Sin(angleSin, angle1);
Math::Cos(angleCos, angle1);
TPoint p1(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));
p1 += rect.Center();
TReal angle2 = angle1-angleStep;
// draw many concentric arcs, each smaller than previous and with different angles
while((rect.Size().iWidth > 2) && (rect.Size().iHeight > 2))
{
Math::Sin(angleSin, angle2);
Math::Cos(angleCos, angle2);
TPoint p2(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));
p2 += rect.Center();
iGc->DrawArc(rect, p1, p2);
TESTNOERRORL(iGc->GetError());
angle2 -= angleStep;
rect.Shrink(3, 3);
}
}
}
TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0007
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test drawing pie functionality.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Set default pen and brush.
Draw various chunks of pie.
Call functions with valid parameters (see Graphics-DirectGDI-ShapeDrawing-001).
The tests is implemented the following way: the pie's starting angle will be
iterated over, and for each iteration a complete circle composed of different pies will be drawn.
@SYMTestExpectedResults
A set of 64 groups of pies should be draw, each one rotated slightly more than the last.
The size of the pies drawn should look the same for all rotations.
*/
void CTDrawShapes::TestDrawPieL(DirectGdi::TBrushStyle aBrushStyle)
{
_LIT(KDrawPie, "ShapeDrawing-DrawPie");
TBuf<50> testName;
testName = KDrawPie();
if(aBrushStyle != DirectGdi::ENullBrush)
{
testName.Append(KSeparator);
testName.Append(KBrushStyleTableNames[aBrushStyle]);
}
if(!iRunningOomTests)
{
INFO_PRINTF1(testName);
}
ResetGc();
TInt width = iGdiTarget->SizeInPixels().iWidth;
TInt height = iGdiTarget->SizeInPixels().iHeight;
const TInt xRectNum = 8;
const TInt yRectNum = 8;
const TReal angleStep = 2.0*KPi/21.0;
TInt step = 0;
iGc->SetBrushStyle(aBrushStyle);
for(TInt i=0; i<yRectNum; i++)
{
for(TInt j=0; j<xRectNum; j++)
{
TRect rect(TPoint(j*width/xRectNum, i*height/yRectNum), TSize(width/xRectNum, height/yRectNum));
TReal angle1 =(i*xRectNum+j)*2.0*KPi/(xRectNum*yRectNum);
//draw six parts of pie
for(TInt k=1; k<=6; k++)
{
TReal angleSin, angleCos;
Math::Sin(angleSin, angle1);
Math::Cos(angleCos, angle1);
TPoint p1(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));
p1 += rect.Center();
TReal angle2 = angle1-k*angleStep;
Math::Sin(angleSin, angle2);
Math::Cos(angleCos, angle2);
TPoint p2(static_cast<TInt>(angleCos*100), static_cast<TInt>(angleSin*100));
p2 += rect.Center();
iGc->SetBrushColor(KColor16Table[step%16]);
step++;
iGc->DrawPie(rect, p1, p2);
TESTNOERRORL(iGc->GetError());
angle1 -= k*angleStep;
rect.Shrink(2, 2);
}
}
}
TESTNOERROR(WriteTargetOutput(iTestParams, testName));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0008
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test drawing polyline functionality.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Test DrawPolyLine() and DrawPolyLineNoEndPoint() methods with various valid parameters.
Draw polylines with:
Different number of points (including zero points).
Different position of points.
Boundary point position.
Point position outside the target surface.
The test will be implemented by repeatedly drawing the same shape with varying number of points.
@SYMTestExpectedResults
Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.
*/
void CTDrawShapes::TestDrawPolyLineL(TDrawShapeAPI aApi)
{
_LIT(KDrawPolyLine, "ShapeDrawing-DrawPolyLine");
_LIT(KDrawPolyLineNoEndPoint, "ShapeDrawing-DrawPolyLineNoEndPoint");
TBuf<50> testName;
if(aApi == EDrawPolyLine)
testName = KDrawPolyLine();
else //if(aApi == EDrawPolyLineNoEndPoint)
testName = KDrawPolyLineNoEndPoint();
if(!iRunningOomTests)
{
INFO_PRINTF1(testName);
}
ResetGc();
TInt width = iGdiTarget->SizeInPixels().iWidth;
TInt height = iGdiTarget->SizeInPixels().iHeight;
TSize size(width/10, height/10);
TSize size2(size.iWidth/2, size.iHeight/2);
const TInt pCount = 28;
CArrayFixFlat<TPoint> *tmpArray = new (ELeave)CArrayFixFlat<TPoint>(pCount);
CleanupStack::PushL(tmpArray);
TReal angle = 0.0;
for(TInt r=pCount-1; r>0; r--,angle+=0.6)
{
TReal ss;
TReal cc;
Math::Sin(ss, angle);
Math::Cos(cc, angle);
TInt32 x;
TInt32 y;
Math::Int(x, cc*r);
Math::Int(y, ss*r);
tmpArray->AppendL(TPoint(x, y)+size2.AsPoint());
//duplicate point to test consecutive points with the same position
if(r==15)
{
tmpArray->AppendL(TPoint(x, y)+size2.AsPoint());
}
}
CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(pCount);
CleanupStack::PushL(array);
for(TInt y=-size2.iHeight,k=0; y<height+size2.iHeight; y+=size.iHeight, k++)
{
for(TInt x=-size2.iWidth,l=0; x<width+size2.iWidth; x+=size.iWidth, l++)
{
TPoint pos(x+k, y+l);
TInt pNum = Abs(l-5) + Abs(k-5)*5 +1;
if(pNum > pCount)
pNum = pCount;
for(TInt i=0; i<pNum; i++)
{
array->AppendL(tmpArray->At(i)+pos);
}
if(aApi == EDrawPolyLine)
{
iGc->SetPenStyle(DirectGdi::EDottedPen);
iGc->DrawPolyLine(*array);
iGc->SetPenStyle(DirectGdi::ESolidPen);
iGc->DrawPolyLine(*array);
}
else //if(aApi == EDrawPolyLineNoEndPoint)
iGc->DrawPolyLineNoEndPoint(*array);
TESTNOERRORL(iGc->GetError());
array->Delete(0, pNum);
}
}
CleanupStack::PopAndDestroy(2, tmpArray);
TESTNOERROR(WriteTargetOutput(iTestParams, testName));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0009
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test drawing polygon functionality.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Test DrawPolygon() methods with various valid parameters.
Draw polygons with:
Different number of points (including zero points and two points).
Different position of points.
Boundary point positions.
Point positions outside the target surface.
Test self-crossing polygons
Test fill rules.
The test will be implemented by repeatedly drawing the same shape with varying number of points.
@SYMTestExpectedResults
Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.
*/
void CTDrawShapes::TestDrawPolygonL(TInt aWidth, TInt aHeight, DirectGdi::TBrushStyle aBrushStyle, DirectGdi::TFillRule aFillRule)
{
_LIT(KDrawPolygon, "ShapeDrawing-DrawPolygon");
TBuf<50> testName;
testName = KDrawPolygon();
if(aBrushStyle != DirectGdi::ENullBrush)
{
testName.Append(KSeparator);
testName.Append(KBrushStyleTableNames[aBrushStyle]);
testName.Append(KSeparator);
testName.Append(KFillRuleNames[aFillRule]);
}
if(!iRunningOomTests)
{
INFO_PRINTF1(testName);
}
ResetGc();
TSize size(aWidth/10, aHeight/10);
TSize size2(size.iWidth/2, size.iHeight/2);
const TInt pCount = 28;
CArrayFixFlat<TPoint> *tmpArray = new (ELeave)CArrayFixFlat<TPoint>(pCount);
CleanupStack::PushL(tmpArray);
TReal angle = 0.0;
for(TInt r=pCount-1; r>0; r--,angle+=0.6)
{
TReal ss;
TReal cc;
Math::Sin(ss, angle);
Math::Cos(cc, angle);
TInt32 x;
TInt32 y;
Math::Int(x, cc*r);
Math::Int(y, ss*r);
tmpArray->AppendL(TPoint(x, y)+size2.AsPoint());
//duplicate point to test consecutive points with the same position
if(r==15)
{
tmpArray->AppendL(TPoint(x, y)+size2.AsPoint());
}
}
CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(pCount);
CleanupStack::PushL(array);
iGc->SetBrushStyle(aBrushStyle);
TInt step = 0;
TBool ZeroPenSizeSet = EFalse;
for(TInt y=-size2.iHeight,k=0; y<aHeight+size2.iHeight; y+=size.iHeight, k++)
{
for(TInt x=-size2.iWidth,l=0; x<aWidth+size2.iWidth; x+=size.iWidth, l++)
{
TPoint pos(x+k, y+l);
TInt pNum = Abs(l-5) + Abs(k-5)*5 +1;
if(pNum > pCount)
pNum = pCount;
for(TInt i=0; i<pNum; i++)
{
array->AppendL(tmpArray->At(i)+pos);
}
iGc->SetBrushColor(KColor16Table[step%16]);
step++;
if(ZeroPenSizeSet)
{
iGc->SetPenSize(TSize(1,1));
}
else
{
iGc->SetPenSize(TSize(0,0));
ZeroPenSizeSet = ETrue;
}
iGc->DrawPolygon(*array, aFillRule);
TESTNOERRORL(iGc->GetError());
array->Delete(0, pNum);
}
}
CleanupStack::PopAndDestroy(2, tmpArray);
TESTNOERROR(WriteTargetOutput(iTestParams, testName));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0010
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test Plot() functionality.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Draw many plots using pen size 1.
Draw various other plots of differing pen sizes and colours.
@SYMTestExpectedResults
VValid bitmap should be created. This bitmap should be the same as the reference bitmap.
*/
void CTDrawShapes::TestPlot()
{
_LIT(KTestName, "ShapeDrawing-Plot");
if(!iRunningOomTests)
{
INFO_PRINTF1(KTestName);
}
ResetGc();
const TInt width = iGdiTarget->SizeInPixels().iWidth;
const TInt height = iGdiTarget->SizeInPixels().iHeight;
// Plot many 1-pixel points.
TPoint plotPoint(10,10);
while (plotPoint.iY < height)
{
iGc->Plot(plotPoint);
plotPoint.iX += 10;
if (plotPoint.iX > width)
{
plotPoint.iX -= width;
plotPoint.iY += 10;
}
}
// Plot points of various sizes/colours.
TInt count = 0;
TInt size;
plotPoint = TPoint(10,10);
while (plotPoint.iY < height)
{
iGc->SetPenColor(KColor16Table[count%16]);
size = (count*2) % 15;
iGc->SetPenSize(TSize(size, size));
iGc->Plot(plotPoint);
plotPoint.iX += 20;
plotPoint.iY += 10;
if (plotPoint.iX > width)
{
plotPoint.iX -= width;
}
++count;
}
TESTNOERROR(iGc->GetError());
TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));
iGc->Reset();
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0011
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Test drawing arc functionality.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Set default pen and brush.
Draw 4 arcs of an ellipse on the same ellipse, one in each quadrant.
Draw lines from the centre of that ellipse to the points defining the beginning and end points of the arcs.
Draw 3 arcs with an angle extent of >90 degrees which span more than one quadrant.
Draw lines from the centre of that ellipse to the points defining the beginning and end points of the arcs.
@SYMTestExpectedResults
Valid bitmap should be created. This bitmap shall be compared to a reference bitmap.
*/
void CTDrawShapes::TestDrawLargeArc()
{
_LIT(KTestName, "ShapeDrawing-DrawArc-LargeArcs");
if(!iRunningOomTests)
{
INFO_PRINTF1(KTestName);
}
ResetGc();
// Draw arcs with short extents using same base ellipse.
iGc->DrawArc(TRect(100,63,150,193), TPoint(110,4), TPoint(71,43));
iGc->DrawLine(TPoint(125,128), TPoint(71,43));
iGc->DrawLine(TPoint(125,128), TPoint(110,4));
iGc->DrawArc(TRect(100,63,150,193), TPoint(71,213), TPoint(110,252));
iGc->DrawLine(TPoint(125,128), TPoint(71,213));
iGc->DrawLine(TPoint(125,128), TPoint(110,252));
iGc->DrawArc(TRect(100,63,150,193), TPoint(140,252), TPoint(179,213));
iGc->DrawLine(TPoint(125,128), TPoint(140,252));
iGc->DrawLine(TPoint(125,128), TPoint(179,213));
iGc->DrawArc(TRect(100,63,150,193), TPoint(179,43), TPoint(140,4));
iGc->DrawLine(TPoint(125,128), TPoint(179,43));
iGc->DrawLine(TPoint(125,128), TPoint(140,4));
// Draw arc with large extent starting and finishing in same quadrant.
iGc->DrawArc(TRect(300,63,350,193), TPoint(271,43), TPoint(310,4));
iGc->DrawLine(TPoint(325,128), TPoint(271,43));
iGc->DrawLine(TPoint(325,128), TPoint(310,4));
// Draw arc with large extent starting and finishing in neighbouring quadrants.
iGc->DrawArc(TRect(100,319,150,449), TPoint(71,299), TPoint(179,299));
iGc->DrawLine(TPoint(125,381), TPoint(71,299));
iGc->DrawLine(TPoint(125,381), TPoint(179,299));
// Draw arc with large extent starting and finishing in opposite quadrants.
iGc->DrawArc(TRect(300,319,350,449), TPoint(271,299), TPoint(340,508));
iGc->DrawLine(TPoint(325,381), TPoint(271,299));
iGc->DrawLine(TPoint(325,381), TPoint(340,508));
TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0012
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Tests polygon drawing behaviour when called with invalid parameters.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Draw several polygons where some of the points are repeated.
@SYMTestExpectedResults
No errors or panics should be reported.
*/
void CTDrawShapes::TestSetAttributesInvalidParametersL()
{
_LIT(KTestName, "ShapeDrawing-SetAttributes-InvalidParameters");
if(!iRunningOomTests)
{
INFO_PRINTF1(KTestName);
}
ResetGc();
CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(20);
CleanupStack::PushL(array);
// points with the same positions
array->Reset();
array->AppendL(TPoint(10, 10));
array->AppendL(TPoint(20, 53));
array->AppendL(TPoint(20, 53));
array->AppendL(TPoint(20, 53));
array->AppendL(TPoint(42, 27));
array->AppendL(TPoint(42, 27));
iGc->Reset();
iGc->DrawPolygon(*array, DirectGdi::EAlternate);
TESTNOERRORL(iGc->GetError());
iGc->SetOrigin(TPoint(100, 100));
iGc->SetBrushStyle(DirectGdi::ESolidBrush);
iGc->SetBrushColor(KColor16Table[5]);
iGc->DrawPolygon(*array, DirectGdi::EAlternate);
TESTNOERRORL(iGc->GetError());
iGc->SetOrigin(TPoint(200, 200));
iGc->DrawPolygon(*array, DirectGdi::EWinding);
TESTNOERRORL(iGc->GetError());
CleanupStack::PopAndDestroy(array);
TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));
}
/**
@SYMTestCaseID
GRAPHICS-DIRECTGDI-SHAPEDRAWING-0013
@SYMPREQ
PREQ39
@SYMREQ
REQ9195
REQ9201
REQ9202
REQ9222
REQ9223
REQ9236
REQ9237
@SYMTestCaseDesc
Draw some shapes with semi-transparent pen outlines.
@SYMTestStatus
Implemented
@SYMTestPriority
Critical
@SYMTestActions
Set the pen to a 10% opacity red colour.
Set the brush fill colour to solid green.
Call DrawRect() and DrawPoylgon() with varying pen-sizes.
(Ellipses and arcs have been deliberately left out because the algorithm used for BitGdi
involves multiple plots at the same point resulting in multiple blends and incorrect colour,
meaning the test would always fail.)
@SYMTestExpectedResults
The outline colour should match for all shapes, and be a consistant colour
for the entire outline of the shape.
The brush fill should reach the centre of the pen outlines, and be visible through the
semi-transparent outline.
*/
void CTDrawShapes::TestDrawShapeTransparentOutlineL()
{
_LIT(KTestName, "ShapeDrawing-TransparentOutline");
if(!iRunningOomTests)
{
INFO_PRINTF1(KTestName);
}
ResetGc();
const TInt width = iGdiTarget->SizeInPixels().iWidth;
const TInt height = iGdiTarget->SizeInPixels().iHeight;
iGc->SetPenColor(TRgb(255,0,0,25));
iGc->SetBrushColor(TRgb(0,255,0,255));
iGc->SetBrushStyle(DirectGdi::ESolidBrush);
const TInt KCount = 3;
TInt left = 10;
for (TInt count = 0; count < KCount; ++count)
{
// The sw version allocates memory when you set a pen size and this memory is not freed
// until after the __UHEAP_MARKEND macro when running OOM tests, this causes a memory
// leak when this test leaves. The following TCleanupItem has been added to reset the pen
// size to 1,1 on account of a leave as settting the pen size to 1,1 deletes the allocated
// pen memory.
CleanupStack::PushL(TCleanupItem(ResetPenSize, iGc));
switch(count)
{
case 0:
iGc->SetPenSize(TSize(1,1));
break;
case 1:
iGc->SetPenSize(TSize(15,7));
break;
case 2:
iGc->SetPenSize(TSize(width/(KCount*2),width/(KCount*2)));
break;
}
TInt right = left + (width/(KCount+2));
iGc->SetPenStyle(DirectGdi::ESolidPen);
iGc->DrawRect(TRect(left, height/10, right, height/5));
CArrayFixFlat<TPoint> *array = new (ELeave)CArrayFixFlat<TPoint>(20);
CleanupStack::PushL(array);
array->AppendL(TPoint(left, height*3/5));
array->AppendL(TPoint(left, height*9/10));
array->AppendL(TPoint(right, height*9/10));
iGc->DrawPolygon(*array, DirectGdi::EWinding);
CleanupStack::PopAndDestroy(2);
left = right + 50;
}
TESTNOERRORL(iGc->GetError());
TESTNOERROR(WriteTargetOutput(iTestParams, KTestName()));
}
/**
Override of base class virtual
@leave Gets system wide error code
@return - TVerdict code
*/
TVerdict CTDrawShapes::doTestStepPreambleL()
{
CTDirectGdiStepBase::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.
@leave Gets system wide error code
@return TVerdict code
*/
TVerdict CTDrawShapes::doTestStepL()
{
// Test for each pixel format
for(TInt targetPixelFormatIndex = iTargetPixelFormatArray.Count() - 1; targetPixelFormatIndex >= 0 ; targetPixelFormatIndex--)
{
iTestParams.iTargetPixelFormat = iTargetPixelFormatArray[targetPixelFormatIndex];
SetTargetL(iTestParams.iTargetPixelFormat, EOneContextOneTarget, TSize(512, 512));
RunTestsL();
// only run OOM tests for one target pixel format to prevent duplication of tests
if (targetPixelFormatIndex == 0)
{
RunOomTestsL(); //from base class
}
}
CloseTMSGraphicsStep();
return TestStepResult();
}
/**
Override of base class pure virtual
Lists the tests to be run
*/
void CTDrawShapes::RunTestsL()
{
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0001"));
TestBasicDrawShapeL();
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0010"));
TestPlot();
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0013"));
TestDrawShapeTransparentOutlineL();
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0008"));
TestDrawPolyLineL(EDrawPolyLine);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0008"));
TestDrawPolyLineL(EDrawPolyLineNoEndPoint);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0009"));
TestDrawPolygonL(iGdiTarget->SizeInPixels().iWidth, iGdiTarget->SizeInPixels().iHeight);
RecordTestResultL();
if(!iRunningOomTests)
{
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0009"));
TestDrawPolygonL(iGdiTarget->SizeInPixels().iWidth, iGdiTarget->SizeInPixels().iHeight, DirectGdi::ESolidBrush, DirectGdi::EAlternate);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0009"));
TestDrawPolygonL(iGdiTarget->SizeInPixels().iWidth, iGdiTarget->SizeInPixels().iHeight, DirectGdi::ESolidBrush, DirectGdi::EWinding);
RecordTestResultL();
}
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0002"));
TestDrawLineL(EDrawLine);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0002"));
TestDrawLineL(EDrawLineTo);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0002"));
TestDrawLineL(EDrawLineBy);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0005"));
TestDrawRoundRectL();
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0005"));
TestDrawRoundRectL(DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0006"));
TestDrawArcL();
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0011"));
TestDrawLargeArc();
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0007"));
TestDrawPieL();
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0007"));
TestDrawPieL(DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawRect, DirectGdi::ESolidPen, DirectGdi::ENullBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawRoundRect, DirectGdi::ESolidPen, DirectGdi::ENullBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawEllipse, DirectGdi::ESolidPen, DirectGdi::ENullBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawPie, DirectGdi::ESolidPen, DirectGdi::ENullBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawArc, DirectGdi::ESolidPen, DirectGdi::ENullBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawRect, DirectGdi::ESolidPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawRoundRect, DirectGdi::ESolidPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawEllipse, DirectGdi::ESolidPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawPie, DirectGdi::ESolidPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawRect, DirectGdi::ENullPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawRoundRect, DirectGdi::ENullPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawEllipse, DirectGdi::ENullPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0003"));
TestDrawShapePositionAndSizeL(EDrawPie, DirectGdi::ENullPen, DirectGdi::ESolidBrush);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004"));
TestDrawShapeInvalidParametersL(EDrawRect);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004"));
TestDrawShapeInvalidParametersL(EDrawRoundRect);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004"));
TestDrawShapeInvalidParametersL(EDrawEllipse);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004"));
TestDrawShapeInvalidParametersL(EDrawPie);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004"));
TestDrawShapeInvalidParametersL(EDrawArc);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0004"));
TestDrawShapeInvalidParametersL(EDrawPolygon);
RecordTestResultL();
SetTestStepID(_L("GRAPHICS-DIRECTGDI-SHAPEDRAWING-0012"));
TestSetAttributesInvalidParametersL();
RecordTestResultL();
}