Sweden-Number/dlls/gdiplus/tests/graphics.c

918 lines
30 KiB
C

/*
* Unit test suite for graphics objects
*
* Copyright (C) 2007 Google (Evan Stade)
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
#include "windows.h"
#include "gdiplus.h"
#include "wingdi.h"
#include "wine/test.h"
#define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
#define TABLE_LEN (23)
static void test_constructor_destructor(void)
{
GpStatus stat;
GpGraphics *graphics = NULL;
HDC hdc = GetDC(0);
stat = GdipCreateFromHDC(NULL, &graphics);
expect(OutOfMemory, stat);
stat = GdipDeleteGraphics(graphics);
expect(InvalidParameter, stat);
stat = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, stat);
stat = GdipDeleteGraphics(graphics);
expect(Ok, stat);
stat = GdipCreateFromHWND(NULL, &graphics);
expect(Ok, stat);
stat = GdipDeleteGraphics(graphics);
expect(Ok, stat);
stat = GdipCreateFromHWNDICM(NULL, &graphics);
expect(Ok, stat);
stat = GdipDeleteGraphics(graphics);
expect(Ok, stat);
stat = GdipDeleteGraphics(NULL);
expect(InvalidParameter, stat);
ReleaseDC(0, hdc);
}
typedef struct node{
GraphicsState data;
struct node * next;
} node;
/* Linked list prepend function. */
static void log_state(GraphicsState data, node ** log)
{
node * new_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(node));
new_entry->data = data;
new_entry->next = *log;
*log = new_entry;
}
/* Checks if there are duplicates in the list, and frees it. */
static void check_no_duplicates(node * log)
{
INT dups = 0;
node * temp = NULL;
node * temp2 = NULL;
node * orig = log;
if(!log)
goto end;
do{
temp = log;
while((temp = temp->next)){
if(log->data == temp->data){
dups++;
break;
}
if(dups > 0)
break;
}
}while((log = log->next));
temp = orig;
do{
temp2 = temp->next;
HeapFree(GetProcessHeap(), 0, temp);
temp = temp2;
}while(temp);
end:
expect(0, dups);
}
static void test_save_restore(void)
{
GpStatus stat;
GraphicsState state_a, state_b, state_c;
InterpolationMode mode;
GpGraphics *graphics1, *graphics2;
node * state_log = NULL;
HDC hdc = GetDC(0);
state_a = state_b = state_c = 0xdeadbeef;
/* Invalid saving. */
GdipCreateFromHDC(hdc, &graphics1);
stat = GdipSaveGraphics(graphics1, NULL);
expect(InvalidParameter, stat);
stat = GdipSaveGraphics(NULL, &state_a);
expect(InvalidParameter, stat);
GdipDeleteGraphics(graphics1);
log_state(state_a, &state_log);
/* Basic save/restore. */
GdipCreateFromHDC(hdc, &graphics1);
GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
stat = GdipSaveGraphics(graphics1, &state_a);
todo_wine
expect(Ok, stat);
GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
stat = GdipRestoreGraphics(graphics1, state_a);
todo_wine
expect(Ok, stat);
GdipGetInterpolationMode(graphics1, &mode);
todo_wine
expect(InterpolationModeBilinear, mode);
GdipDeleteGraphics(graphics1);
log_state(state_a, &state_log);
/* Restoring garbage doesn't affect saves. */
GdipCreateFromHDC(hdc, &graphics1);
GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
GdipSaveGraphics(graphics1, &state_a);
GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
GdipSaveGraphics(graphics1, &state_b);
GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
stat = GdipRestoreGraphics(graphics1, 0xdeadbeef);
todo_wine
expect(Ok, stat);
GdipRestoreGraphics(graphics1, state_b);
GdipGetInterpolationMode(graphics1, &mode);
todo_wine
expect(InterpolationModeBicubic, mode);
GdipRestoreGraphics(graphics1, state_a);
GdipGetInterpolationMode(graphics1, &mode);
todo_wine
expect(InterpolationModeBilinear, mode);
GdipDeleteGraphics(graphics1);
log_state(state_a, &state_log);
log_state(state_b, &state_log);
/* Restoring older state invalidates newer saves (but not older saves). */
GdipCreateFromHDC(hdc, &graphics1);
GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
GdipSaveGraphics(graphics1, &state_a);
GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
GdipSaveGraphics(graphics1, &state_b);
GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
GdipSaveGraphics(graphics1, &state_c);
GdipSetInterpolationMode(graphics1, InterpolationModeHighQualityBilinear);
GdipRestoreGraphics(graphics1, state_b);
GdipGetInterpolationMode(graphics1, &mode);
todo_wine
expect(InterpolationModeBicubic, mode);
GdipRestoreGraphics(graphics1, state_c);
GdipGetInterpolationMode(graphics1, &mode);
todo_wine
expect(InterpolationModeBicubic, mode);
GdipRestoreGraphics(graphics1, state_a);
GdipGetInterpolationMode(graphics1, &mode);
todo_wine
expect(InterpolationModeBilinear, mode);
GdipDeleteGraphics(graphics1);
log_state(state_a, &state_log);
log_state(state_b, &state_log);
log_state(state_c, &state_log);
/* Restoring older save from one graphics object does not invalidate
* newer save from other graphics object. */
GdipCreateFromHDC(hdc, &graphics1);
GdipCreateFromHDC(hdc, &graphics2);
GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
GdipSaveGraphics(graphics1, &state_a);
GdipSetInterpolationMode(graphics2, InterpolationModeBicubic);
GdipSaveGraphics(graphics2, &state_b);
GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
GdipRestoreGraphics(graphics1, state_a);
GdipGetInterpolationMode(graphics1, &mode);
todo_wine
expect(InterpolationModeBilinear, mode);
GdipRestoreGraphics(graphics2, state_b);
GdipGetInterpolationMode(graphics2, &mode);
todo_wine
expect(InterpolationModeBicubic, mode);
GdipDeleteGraphics(graphics1);
GdipDeleteGraphics(graphics2);
/* You can't restore a state to a graphics object that didn't save it. */
GdipCreateFromHDC(hdc, &graphics1);
GdipCreateFromHDC(hdc, &graphics2);
GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
GdipSaveGraphics(graphics1, &state_a);
GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
GdipRestoreGraphics(graphics2, state_a);
GdipGetInterpolationMode(graphics2, &mode);
expect(InterpolationModeNearestNeighbor, mode);
GdipDeleteGraphics(graphics1);
GdipDeleteGraphics(graphics2);
log_state(state_a, &state_log);
/* The same state value should never be returned twice. */
todo_wine
check_no_duplicates(state_log);
ReleaseDC(0, hdc);
}
static void test_GdipDrawArc(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
GpPen *pen = NULL;
HDC hdc = GetDC(0);
/* make a graphics object and pen object */
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(hdc != NULL, "Expected HDC to be initialized\n");
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(graphics != NULL, "Expected graphics to be initialized\n");
status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
expect(Ok, status);
ok(pen != NULL, "Expected pen to be initialized\n");
/* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
status = GdipDrawArc(NULL, NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
expect(InvalidParameter, status);
status = GdipDrawArc(graphics, NULL, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
expect(InvalidParameter, status);
status = GdipDrawArc(NULL, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
expect(InvalidParameter, status);
status = GdipDrawArc(graphics, pen, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
expect(InvalidParameter, status);
status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
expect(InvalidParameter, status);
/* successful case */
status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
expect(Ok, status);
GdipDeletePen(pen);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_GdipDrawArcI(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
GpPen *pen = NULL;
HDC hdc = GetDC(0);
/* make a graphics object and pen object */
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(hdc != NULL, "Expected HDC to be initialized\n");
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(graphics != NULL, "Expected graphics to be initialized\n");
status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
expect(Ok, status);
ok(pen != NULL, "Expected pen to be initialized\n");
/* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
status = GdipDrawArcI(NULL, NULL, 0, 0, 0, 0, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawArcI(graphics, NULL, 0, 0, 1, 1, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawArcI(NULL, pen, 0, 0, 1, 1, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawArcI(graphics, pen, 0, 0, 1, 0, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawArcI(graphics, pen, 0, 0, 0, 1, 0, 0);
expect(InvalidParameter, status);
/* successful case */
status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0, 0);
expect(Ok, status);
GdipDeletePen(pen);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_GdipDrawBezierI(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
GpPen *pen = NULL;
HDC hdc = GetDC(0);
/* make a graphics object and pen object */
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(hdc != NULL, "Expected HDC to be initialized\n");
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(graphics != NULL, "Expected graphics to be initialized\n");
status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
expect(Ok, status);
ok(pen != NULL, "Expected pen to be initialized\n");
/* InvalidParameter cases: null graphics, null pen */
status = GdipDrawBezierI(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawBezierI(graphics, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawBezierI(NULL, pen, 0, 0, 0, 0, 0, 0, 0, 0);
expect(InvalidParameter, status);
/* successful case */
status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
expect(Ok, status);
GdipDeletePen(pen);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_GdipDrawLineI(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
GpPen *pen = NULL;
HDC hdc = GetDC(0);
/* make a graphics object and pen object */
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(hdc != NULL, "Expected HDC to be initialized\n");
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(graphics != NULL, "Expected graphics to be initialized\n");
status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
expect(Ok, status);
ok(pen != NULL, "Expected pen to be initialized\n");
/* InvalidParameter cases: null graphics, null pen */
status = GdipDrawLineI(NULL, NULL, 0, 0, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawLineI(graphics, NULL, 0, 0, 0, 0);
expect(InvalidParameter, status);
status = GdipDrawLineI(NULL, pen, 0, 0, 0, 0);
expect(InvalidParameter, status);
/* successful case */
status = GdipDrawLineI(graphics, pen, 0, 0, 0, 0);
expect(Ok, status);
GdipDeletePen(pen);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_GdipDrawLinesI(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
GpPen *pen = NULL;
GpPoint *ptf = NULL;
HDC hdc = GetDC(0);
/* make a graphics object and pen object */
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(hdc != NULL, "Expected HDC to be initialized\n");
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(graphics != NULL, "Expected graphics to be initialized\n");
status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
expect(Ok, status);
ok(pen != NULL, "Expected pen to be initialized\n");
/* make some arbitrary valid points*/
ptf = GdipAlloc(2 * sizeof(GpPointF));
ptf[0].X = 1;
ptf[0].Y = 1;
ptf[1].X = 2;
ptf[1].Y = 2;
/* InvalidParameter cases: null graphics, null pen, null points, count < 2*/
status = GdipDrawLinesI(NULL, NULL, NULL, 0);
expect(InvalidParameter, status);
status = GdipDrawLinesI(graphics, pen, ptf, 0);
expect(InvalidParameter, status);
status = GdipDrawLinesI(graphics, NULL, ptf, 2);
expect(InvalidParameter, status);
status = GdipDrawLinesI(NULL, pen, ptf, 2);
expect(InvalidParameter, status);
/* successful case */
status = GdipDrawLinesI(graphics, pen, ptf, 2);
expect(Ok, status);
GdipFree(ptf);
GdipDeletePen(pen);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_Get_Release_DC(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
GpPen *pen;
GpSolidFill *brush;
GpPath *path;
HDC hdc = GetDC(0);
HDC retdc;
REAL r;
CompositingQuality quality;
CompositingMode compmode;
InterpolationMode intmode;
GpMatrix *m;
GpRegion *region;
GpUnit unit;
PixelOffsetMode offsetmode;
SmoothingMode smoothmode;
TextRenderingHint texthint;
GpPointF ptf[5];
GpPoint pt[5];
GpRectF rectf[2];
GpRect rect[2];
GpRegion *clip;
INT i;
pt[0].X = 10;
pt[0].Y = 10;
pt[1].X = 20;
pt[1].Y = 15;
pt[2].X = 40;
pt[2].Y = 80;
pt[3].X = -20;
pt[3].Y = 20;
pt[4].X = 50;
pt[4].Y = 110;
for(i = 0; i < 5;i++){
ptf[i].X = (REAL)pt[i].X;
ptf[i].Y = (REAL)pt[i].Y;
}
rect[0].X = 0;
rect[0].Y = 0;
rect[0].Width = 50;
rect[0].Height = 70;
rect[1].X = 0;
rect[1].Y = 0;
rect[1].Width = 10;
rect[1].Height = 20;
for(i = 0; i < 2;i++){
rectf[i].X = (REAL)rect[i].X;
rectf[i].Y = (REAL)rect[i].Y;
rectf[i].Height = (REAL)rect[i].Height;
rectf[i].Width = (REAL)rect[i].Width;
}
GdipCreateMatrix(&m);
GdipCreateRegion(&region);
GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
GdipCreatePath(FillModeAlternate, &path);
GdipCreateRegion(&clip);
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
ok(graphics != NULL, "Expected graphics to be initialized\n");
status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
expect(Ok, status);
/* NULL arguments */
status = GdipGetDC(NULL, NULL);
expect(InvalidParameter, status);
status = GdipGetDC(graphics, NULL);
expect(InvalidParameter, status);
status = GdipGetDC(NULL, &retdc);
expect(InvalidParameter, status);
status = GdipReleaseDC(NULL, NULL);
expect(InvalidParameter, status);
status = GdipReleaseDC(graphics, NULL);
expect(InvalidParameter, status);
status = GdipReleaseDC(NULL, (HDC)0xdeadbeef);
expect(InvalidParameter, status);
/* Release without Get */
status = GdipReleaseDC(graphics, hdc);
expect(InvalidParameter, status);
retdc = NULL;
status = GdipGetDC(graphics, &retdc);
expect(Ok, status);
ok(retdc == hdc, "Invalid HDC returned\n");
/* call it once more */
status = GdipGetDC(graphics, &retdc);
expect(ObjectBusy, status);
/* try all Graphics calls here */
status = Ok;
status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0.0, 0.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawBezier(graphics, pen, 0.0, 10.0, 20.0, 15.0, 35.0, -10.0, 10.0, 10.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawBeziers(graphics, pen, ptf, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawBeziersI(graphics, pen, pt, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawClosedCurve(graphics, pen, ptf, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawClosedCurveI(graphics, pen, pt, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawClosedCurve2(graphics, pen, ptf, 5, 1.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawClosedCurve2I(graphics, pen, pt, 5, 1.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawCurve(graphics, pen, ptf, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawCurveI(graphics, pen, pt, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawCurve2(graphics, pen, ptf, 5, 1.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawCurve2I(graphics, pen, pt, 5, 1.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawEllipse(graphics, pen, 0.0, 0.0, 100.0, 50.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawEllipseI(graphics, pen, 0, 0, 100, 50);
expect(ObjectBusy, status); status = Ok;
/* GdipDrawImage/GdipDrawImageI */
/* GdipDrawImagePointsRect/GdipDrawImagePointsRectI */
/* GdipDrawImageRectRect/GdipDrawImageRectRectI */
/* GdipDrawImageRect/GdipDrawImageRectI */
status = GdipDrawLine(graphics, pen, 0.0, 0.0, 100.0, 200.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawLineI(graphics, pen, 0, 0, 100, 200);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawLines(graphics, pen, ptf, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawLinesI(graphics, pen, pt, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawPath(graphics, pen, path);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawPie(graphics, pen, 0.0, 0.0, 100.0, 100.0, 0.0, 90.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawPieI(graphics, pen, 0, 0, 100, 100, 0.0, 90.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawRectangle(graphics, pen, 0.0, 0.0, 100.0, 300.0);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawRectangleI(graphics, pen, 0, 0, 100, 300);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawRectangles(graphics, pen, rectf, 2);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawRectanglesI(graphics, pen, rect, 2);
expect(ObjectBusy, status); status = Ok;
/* GdipDrawString */
status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, ptf, 5, 1.0, FillModeAlternate);
expect(ObjectBusy, status); status = Ok;
status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, pt, 5, 1.0, FillModeAlternate);
expect(ObjectBusy, status); status = Ok;
status = GdipFillEllipse(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
expect(ObjectBusy, status); status = Ok;
status = GdipFillEllipseI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
expect(ObjectBusy, status); status = Ok;
status = GdipFillPath(graphics, (GpBrush*)brush, path);
expect(ObjectBusy, status); status = Ok;
status = GdipFillPie(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0, 0.0, 15.0);
expect(ObjectBusy, status); status = Ok;
status = GdipFillPieI(graphics, (GpBrush*)brush, 0, 0, 100, 100, 0.0, 15.0);
expect(ObjectBusy, status); status = Ok;
status = GdipFillPolygon(graphics, (GpBrush*)brush, ptf, 5, FillModeAlternate);
expect(ObjectBusy, status); status = Ok;
status = GdipFillPolygonI(graphics, (GpBrush*)brush, pt, 5, FillModeAlternate);
expect(ObjectBusy, status); status = Ok;
status = GdipFillPolygon2(graphics, (GpBrush*)brush, ptf, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipFillPolygon2I(graphics, (GpBrush*)brush, pt, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipFillRectangle(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
expect(ObjectBusy, status); status = Ok;
status = GdipFillRectangleI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
expect(ObjectBusy, status); status = Ok;
status = GdipFillRectangles(graphics, (GpBrush*)brush, rectf, 2);
expect(ObjectBusy, status); status = Ok;
status = GdipFillRectanglesI(graphics, (GpBrush*)brush, rect, 2);
expect(ObjectBusy, status); status = Ok;
status = GdipFillRegion(graphics, (GpBrush*)brush, region);
expect(ObjectBusy, status); status = Ok;
status = GdipFlush(graphics, FlushIntentionFlush);
expect(ObjectBusy, status); status = Ok;
status = GdipGetCompositingMode(graphics, &compmode);
expect(ObjectBusy, status); status = Ok;
status = GdipGetCompositingQuality(graphics, &quality);
expect(ObjectBusy, status); status = Ok;
status = GdipGetInterpolationMode(graphics, &intmode);
expect(ObjectBusy, status); status = Ok;
status = GdipGetPageScale(graphics, &r);
expect(ObjectBusy, status); status = Ok;
status = GdipGetPageUnit(graphics, &unit);
expect(ObjectBusy, status); status = Ok;
status = GdipGetPixelOffsetMode(graphics, &offsetmode);
expect(ObjectBusy, status); status = Ok;
status = GdipGetSmoothingMode(graphics, &smoothmode);
expect(ObjectBusy, status); status = Ok;
status = GdipGetTextRenderingHint(graphics, &texthint);
expect(ObjectBusy, status); status = Ok;
status = GdipGetWorldTransform(graphics, m);
expect(ObjectBusy, status); status = Ok;
status = GdipGraphicsClear(graphics, 0xdeadbeef);
expect(ObjectBusy, status); status = Ok;
/* GdipMeasureCharacterRanges */
/* GdipMeasureString */
status = GdipResetClip(graphics);
expect(ObjectBusy, status); status = Ok;
status = GdipResetWorldTransform(graphics);
expect(ObjectBusy, status); status = Ok;
/* GdipRestoreGraphics */
status = GdipRotateWorldTransform(graphics, 15.0, MatrixOrderPrepend);
expect(ObjectBusy, status); status = Ok;
/* GdipSaveGraphics */
status = GdipScaleWorldTransform(graphics, 1.0, 1.0, MatrixOrderPrepend);
expect(ObjectBusy, status); status = Ok;
status = GdipSetCompositingMode(graphics, CompositingModeSourceOver);
expect(ObjectBusy, status); status = Ok;
status = GdipSetCompositingQuality(graphics, CompositingQualityDefault);
expect(ObjectBusy, status); status = Ok;
status = GdipSetInterpolationMode(graphics, InterpolationModeDefault);
expect(ObjectBusy, status); status = Ok;
status = GdipSetPageScale(graphics, 1.0);
expect(ObjectBusy, status); status = Ok;
status = GdipSetPageUnit(graphics, UnitWorld);
expect(ObjectBusy, status); status = Ok;
status = GdipSetPixelOffsetMode(graphics, PixelOffsetModeDefault);
expect(ObjectBusy, status); status = Ok;
status = GdipSetSmoothingMode(graphics, SmoothingModeDefault);
expect(ObjectBusy, status); status = Ok;
status = GdipSetTextRenderingHint(graphics, TextRenderingHintSystemDefault);
expect(ObjectBusy, status); status = Ok;
status = GdipSetWorldTransform(graphics, m);
expect(ObjectBusy, status); status = Ok;
status = GdipTranslateWorldTransform(graphics, 0.0, 0.0, MatrixOrderPrepend);
expect(ObjectBusy, status); status = Ok;
status = GdipSetClipRectI(graphics, 0, 0, 10, 10, CombineModeReplace);
expect(ObjectBusy, status); status = Ok;
status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
expect(ObjectBusy, status);
status = GdipDrawPolygon(graphics, pen, ptf, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipDrawPolygonI(graphics, pen, pt, 5);
expect(ObjectBusy, status); status = Ok;
status = GdipGetDpiX(graphics, &r);
expect(ObjectBusy, status); status = Ok;
status = GdipGetDpiY(graphics, &r);
expect(ObjectBusy, status); status = Ok;
status = GdipMultiplyWorldTransform(graphics, m, MatrixOrderPrepend);
status = GdipGetClip(graphics, region);
expect(ObjectBusy, status); status = Ok;
status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 5);
expect(ObjectBusy, status); status = Ok;
/* try to delete before release */
status = GdipDeleteGraphics(graphics);
expect(ObjectBusy, status);
status = GdipReleaseDC(graphics, retdc);
expect(Ok, status);
GdipDeletePen(pen);
GdipDeleteGraphics(graphics);
GdipDeletePath(path);
GdipDeleteBrush((GpBrush*)brush);
GdipDeleteRegion(region);
GdipDeleteMatrix(m);
GdipDeleteRegion(region);
ReleaseDC(0, hdc);
}
static void test_transformpoints(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
HDC hdc = GetDC(0);
GpPointF ptf[5];
INT i;
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
for(i = 0; i < 5; i++){
ptf[i].X = 200.0 + i * 50.0 * (i % 2);
ptf[i].Y = 200.0 + i * 50.0 * !(i % 2);
}
/* NULL arguments */
status = GdipTransformPoints(NULL, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
expect(InvalidParameter, status);
status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
expect(InvalidParameter, status);
status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 0);
expect(InvalidParameter, status);
status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, -1);
expect(InvalidParameter, status);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_get_set_clip(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
HDC hdc = GetDC(0);
GpRegion *clip;
GpRectF rect;
BOOL res;
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
rect.X = rect.Y = 0.0;
rect.Height = rect.Width = 100.0;
status = GdipCreateRegionRect(&rect, &clip);
/* NULL arguments */
status = GdipGetClip(NULL, NULL);
expect(InvalidParameter, status);
status = GdipGetClip(graphics, NULL);
expect(InvalidParameter, status);
status = GdipGetClip(NULL, clip);
expect(InvalidParameter, status);
status = GdipSetClipRegion(NULL, NULL, CombineModeReplace);
expect(InvalidParameter, status);
status = GdipSetClipRegion(graphics, NULL, CombineModeReplace);
expect(InvalidParameter, status);
res = FALSE;
status = GdipGetClip(graphics, clip);
expect(Ok, status);
status = GdipIsInfiniteRegion(clip, graphics, &res);
expect(Ok, status);
expect(TRUE, res);
/* remains infinite after reset */
res = FALSE;
status = GdipResetClip(graphics);
expect(Ok, status);
status = GdipGetClip(graphics, clip);
expect(Ok, status);
status = GdipIsInfiniteRegion(clip, graphics, &res);
expect(Ok, status);
expect(TRUE, res);
/* set to empty and then reset to infinite */
status = GdipSetEmpty(clip);
expect(Ok, status);
status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
expect(Ok, status);
status = GdipGetClip(graphics, clip);
expect(Ok, status);
res = FALSE;
status = GdipIsEmptyRegion(clip, graphics, &res);
expect(Ok, status);
expect(TRUE, res);
status = GdipResetClip(graphics);
expect(Ok, status);
status = GdipGetClip(graphics, clip);
expect(Ok, status);
res = FALSE;
status = GdipIsInfiniteRegion(clip, graphics, &res);
expect(Ok, status);
expect(TRUE, res);
GdipDeleteRegion(clip);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_isempty(void)
{
GpStatus status;
GpGraphics *graphics = NULL;
HDC hdc = GetDC(0);
GpRegion *clip;
BOOL res;
status = GdipCreateFromHDC(hdc, &graphics);
expect(Ok, status);
status = GdipCreateRegion(&clip);
expect(Ok, status);
/* NULL */
status = GdipIsClipEmpty(NULL, NULL);
expect(InvalidParameter, status);
status = GdipIsClipEmpty(graphics, NULL);
expect(InvalidParameter, status);
status = GdipIsClipEmpty(NULL, &res);
expect(InvalidParameter, status);
/* default is infinite */
res = TRUE;
status = GdipIsClipEmpty(graphics, &res);
expect(Ok, status);
expect(FALSE, res);
GdipDeleteRegion(clip);
GdipDeleteGraphics(graphics);
ReleaseDC(0, hdc);
}
static void test_clear(void)
{
GpStatus status;
status = GdipGraphicsClear(NULL, 0xdeadbeef);
expect(InvalidParameter, status);
}
START_TEST(graphics)
{
struct GdiplusStartupInput gdiplusStartupInput;
ULONG_PTR gdiplusToken;
gdiplusStartupInput.GdiplusVersion = 1;
gdiplusStartupInput.DebugEventCallback = NULL;
gdiplusStartupInput.SuppressBackgroundThread = 0;
gdiplusStartupInput.SuppressExternalCodecs = 0;
GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
test_constructor_destructor();
test_save_restore();
test_GdipDrawBezierI();
test_GdipDrawArc();
test_GdipDrawArcI();
test_GdipDrawLineI();
test_GdipDrawLinesI();
test_Get_Release_DC();
test_transformpoints();
test_get_set_clip();
test_isempty();
test_clear();
GdiplusShutdown(gdiplusToken);
}