dlls/gdiplus/tests/graphics.c

   1 /*
   2  * Unit test suite for graphics objects
   3  *
   4  * Copyright (C) 2007 Google (Evan Stade)
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include "windows.h"
  22 #include "gdiplus.h"
  23 #include "wingdi.h"
  24 #include "wine/test.h"
  25
  26 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
  27 #define TABLE_LEN (23)
  28
  29 static void test_constructor_destructor(void)
  30 {
  31     GpStatus stat;
  32     GpGraphics *graphics = NULL;
  33     HDC hdc = GetDC(0);
  34
  35     stat = GdipCreateFromHDC(NULL, &graphics);
  36     expect(OutOfMemory, stat);
  37     stat = GdipDeleteGraphics(graphics);
  38     expect(InvalidParameter, stat);
  39
  40     stat = GdipCreateFromHDC(hdc, &graphics);
  41     expect(Ok, stat);
  42     stat = GdipDeleteGraphics(graphics);
  43     expect(Ok, stat);
  44
  45     stat = GdipCreateFromHWND(NULL, &graphics);
  46     expect(Ok, stat);
  47     stat = GdipDeleteGraphics(graphics);
  48     expect(Ok, stat);
  49
  50     stat = GdipCreateFromHWNDICM(NULL, &graphics);
  51     expect(Ok, stat);
  52     stat = GdipDeleteGraphics(graphics);
  53     expect(Ok, stat);
  54
  55     stat = GdipDeleteGraphics(NULL);
  56     expect(InvalidParameter, stat);
  57     ReleaseDC(0, hdc);
  58 }
  59
  60 typedef struct node{
  61     GraphicsState data;
  62     struct node * next;
  63 } node;
  64
  65 /* Linked list prepend function. */
  66 static void log_state(GraphicsState data, node ** log)
  67 {
  68     node * new_entry = HeapAlloc(GetProcessHeap(), 0, sizeof(node));
  69
  70     new_entry->data = data;
  71     new_entry->next = *log;
  72     *log = new_entry;
  73 }
  74
  75 /* Checks if there are duplicates in the list, and frees it. */
  76 static void check_no_duplicates(node * log)
  77 {
  78     INT dups = 0;
  79     node * temp = NULL;
  80     node * temp2 = NULL;
  81     node * orig = log;
  82
  83     if(!log)
  84         goto end;
  85
  86     do{
  87         temp = log;
  88         while((temp = temp->next)){
  89             if(log->data == temp->data){
  90                 dups++;
  91                 break;
  92             }
  93             if(dups > 0)
  94                 break;
  95         }
  96     }while((log = log->next));
  97
  98     temp = orig;
  99     do{
 100         temp2 = temp->next;
 101         HeapFree(GetProcessHeap(), 0, temp);
 102         temp = temp2;
 103     }while(temp);
 104
 105 end:
 106     expect(0, dups);
 107 }
 108
 109 static void test_save_restore(void)
 110 {
 111     GpStatus stat;
 112     GraphicsState state_a, state_b, state_c;
 113     InterpolationMode mode;
 114     GpGraphics *graphics1, *graphics2;
 115     node * state_log = NULL;
 116     HDC hdc = GetDC(0);
 117     state_a = state_b = state_c = 0xdeadbeef;
 118
 119     /* Invalid saving. */
 120     GdipCreateFromHDC(hdc, &graphics1);
 121     stat = GdipSaveGraphics(graphics1, NULL);
 122     expect(InvalidParameter, stat);
 123     stat = GdipSaveGraphics(NULL, &state_a);
 124     expect(InvalidParameter, stat);
 125     GdipDeleteGraphics(graphics1);
 126
 127     log_state(state_a, &state_log);
 128
 129     /* Basic save/restore. */
 130     GdipCreateFromHDC(hdc, &graphics1);
 131     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 132     stat = GdipSaveGraphics(graphics1, &state_a);
 133     todo_wine
 134         expect(Ok, stat);
 135     GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
 136     stat = GdipRestoreGraphics(graphics1, state_a);
 137     todo_wine
 138         expect(Ok, stat);
 139     GdipGetInterpolationMode(graphics1, &mode);
 140     todo_wine
 141         expect(InterpolationModeBilinear, mode);
 142     GdipDeleteGraphics(graphics1);
 143
 144     log_state(state_a, &state_log);
 145
 146     /* Restoring garbage doesn't affect saves. */
 147     GdipCreateFromHDC(hdc, &graphics1);
 148     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 149     GdipSaveGraphics(graphics1, &state_a);
 150     GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
 151     GdipSaveGraphics(graphics1, &state_b);
 152     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 153     stat = GdipRestoreGraphics(graphics1, 0xdeadbeef);
 154     todo_wine
 155         expect(Ok, stat);
 156     GdipRestoreGraphics(graphics1, state_b);
 157     GdipGetInterpolationMode(graphics1, &mode);
 158     todo_wine
 159         expect(InterpolationModeBicubic, mode);
 160     GdipRestoreGraphics(graphics1, state_a);
 161     GdipGetInterpolationMode(graphics1, &mode);
 162     todo_wine
 163         expect(InterpolationModeBilinear, mode);
 164     GdipDeleteGraphics(graphics1);
 165
 166     log_state(state_a, &state_log);
 167     log_state(state_b, &state_log);
 168
 169     /* Restoring older state invalidates newer saves (but not older saves). */
 170     GdipCreateFromHDC(hdc, &graphics1);
 171     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 172     GdipSaveGraphics(graphics1, &state_a);
 173     GdipSetInterpolationMode(graphics1, InterpolationModeBicubic);
 174     GdipSaveGraphics(graphics1, &state_b);
 175     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 176     GdipSaveGraphics(graphics1, &state_c);
 177     GdipSetInterpolationMode(graphics1, InterpolationModeHighQualityBilinear);
 178     GdipRestoreGraphics(graphics1, state_b);
 179     GdipGetInterpolationMode(graphics1, &mode);
 180     todo_wine
 181         expect(InterpolationModeBicubic, mode);
 182     GdipRestoreGraphics(graphics1, state_c);
 183     GdipGetInterpolationMode(graphics1, &mode);
 184     todo_wine
 185         expect(InterpolationModeBicubic, mode);
 186     GdipRestoreGraphics(graphics1, state_a);
 187     GdipGetInterpolationMode(graphics1, &mode);
 188     todo_wine
 189         expect(InterpolationModeBilinear, mode);
 190     GdipDeleteGraphics(graphics1);
 191
 192     log_state(state_a, &state_log);
 193     log_state(state_b, &state_log);
 194     log_state(state_c, &state_log);
 195
 196     /* Restoring older save from one graphics object does not invalidate
 197      * newer save from other graphics object. */
 198     GdipCreateFromHDC(hdc, &graphics1);
 199     GdipCreateFromHDC(hdc, &graphics2);
 200     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 201     GdipSaveGraphics(graphics1, &state_a);
 202     GdipSetInterpolationMode(graphics2, InterpolationModeBicubic);
 203     GdipSaveGraphics(graphics2, &state_b);
 204     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 205     GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
 206     GdipRestoreGraphics(graphics1, state_a);
 207     GdipGetInterpolationMode(graphics1, &mode);
 208     todo_wine
 209         expect(InterpolationModeBilinear, mode);
 210     GdipRestoreGraphics(graphics2, state_b);
 211     GdipGetInterpolationMode(graphics2, &mode);
 212     todo_wine
 213         expect(InterpolationModeBicubic, mode);
 214     GdipDeleteGraphics(graphics1);
 215     GdipDeleteGraphics(graphics2);
 216
 217     /* You can't restore a state to a graphics object that didn't save it. */
 218     GdipCreateFromHDC(hdc, &graphics1);
 219     GdipCreateFromHDC(hdc, &graphics2);
 220     GdipSetInterpolationMode(graphics1, InterpolationModeBilinear);
 221     GdipSaveGraphics(graphics1, &state_a);
 222     GdipSetInterpolationMode(graphics1, InterpolationModeNearestNeighbor);
 223     GdipSetInterpolationMode(graphics2, InterpolationModeNearestNeighbor);
 224     GdipRestoreGraphics(graphics2, state_a);
 225     GdipGetInterpolationMode(graphics2, &mode);
 226     expect(InterpolationModeNearestNeighbor, mode);
 227     GdipDeleteGraphics(graphics1);
 228     GdipDeleteGraphics(graphics2);
 229
 230     log_state(state_a, &state_log);
 231
 232     /* The same state value should never be returned twice. */
 233     todo_wine
 234         check_no_duplicates(state_log);
 235
 236     ReleaseDC(0, hdc);
 237 }
 238
 239 static void test_GdipDrawArc(void)
 240 {
 241     GpStatus status;
 242     GpGraphics *graphics = NULL;
 243     GpPen *pen = NULL;
 244     HDC hdc = GetDC(0);
 245
 246     /* make a graphics object and pen object */
 247     status = GdipCreateFromHDC(hdc, &graphics);
 248     expect(Ok, status);
 249     ok(hdc != NULL, "Expected HDC to be initialized\n");
 250
 251     status = GdipCreateFromHDC(hdc, &graphics);
 252     expect(Ok, status);
 253     ok(graphics != NULL, "Expected graphics to be initialized\n");
 254
 255     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 256     expect(Ok, status);
 257     ok(pen != NULL, "Expected pen to be initialized\n");
 258
 259     /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
 260     status = GdipDrawArc(NULL, NULL, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0);
 261     expect(InvalidParameter, status);
 262
 263     status = GdipDrawArc(graphics, NULL, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 264     expect(InvalidParameter, status);
 265
 266     status = GdipDrawArc(NULL, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 267     expect(InvalidParameter, status);
 268
 269     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0);
 270     expect(InvalidParameter, status);
 271
 272     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0);
 273     expect(InvalidParameter, status);
 274
 275     /* successful case */
 276     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 277     expect(Ok, status);
 278
 279     GdipDeletePen(pen);
 280     GdipDeleteGraphics(graphics);
 281
 282     ReleaseDC(0, hdc);
 283 }
 284
 285 static void test_GdipDrawArcI(void)
 286 {
 287     GpStatus status;
 288     GpGraphics *graphics = NULL;
 289     GpPen *pen = NULL;
 290     HDC hdc = GetDC(0);
 291
 292     /* make a graphics object and pen object */
 293     status = GdipCreateFromHDC(hdc, &graphics);
 294     expect(Ok, status);
 295     ok(hdc != NULL, "Expected HDC to be initialized\n");
 296
 297     status = GdipCreateFromHDC(hdc, &graphics);
 298     expect(Ok, status);
 299     ok(graphics != NULL, "Expected graphics to be initialized\n");
 300
 301     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 302     expect(Ok, status);
 303     ok(pen != NULL, "Expected pen to be initialized\n");
 304
 305     /* InvalidParameter cases: null graphics, null pen, non-positive width, non-positive height */
 306     status = GdipDrawArcI(NULL, NULL, 0, 0, 0, 0, 0, 0);
 307     expect(InvalidParameter, status);
 308
 309     status = GdipDrawArcI(graphics, NULL, 0, 0, 1, 1, 0, 0);
 310     expect(InvalidParameter, status);
 311
 312     status = GdipDrawArcI(NULL, pen, 0, 0, 1, 1, 0, 0);
 313     expect(InvalidParameter, status);
 314
 315     status = GdipDrawArcI(graphics, pen, 0, 0, 1, 0, 0, 0);
 316     expect(InvalidParameter, status);
 317
 318     status = GdipDrawArcI(graphics, pen, 0, 0, 0, 1, 0, 0);
 319     expect(InvalidParameter, status);
 320
 321     /* successful case */
 322     status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0, 0);
 323     expect(Ok, status);
 324
 325     GdipDeletePen(pen);
 326     GdipDeleteGraphics(graphics);
 327
 328     ReleaseDC(0, hdc);
 329 }
 330
 331 static void test_GdipDrawBezierI(void)
 332 {
 333     GpStatus status;
 334     GpGraphics *graphics = NULL;
 335     GpPen *pen = NULL;
 336     HDC hdc = GetDC(0);
 337
 338     /* make a graphics object and pen object */
 339     status = GdipCreateFromHDC(hdc, &graphics);
 340     expect(Ok, status);
 341     ok(hdc != NULL, "Expected HDC to be initialized\n");
 342
 343     status = GdipCreateFromHDC(hdc, &graphics);
 344     expect(Ok, status);
 345     ok(graphics != NULL, "Expected graphics to be initialized\n");
 346
 347     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 348     expect(Ok, status);
 349     ok(pen != NULL, "Expected pen to be initialized\n");
 350
 351     /* InvalidParameter cases: null graphics, null pen */
 352     status = GdipDrawBezierI(NULL, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
 353     expect(InvalidParameter, status);
 354
 355     status = GdipDrawBezierI(graphics, NULL, 0, 0, 0, 0, 0, 0, 0, 0);
 356     expect(InvalidParameter, status);
 357
 358     status = GdipDrawBezierI(NULL, pen, 0, 0, 0, 0, 0, 0, 0, 0);
 359     expect(InvalidParameter, status);
 360
 361     /* successful case */
 362     status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
 363     expect(Ok, status);
 364
 365     GdipDeletePen(pen);
 366     GdipDeleteGraphics(graphics);
 367
 368     ReleaseDC(0, hdc);
 369 }
 370
 371 static void test_GdipDrawLineI(void)
 372 {
 373     GpStatus status;
 374     GpGraphics *graphics = NULL;
 375     GpPen *pen = NULL;
 376     HDC hdc = GetDC(0);
 377
 378     /* make a graphics object and pen object */
 379     status = GdipCreateFromHDC(hdc, &graphics);
 380     expect(Ok, status);
 381     ok(hdc != NULL, "Expected HDC to be initialized\n");
 382
 383     status = GdipCreateFromHDC(hdc, &graphics);
 384     expect(Ok, status);
 385     ok(graphics != NULL, "Expected graphics to be initialized\n");
 386
 387     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 388     expect(Ok, status);
 389     ok(pen != NULL, "Expected pen to be initialized\n");
 390
 391     /* InvalidParameter cases: null graphics, null pen */
 392     status = GdipDrawLineI(NULL, NULL, 0, 0, 0, 0);
 393     expect(InvalidParameter, status);
 394
 395     status = GdipDrawLineI(graphics, NULL, 0, 0, 0, 0);
 396     expect(InvalidParameter, status);
 397
 398     status = GdipDrawLineI(NULL, pen, 0, 0, 0, 0);
 399     expect(InvalidParameter, status);
 400
 401     /* successful case */
 402     status = GdipDrawLineI(graphics, pen, 0, 0, 0, 0);
 403     expect(Ok, status);
 404
 405     GdipDeletePen(pen);
 406     GdipDeleteGraphics(graphics);
 407
 408     ReleaseDC(0, hdc);
 409 }
 410
 411 static void test_GdipDrawLinesI(void)
 412 {
 413     GpStatus status;
 414     GpGraphics *graphics = NULL;
 415     GpPen *pen = NULL;
 416     GpPoint *ptf = NULL;
 417     HDC hdc = GetDC(0);
 418
 419     /* make a graphics object and pen object */
 420     status = GdipCreateFromHDC(hdc, &graphics);
 421     expect(Ok, status);
 422     ok(hdc != NULL, "Expected HDC to be initialized\n");
 423
 424     status = GdipCreateFromHDC(hdc, &graphics);
 425     expect(Ok, status);
 426     ok(graphics != NULL, "Expected graphics to be initialized\n");
 427
 428     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 429     expect(Ok, status);
 430     ok(pen != NULL, "Expected pen to be initialized\n");
 431
 432     /* make some arbitrary valid points*/
 433     ptf = GdipAlloc(2 * sizeof(GpPointF));
 434
 435     ptf[0].X = 1;
 436     ptf[0].Y = 1;
 437
 438     ptf[1].X = 2;
 439     ptf[1].Y = 2;
 440
 441     /* InvalidParameter cases: null graphics, null pen, null points, count < 2*/
 442     status = GdipDrawLinesI(NULL, NULL, NULL, 0);
 443     expect(InvalidParameter, status);
 444
 445     status = GdipDrawLinesI(graphics, pen, ptf, 0);
 446     expect(InvalidParameter, status);
 447
 448     status = GdipDrawLinesI(graphics, NULL, ptf, 2);
 449     expect(InvalidParameter, status);
 450
 451     status = GdipDrawLinesI(NULL, pen, ptf, 2);
 452     expect(InvalidParameter, status);
 453
 454     /* successful case */
 455     status = GdipDrawLinesI(graphics, pen, ptf, 2);
 456     expect(Ok, status);
 457
 458     GdipFree(ptf);
 459     GdipDeletePen(pen);
 460     GdipDeleteGraphics(graphics);
 461
 462     ReleaseDC(0, hdc);
 463 }
 464
 465 static void test_Get_Release_DC(void)
 466 {
 467     GpStatus status;
 468     GpGraphics *graphics = NULL;
 469     GpPen *pen;
 470     GpSolidFill *brush;
 471     GpPath *path;
 472     HDC hdc = GetDC(0);
 473     HDC retdc;
 474     REAL r;
 475     CompositingQuality quality;
 476     CompositingMode compmode;
 477     InterpolationMode intmode;
 478     GpMatrix *m;
 479     GpRegion *region;
 480     GpUnit unit;
 481     PixelOffsetMode offsetmode;
 482     SmoothingMode smoothmode;
 483     TextRenderingHint texthint;
 484     GpPointF ptf[5];
 485     GpPoint  pt[5];
 486     GpRectF  rectf[2];
 487     GpRect   rect[2];
 488     GpRegion *clip;
 489     INT i;
 490
 491     pt[0].X = 10;
 492     pt[0].Y = 10;
 493     pt[1].X = 20;
 494     pt[1].Y = 15;
 495     pt[2].X = 40;
 496     pt[2].Y = 80;
 497     pt[3].X = -20;
 498     pt[3].Y = 20;
 499     pt[4].X = 50;
 500     pt[4].Y = 110;
 501
 502     for(i = 0; i < 5;i++){
 503         ptf[i].X = (REAL)pt[i].X;
 504         ptf[i].Y = (REAL)pt[i].Y;
 505     }
 506
 507     rect[0].X = 0;
 508     rect[0].Y = 0;
 509     rect[0].Width  = 50;
 510     rect[0].Height = 70;
 511     rect[1].X = 0;
 512     rect[1].Y = 0;
 513     rect[1].Width  = 10;
 514     rect[1].Height = 20;
 515
 516     for(i = 0; i < 2;i++){
 517         rectf[i].X = (REAL)rect[i].X;
 518         rectf[i].Y = (REAL)rect[i].Y;
 519         rectf[i].Height = (REAL)rect[i].Height;
 520         rectf[i].Width  = (REAL)rect[i].Width;
 521     }
 522
 523     GdipCreateMatrix(&m);
 524     GdipCreateRegion(&region);
 525     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
 526     GdipCreatePath(FillModeAlternate, &path);
 527     GdipCreateRegion(&clip);
 528
 529     status = GdipCreateFromHDC(hdc, &graphics);
 530     expect(Ok, status);
 531     ok(graphics != NULL, "Expected graphics to be initialized\n");
 532     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 533     expect(Ok, status);
 534
 535     /* NULL arguments */
 536     status = GdipGetDC(NULL, NULL);
 537     expect(InvalidParameter, status);
 538     status = GdipGetDC(graphics, NULL);
 539     expect(InvalidParameter, status);
 540     status = GdipGetDC(NULL, &retdc);
 541     expect(InvalidParameter, status);
 542
 543     status = GdipReleaseDC(NULL, NULL);
 544     expect(InvalidParameter, status);
 545     status = GdipReleaseDC(graphics, NULL);
 546     expect(InvalidParameter, status);
 547     status = GdipReleaseDC(NULL, (HDC)0xdeadbeef);
 548     expect(InvalidParameter, status);
 549
 550     /* Release without Get */
 551     status = GdipReleaseDC(graphics, hdc);
 552     expect(InvalidParameter, status);
 553
 554     retdc = NULL;
 555     status = GdipGetDC(graphics, &retdc);
 556     expect(Ok, status);
 557     ok(retdc == hdc, "Invalid HDC returned\n");
 558     /* call it once more */
 559     status = GdipGetDC(graphics, &retdc);
 560     expect(ObjectBusy, status);
 561
 562     /* try all Graphics calls here */
 563     status = Ok;
 564     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 565     expect(ObjectBusy, status); status = Ok;
 566     status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0.0, 0.0);
 567     expect(ObjectBusy, status); status = Ok;
 568     status = GdipDrawBezier(graphics, pen, 0.0, 10.0, 20.0, 15.0, 35.0, -10.0, 10.0, 10.0);
 569     expect(ObjectBusy, status); status = Ok;
 570     status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
 571     expect(ObjectBusy, status); status = Ok;
 572     status = GdipDrawBeziers(graphics, pen, ptf, 5);
 573     expect(ObjectBusy, status); status = Ok;
 574     status = GdipDrawBeziersI(graphics, pen, pt, 5);
 575     expect(ObjectBusy, status); status = Ok;
 576     status = GdipDrawClosedCurve(graphics, pen, ptf, 5);
 577     expect(ObjectBusy, status); status = Ok;
 578     status = GdipDrawClosedCurveI(graphics, pen, pt, 5);
 579     expect(ObjectBusy, status); status = Ok;
 580     status = GdipDrawClosedCurve2(graphics, pen, ptf, 5, 1.0);
 581     expect(ObjectBusy, status); status = Ok;
 582     status = GdipDrawClosedCurve2I(graphics, pen, pt, 5, 1.0);
 583     expect(ObjectBusy, status); status = Ok;
 584     status = GdipDrawCurve(graphics, pen, ptf, 5);
 585     expect(ObjectBusy, status); status = Ok;
 586     status = GdipDrawCurveI(graphics, pen, pt, 5);
 587     expect(ObjectBusy, status); status = Ok;
 588     status = GdipDrawCurve2(graphics, pen, ptf, 5, 1.0);
 589     expect(ObjectBusy, status); status = Ok;
 590     status = GdipDrawCurve2I(graphics, pen, pt, 5, 1.0);
 591     expect(ObjectBusy, status); status = Ok;
 592     status = GdipDrawEllipse(graphics, pen, 0.0, 0.0, 100.0, 50.0);
 593     expect(ObjectBusy, status); status = Ok;
 594     status = GdipDrawEllipseI(graphics, pen, 0, 0, 100, 50);
 595     expect(ObjectBusy, status); status = Ok;
 596     /* GdipDrawImage/GdipDrawImageI */
 597     /* GdipDrawImagePointsRect/GdipDrawImagePointsRectI */
 598     /* GdipDrawImageRectRect/GdipDrawImageRectRectI */
 599     /* GdipDrawImageRect/GdipDrawImageRectI */
 600     status = GdipDrawLine(graphics, pen, 0.0, 0.0, 100.0, 200.0);
 601     expect(ObjectBusy, status); status = Ok;
 602     status = GdipDrawLineI(graphics, pen, 0, 0, 100, 200);
 603     expect(ObjectBusy, status); status = Ok;
 604     status = GdipDrawLines(graphics, pen, ptf, 5);
 605     expect(ObjectBusy, status); status = Ok;
 606     status = GdipDrawLinesI(graphics, pen, pt, 5);
 607     expect(ObjectBusy, status); status = Ok;
 608     status = GdipDrawPath(graphics, pen, path);
 609     expect(ObjectBusy, status); status = Ok;
 610     status = GdipDrawPie(graphics, pen, 0.0, 0.0, 100.0, 100.0, 0.0, 90.0);
 611     expect(ObjectBusy, status); status = Ok;
 612     status = GdipDrawPieI(graphics, pen, 0, 0, 100, 100, 0.0, 90.0);
 613     expect(ObjectBusy, status); status = Ok;
 614     status = GdipDrawRectangle(graphics, pen, 0.0, 0.0, 100.0, 300.0);
 615     expect(ObjectBusy, status); status = Ok;
 616     status = GdipDrawRectangleI(graphics, pen, 0, 0, 100, 300);
 617     expect(ObjectBusy, status); status = Ok;
 618     status = GdipDrawRectangles(graphics, pen, rectf, 2);
 619     expect(ObjectBusy, status); status = Ok;
 620     status = GdipDrawRectanglesI(graphics, pen, rect, 2);
 621     expect(ObjectBusy, status); status = Ok;
 622     /* GdipDrawString */
 623     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, ptf, 5, 1.0, FillModeAlternate);
 624     expect(ObjectBusy, status); status = Ok;
 625     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, pt, 5, 1.0, FillModeAlternate);
 626     expect(ObjectBusy, status); status = Ok;
 627     status = GdipFillEllipse(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
 628     expect(ObjectBusy, status); status = Ok;
 629     status = GdipFillEllipseI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
 630     expect(ObjectBusy, status); status = Ok;
 631     status = GdipFillPath(graphics, (GpBrush*)brush, path);
 632     expect(ObjectBusy, status); status = Ok;
 633     status = GdipFillPie(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0, 0.0, 15.0);
 634     expect(ObjectBusy, status); status = Ok;
 635     status = GdipFillPieI(graphics, (GpBrush*)brush, 0, 0, 100, 100, 0.0, 15.0);
 636     expect(ObjectBusy, status); status = Ok;
 637     status = GdipFillPolygon(graphics, (GpBrush*)brush, ptf, 5, FillModeAlternate);
 638     expect(ObjectBusy, status); status = Ok;
 639     status = GdipFillPolygonI(graphics, (GpBrush*)brush, pt, 5, FillModeAlternate);
 640     expect(ObjectBusy, status); status = Ok;
 641     status = GdipFillPolygon2(graphics, (GpBrush*)brush, ptf, 5);
 642     expect(ObjectBusy, status); status = Ok;
 643     status = GdipFillPolygon2I(graphics, (GpBrush*)brush, pt, 5);
 644     expect(ObjectBusy, status); status = Ok;
 645     status = GdipFillRectangle(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
 646     expect(ObjectBusy, status); status = Ok;
 647     status = GdipFillRectangleI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
 648     expect(ObjectBusy, status); status = Ok;
 649     status = GdipFillRectangles(graphics, (GpBrush*)brush, rectf, 2);
 650     expect(ObjectBusy, status); status = Ok;
 651     status = GdipFillRectanglesI(graphics, (GpBrush*)brush, rect, 2);
 652     expect(ObjectBusy, status); status = Ok;
 653     status = GdipFillRegion(graphics, (GpBrush*)brush, region);
 654     expect(ObjectBusy, status); status = Ok;
 655     status = GdipFlush(graphics, FlushIntentionFlush);
 656     expect(ObjectBusy, status); status = Ok;
 657     status = GdipGetCompositingMode(graphics, &compmode);
 658     expect(ObjectBusy, status); status = Ok;
 659     status = GdipGetCompositingQuality(graphics, &quality);
 660     expect(ObjectBusy, status); status = Ok;
 661     status = GdipGetInterpolationMode(graphics, &intmode);
 662     expect(ObjectBusy, status); status = Ok;
 663     status = GdipGetPageScale(graphics, &r);
 664     expect(ObjectBusy, status); status = Ok;
 665     status = GdipGetPageUnit(graphics, &unit);
 666     expect(ObjectBusy, status); status = Ok;
 667     status = GdipGetPixelOffsetMode(graphics, &offsetmode);
 668     expect(ObjectBusy, status); status = Ok;
 669     status = GdipGetSmoothingMode(graphics, &smoothmode);
 670     expect(ObjectBusy, status); status = Ok;
 671     status = GdipGetTextRenderingHint(graphics, &texthint);
 672     expect(ObjectBusy, status); status = Ok;
 673     status = GdipGetWorldTransform(graphics, m);
 674     expect(ObjectBusy, status); status = Ok;
 675     status = GdipGraphicsClear(graphics, 0xdeadbeef);
 676     expect(ObjectBusy, status); status = Ok;
 677     /* GdipMeasureCharacterRanges */
 678     /* GdipMeasureString */
 679     status = GdipResetClip(graphics);
 680     expect(ObjectBusy, status); status = Ok;
 681     status = GdipResetWorldTransform(graphics);
 682     expect(ObjectBusy, status); status = Ok;
 683     /* GdipRestoreGraphics */
 684     status = GdipRotateWorldTransform(graphics, 15.0, MatrixOrderPrepend);
 685     expect(ObjectBusy, status); status = Ok;
 686     /*  GdipSaveGraphics */
 687     status = GdipScaleWorldTransform(graphics, 1.0, 1.0, MatrixOrderPrepend);
 688     expect(ObjectBusy, status); status = Ok;
 689     status = GdipSetCompositingMode(graphics, CompositingModeSourceOver);
 690     expect(ObjectBusy, status); status = Ok;
 691     status = GdipSetCompositingQuality(graphics, CompositingQualityDefault);
 692     expect(ObjectBusy, status); status = Ok;
 693     status = GdipSetInterpolationMode(graphics, InterpolationModeDefault);
 694     expect(ObjectBusy, status); status = Ok;
 695     status = GdipSetPageScale(graphics, 1.0);
 696     expect(ObjectBusy, status); status = Ok;
 697     status = GdipSetPageUnit(graphics, UnitWorld);
 698     expect(ObjectBusy, status); status = Ok;
 699     status = GdipSetPixelOffsetMode(graphics, PixelOffsetModeDefault);
 700     expect(ObjectBusy, status); status = Ok;
 701     status = GdipSetSmoothingMode(graphics, SmoothingModeDefault);
 702     expect(ObjectBusy, status); status = Ok;
 703     status = GdipSetTextRenderingHint(graphics, TextRenderingHintSystemDefault);
 704     expect(ObjectBusy, status); status = Ok;
 705     status = GdipSetWorldTransform(graphics, m);
 706     expect(ObjectBusy, status); status = Ok;
 707     status = GdipTranslateWorldTransform(graphics, 0.0, 0.0, MatrixOrderPrepend);
 708     expect(ObjectBusy, status); status = Ok;
 709     status = GdipSetClipRect(graphics, 0.0, 0.0, 10.0, 10.0, CombineModeReplace);
 710     expect(ObjectBusy, status); status = Ok;
 711     status = GdipSetClipRectI(graphics, 0, 0, 10, 10, CombineModeReplace);
 712     expect(ObjectBusy, status); status = Ok;
 713     status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
 714     expect(ObjectBusy, status);
 715     status = GdipDrawPolygon(graphics, pen, ptf, 5);
 716     expect(ObjectBusy, status); status = Ok;
 717     status = GdipDrawPolygonI(graphics, pen, pt, 5);
 718     expect(ObjectBusy, status); status = Ok;
 719     status = GdipGetDpiX(graphics, &r);
 720     expect(ObjectBusy, status); status = Ok;
 721     status = GdipGetDpiY(graphics, &r);
 722     expect(ObjectBusy, status); status = Ok;
 723     status = GdipMultiplyWorldTransform(graphics, m, MatrixOrderPrepend);
 724     status = GdipGetClip(graphics, region);
 725     expect(ObjectBusy, status); status = Ok;
 726     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 5);
 727     expect(ObjectBusy, status); status = Ok;
 728     /* try to delete before release */
 729     status = GdipDeleteGraphics(graphics);
 730     expect(ObjectBusy, status);
 731
 732     status = GdipReleaseDC(graphics, retdc);
 733     expect(Ok, status);
 734
 735     GdipDeletePen(pen);
 736     GdipDeleteGraphics(graphics);
 737
 738     GdipDeletePath(path);
 739     GdipDeleteBrush((GpBrush*)brush);
 740     GdipDeleteRegion(region);
 741     GdipDeleteMatrix(m);
 742     GdipDeleteRegion(region);
 743
 744     ReleaseDC(0, hdc);
 745 }
 746
 747 static void test_transformpoints(void)
 748 {
 749     GpStatus status;
 750     GpGraphics *graphics = NULL;
 751     HDC hdc = GetDC(0);
 752     GpPointF ptf[5];
 753     INT i;
 754
 755     status = GdipCreateFromHDC(hdc, &graphics);
 756     expect(Ok, status);
 757
 758     for(i = 0; i < 5; i++){
 759         ptf[i].X = 200.0 + i * 50.0 * (i % 2);
 760         ptf[i].Y = 200.0 + i * 50.0 * !(i % 2);
 761     }
 762
 763     /* NULL arguments */
 764     status = GdipTransformPoints(NULL, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
 765     expect(InvalidParameter, status);
 766     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, NULL, 0);
 767     expect(InvalidParameter, status);
 768     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, 0);
 769     expect(InvalidParameter, status);
 770     status = GdipTransformPoints(graphics, CoordinateSpacePage, CoordinateSpaceWorld, ptf, -1);
 771     expect(InvalidParameter, status);
 772
 773     GdipDeleteGraphics(graphics);
 774     ReleaseDC(0, hdc);
 775 }
 776
 777 static void test_get_set_clip(void)
 778 {
 779     GpStatus status;
 780     GpGraphics *graphics = NULL;
 781     HDC hdc = GetDC(0);
 782     GpRegion *clip;
 783     GpRectF rect;
 784     BOOL res;
 785
 786     status = GdipCreateFromHDC(hdc, &graphics);
 787     expect(Ok, status);
 788
 789     rect.X = rect.Y = 0.0;
 790     rect.Height = rect.Width = 100.0;
 791
 792     status = GdipCreateRegionRect(&rect, &clip);
 793
 794     /* NULL arguments */
 795     status = GdipGetClip(NULL, NULL);
 796     expect(InvalidParameter, status);
 797     status = GdipGetClip(graphics, NULL);
 798     expect(InvalidParameter, status);
 799     status = GdipGetClip(NULL, clip);
 800     expect(InvalidParameter, status);
 801
 802     status = GdipSetClipRegion(NULL, NULL, CombineModeReplace);
 803     expect(InvalidParameter, status);
 804     status = GdipSetClipRegion(graphics, NULL, CombineModeReplace);
 805     expect(InvalidParameter, status);
 806
 807     res = FALSE;
 808     status = GdipGetClip(graphics, clip);
 809     expect(Ok, status);
 810     status = GdipIsInfiniteRegion(clip, graphics, &res);
 811     expect(Ok, status);
 812     expect(TRUE, res);
 813
 814     /* remains infinite after reset */
 815     res = FALSE;
 816     status = GdipResetClip(graphics);
 817     expect(Ok, status);
 818     status = GdipGetClip(graphics, clip);
 819     expect(Ok, status);
 820     status = GdipIsInfiniteRegion(clip, graphics, &res);
 821     expect(Ok, status);
 822     expect(TRUE, res);
 823
 824     /* set to empty and then reset to infinite */
 825     status = GdipSetEmpty(clip);
 826     expect(Ok, status);
 827     status = GdipSetClipRegion(graphics, clip, CombineModeReplace);
 828     expect(Ok, status);
 829
 830     status = GdipGetClip(graphics, clip);
 831     expect(Ok, status);
 832     res = FALSE;
 833     status = GdipIsEmptyRegion(clip, graphics, &res);
 834     expect(Ok, status);
 835     expect(TRUE, res);
 836     status = GdipResetClip(graphics);
 837     expect(Ok, status);
 838     status = GdipGetClip(graphics, clip);
 839     expect(Ok, status);
 840     res = FALSE;
 841     status = GdipIsInfiniteRegion(clip, graphics, &res);
 842     expect(Ok, status);
 843     expect(TRUE, res);
 844
 845     GdipDeleteRegion(clip);
 846
 847     GdipDeleteGraphics(graphics);
 848     ReleaseDC(0, hdc);
 849 }
 850
 851 static void test_isempty(void)
 852 {
 853     GpStatus status;
 854     GpGraphics *graphics = NULL;
 855     HDC hdc = GetDC(0);
 856     GpRegion *clip;
 857     BOOL res;
 858
 859     status = GdipCreateFromHDC(hdc, &graphics);
 860     expect(Ok, status);
 861
 862     status = GdipCreateRegion(&clip);
 863     expect(Ok, status);
 864
 865     /* NULL */
 866     status = GdipIsClipEmpty(NULL, NULL);
 867     expect(InvalidParameter, status);
 868     status = GdipIsClipEmpty(graphics, NULL);
 869     expect(InvalidParameter, status);
 870     status = GdipIsClipEmpty(NULL, &res);
 871     expect(InvalidParameter, status);
 872
 873     /* default is infinite */
 874     res = TRUE;
 875     status = GdipIsClipEmpty(graphics, &res);
 876     expect(Ok, status);
 877     expect(FALSE, res);
 878
 879     GdipDeleteRegion(clip);
 880
 881     GdipDeleteGraphics(graphics);
 882     ReleaseDC(0, hdc);
 883 }
 884
 885 static void test_clear(void)
 886 {
 887     GpStatus status;
 888
 889     status = GdipGraphicsClear(NULL, 0xdeadbeef);
 890     expect(InvalidParameter, status);
 891 }
 892
 893 START_TEST(graphics)
 894 {
 895     struct GdiplusStartupInput gdiplusStartupInput;
 896     ULONG_PTR gdiplusToken;
 897
 898     gdiplusStartupInput.GdiplusVersion              = 1;
 899     gdiplusStartupInput.DebugEventCallback          = NULL;
 900     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 901     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 902
 903     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 904
 905     test_constructor_destructor();
 906     test_save_restore();
 907     test_GdipDrawBezierI();
 908     test_GdipDrawArc();
 909     test_GdipDrawArcI();
 910     test_GdipDrawLineI();
 911     test_GdipDrawLinesI();
 912     test_Get_Release_DC();
 913     test_transformpoints();
 914     test_get_set_clip();
 915     test_isempty();
 916     test_clear();
 917
 918     GdiplusShutdown(gdiplusToken);
 919 }