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     INT i;
 489
 490     pt[0].X = 10;
 491     pt[0].Y = 10;
 492     pt[1].X = 20;
 493     pt[1].Y = 15;
 494     pt[2].X = 40;
 495     pt[2].Y = 80;
 496     pt[3].X = -20;
 497     pt[3].Y = 20;
 498     pt[4].X = 50;
 499     pt[4].Y = 110;
 500
 501     for(i = 0; i < 5;i++){
 502         ptf[i].X = (REAL)pt[i].X;
 503         ptf[i].Y = (REAL)pt[i].Y;
 504     }
 505
 506     rect[0].X = 0;
 507     rect[0].Y = 0;
 508     rect[0].Width  = 50;
 509     rect[0].Height = 70;
 510     rect[1].X = 0;
 511     rect[1].Y = 0;
 512     rect[1].Width  = 10;
 513     rect[1].Height = 20;
 514
 515     for(i = 0; i < 2;i++){
 516         rectf[i].X = (REAL)rect[i].X;
 517         rectf[i].Y = (REAL)rect[i].Y;
 518         rectf[i].Height = (REAL)rect[i].Height;
 519         rectf[i].Width  = (REAL)rect[i].Width;
 520     }
 521
 522     GdipCreateMatrix(&m);
 523     GdipCreateRegion(&region);
 524     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
 525     GdipCreatePath(FillModeAlternate, &path);
 526
 527     status = GdipCreateFromHDC(hdc, &graphics);
 528     expect(Ok, status);
 529     ok(graphics != NULL, "Expected graphics to be initialized\n");
 530     status = GdipCreatePen1((ARGB)0xffff00ff, 10.0f, UnitPixel, &pen);
 531     expect(Ok, status);
 532
 533     /* NULL arguments */
 534     status = GdipGetDC(NULL, NULL);
 535     expect(InvalidParameter, status);
 536     status = GdipGetDC(graphics, NULL);
 537     expect(InvalidParameter, status);
 538     status = GdipGetDC(NULL, &retdc);
 539     expect(InvalidParameter, status);
 540
 541     status = GdipReleaseDC(NULL, (HDC)0);
 542     expect(InvalidParameter, status);
 543     status = GdipReleaseDC(graphics, (HDC)0);
 544     expect(InvalidParameter, status);
 545     status = GdipReleaseDC(NULL, (HDC)0xdeadbeef);
 546     expect(InvalidParameter, status);
 547
 548     /* Release without Get */
 549     status = GdipReleaseDC(graphics, hdc);
 550     expect(InvalidParameter, status);
 551
 552     retdc = NULL;
 553     status = GdipGetDC(graphics, &retdc);
 554     expect(Ok, status);
 555     ok(retdc == hdc, "Invalid HDC returned\n");
 556     /* call it once more */
 557     status = GdipGetDC(graphics, &retdc);
 558     expect(ObjectBusy, status);
 559
 560     /* try all Graphics calls here */
 561     status = Ok;
 562     status = GdipDrawArc(graphics, pen, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0);
 563     expect(ObjectBusy, status); status = Ok;
 564     status = GdipDrawArcI(graphics, pen, 0, 0, 1, 1, 0.0, 0.0);
 565     expect(ObjectBusy, status); status = Ok;
 566     status = GdipDrawBezier(graphics, pen, 0.0, 10.0, 20.0, 15.0, 35.0, -10.0, 10.0, 10.0);
 567     expect(ObjectBusy, status); status = Ok;
 568     status = GdipDrawBezierI(graphics, pen, 0, 0, 0, 0, 0, 0, 0, 0);
 569     expect(ObjectBusy, status); status = Ok;
 570     status = GdipDrawBeziers(graphics, pen, ptf, 5);
 571     expect(ObjectBusy, status); status = Ok;
 572     status = GdipDrawBeziersI(graphics, pen, pt, 5);
 573     expect(ObjectBusy, status); status = Ok;
 574     status = GdipDrawClosedCurve(graphics, pen, ptf, 5);
 575     expect(ObjectBusy, status); status = Ok;
 576     status = GdipDrawClosedCurveI(graphics, pen, pt, 5);
 577     expect(ObjectBusy, status); status = Ok;
 578     status = GdipDrawClosedCurve2(graphics, pen, ptf, 5, 1.0);
 579     expect(ObjectBusy, status); status = Ok;
 580     status = GdipDrawClosedCurve2I(graphics, pen, pt, 5, 1.0);
 581     expect(ObjectBusy, status); status = Ok;
 582     status = GdipDrawCurve(graphics, pen, ptf, 5);
 583     expect(ObjectBusy, status); status = Ok;
 584     status = GdipDrawCurveI(graphics, pen, pt, 5);
 585     expect(ObjectBusy, status); status = Ok;
 586     status = GdipDrawCurve2(graphics, pen, ptf, 5, 1.0);
 587     expect(ObjectBusy, status); status = Ok;
 588     status = GdipDrawCurve2I(graphics, pen, pt, 5, 1.0);
 589     expect(ObjectBusy, status); status = Ok;
 590     status = GdipDrawEllipse(graphics, pen, 0.0, 0.0, 100.0, 50.0);
 591     expect(ObjectBusy, status); status = Ok;
 592     status = GdipDrawEllipseI(graphics, pen, 0, 0, 100, 50);
 593     expect(ObjectBusy, status); status = Ok;
 594     /* GdipDrawImage/GdipDrawImageI */
 595     /* GdipDrawImagePointsRect/GdipDrawImagePointsRectI */
 596     /* GdipDrawImageRectRect/GdipDrawImageRectRectI */
 597     /* GdipDrawImageRect/GdipDrawImageRectI */
 598     status = GdipDrawLine(graphics, pen, 0.0, 0.0, 100.0, 200.0);
 599     expect(ObjectBusy, status); status = Ok;
 600     status = GdipDrawLineI(graphics, pen, 0, 0, 100, 200);
 601     expect(ObjectBusy, status); status = Ok;
 602     status = GdipDrawLines(graphics, pen, ptf, 5);
 603     expect(ObjectBusy, status); status = Ok;
 604     status = GdipDrawLinesI(graphics, pen, pt, 5);
 605     expect(ObjectBusy, status); status = Ok;
 606     status = GdipDrawPath(graphics, pen, path);
 607     expect(ObjectBusy, status); status = Ok;
 608     status = GdipDrawPie(graphics, pen, 0.0, 0.0, 100.0, 100.0, 0.0, 90.0);
 609     expect(ObjectBusy, status); status = Ok;
 610     status = GdipDrawPieI(graphics, pen, 0, 0, 100, 100, 0.0, 90.0);
 611     expect(ObjectBusy, status); status = Ok;
 612     status = GdipDrawRectangle(graphics, pen, 0.0, 0.0, 100.0, 300.0);
 613     expect(ObjectBusy, status); status = Ok;
 614     status = GdipDrawRectangleI(graphics, pen, 0, 0, 100, 300);
 615     expect(ObjectBusy, status); status = Ok;
 616     status = GdipDrawRectangles(graphics, pen, rectf, 2);
 617     expect(ObjectBusy, status); status = Ok;
 618     status = GdipDrawRectanglesI(graphics, pen, rect, 2);
 619     expect(ObjectBusy, status); status = Ok;
 620     /* GdipDrawString */
 621     status = GdipFillClosedCurve2(graphics, (GpBrush*)brush, ptf, 5, 1.0, FillModeAlternate);
 622     expect(ObjectBusy, status); status = Ok;
 623     status = GdipFillClosedCurve2I(graphics, (GpBrush*)brush, pt, 5, 1.0, FillModeAlternate);
 624     expect(ObjectBusy, status); status = Ok;
 625     status = GdipFillEllipse(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
 626     expect(ObjectBusy, status); status = Ok;
 627     status = GdipFillEllipseI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
 628     expect(ObjectBusy, status); status = Ok;
 629     status = GdipFillPath(graphics, (GpBrush*)brush, path);
 630     expect(ObjectBusy, status); status = Ok;
 631     status = GdipFillPie(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0, 0.0, 15.0);
 632     expect(ObjectBusy, status); status = Ok;
 633     status = GdipFillPieI(graphics, (GpBrush*)brush, 0, 0, 100, 100, 0.0, 15.0);
 634     expect(ObjectBusy, status); status = Ok;
 635     status = GdipFillPolygon(graphics, (GpBrush*)brush, ptf, 5, FillModeAlternate);
 636     expect(ObjectBusy, status); status = Ok;
 637     status = GdipFillPolygonI(graphics, (GpBrush*)brush, pt, 5, FillModeAlternate);
 638     expect(ObjectBusy, status); status = Ok;
 639     status = GdipFillPolygon2(graphics, (GpBrush*)brush, ptf, 5);
 640     expect(ObjectBusy, status); status = Ok;
 641     status = GdipFillPolygon2I(graphics, (GpBrush*)brush, pt, 5);
 642     expect(ObjectBusy, status); status = Ok;
 643     status = GdipFillRectangle(graphics, (GpBrush*)brush, 0.0, 0.0, 100.0, 100.0);
 644     expect(ObjectBusy, status); status = Ok;
 645     status = GdipFillRectangleI(graphics, (GpBrush*)brush, 0, 0, 100, 100);
 646     expect(ObjectBusy, status); status = Ok;
 647     status = GdipFillRectangles(graphics, (GpBrush*)brush, rectf, 2);
 648     expect(ObjectBusy, status); status = Ok;
 649     status = GdipFillRectanglesI(graphics, (GpBrush*)brush, rect, 2);
 650     expect(ObjectBusy, status); status = Ok;
 651     status = GdipFillRegion(graphics, (GpBrush*)brush, region);
 652     expect(ObjectBusy, status); status = Ok;
 653     status = GdipFlush(graphics, FlushIntentionFlush);
 654     expect(ObjectBusy, status); status = Ok;
 655     status = GdipGetCompositingMode(graphics, &compmode);
 656     expect(ObjectBusy, status); status = Ok;
 657     status = GdipGetCompositingQuality(graphics, &quality);
 658     expect(ObjectBusy, status); status = Ok;
 659     status = GdipGetInterpolationMode(graphics, &intmode);
 660     expect(ObjectBusy, status); status = Ok;
 661     status = GdipGetPageScale(graphics, &r);
 662     expect(ObjectBusy, status); status = Ok;
 663     status = GdipGetPageUnit(graphics, &unit);
 664     expect(ObjectBusy, status); status = Ok;
 665     status = GdipGetPixelOffsetMode(graphics, &offsetmode);
 666     expect(ObjectBusy, status); status = Ok;
 667     status = GdipGetSmoothingMode(graphics, &smoothmode);
 668     expect(ObjectBusy, status); status = Ok;
 669     status = GdipGetTextRenderingHint(graphics, &texthint);
 670     expect(ObjectBusy, status); status = Ok;
 671     status = GdipGetWorldTransform(graphics, m);
 672     expect(ObjectBusy, status); status = Ok;
 673     /* GdipMeasureCharacterRanges */
 674     /* GdipMeasureString */
 675     status = GdipResetWorldTransform(graphics);
 676     expect(ObjectBusy, status); status = Ok;
 677     /* GdipRestoreGraphics */
 678     status = GdipRotateWorldTransform(graphics, 15.0, MatrixOrderPrepend);
 679     expect(ObjectBusy, status); status = Ok;
 680     /*  GdipSaveGraphics */
 681     status = GdipScaleWorldTransform(graphics, 1.0, 1.0, MatrixOrderPrepend);
 682     expect(ObjectBusy, status); status = Ok;
 683     status = GdipSetCompositingMode(graphics, CompositingModeSourceOver);
 684     expect(ObjectBusy, status); status = Ok;
 685     status = GdipSetCompositingQuality(graphics, CompositingQualityDefault);
 686     expect(ObjectBusy, status); status = Ok;
 687     status = GdipSetInterpolationMode(graphics, InterpolationModeDefault);
 688     expect(ObjectBusy, status); status = Ok;
 689     status = GdipSetPageScale(graphics, 1.0);
 690     expect(ObjectBusy, status); status = Ok;
 691     status = GdipSetPageUnit(graphics, UnitWorld);
 692     expect(ObjectBusy, status); status = Ok;
 693     status = GdipSetPixelOffsetMode(graphics, PixelOffsetModeDefault);
 694     expect(ObjectBusy, status); status = Ok;
 695     status = GdipSetSmoothingMode(graphics, SmoothingModeDefault);
 696     expect(ObjectBusy, status); status = Ok;
 697     status = GdipSetTextRenderingHint(graphics, TextRenderingHintSystemDefault);
 698     expect(ObjectBusy, status); status = Ok;
 699     status = GdipSetWorldTransform(graphics, m);
 700     expect(ObjectBusy, status); status = Ok;
 701     status = GdipTranslateWorldTransform(graphics, 0.0, 0.0, MatrixOrderPrepend);
 702     expect(ObjectBusy, status); status = Ok;
 703     status = GdipSetClipRectI(graphics, 0, 0, 10, 10, CombineModeReplace);
 704     expect(ObjectBusy, status); status = Ok;
 705     /* GdipSetClipRegion */
 706     status = GdipDrawPolygon(graphics, pen, ptf, 5);
 707     expect(ObjectBusy, status); status = Ok;
 708     status = GdipDrawPolygonI(graphics, pen, pt, 5);
 709     expect(ObjectBusy, status); status = Ok;
 710     status = GdipGetDpiX(graphics, &r);
 711     expect(ObjectBusy, status); status = Ok;
 712     status = GdipGetDpiY(graphics, &r);
 713     expect(ObjectBusy, status); status = Ok;
 714     status = GdipMultiplyWorldTransform(graphics, m, MatrixOrderPrepend);
 715     status = GdipGetClip(graphics, region);
 716     expect(ObjectBusy, status); status = Ok;
 717
 718     status = GdipReleaseDC(graphics, retdc);
 719     expect(Ok, status);
 720
 721     GdipDeletePen(pen);
 722     GdipDeleteGraphics(graphics);
 723
 724     GdipDeletePath(path);
 725     GdipDeleteBrush((GpBrush*)brush);
 726     GdipDeleteRegion(region);
 727     GdipDeleteMatrix(m);
 728
 729     ReleaseDC(0, hdc);
 730 }
 731
 732 START_TEST(graphics)
 733 {
 734     struct GdiplusStartupInput gdiplusStartupInput;
 735     ULONG_PTR gdiplusToken;
 736
 737     gdiplusStartupInput.GdiplusVersion              = 1;
 738     gdiplusStartupInput.DebugEventCallback          = NULL;
 739     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 740     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 741
 742     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 743
 744     test_constructor_destructor();
 745     test_save_restore();
 746     test_GdipDrawBezierI();
 747     test_GdipDrawArc();
 748     test_GdipDrawArcI();
 749     test_GdipDrawLineI();
 750     test_GdipDrawLinesI();
 751     test_Get_Release_DC();
 752
 753     GdiplusShutdown(gdiplusToken);
 754 }