dlls/gdiplus/tests/pathiterator.c

   1 /*
   2  * Unit test suite for pathiterator
   3  *
   4  * Copyright (C) 2008 Nikolay Sivov
   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 "wine/test.h"
  24
  25 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
  26
  27 static void test_constructor_destructor(void)
  28 {
  29     GpPath *path;
  30     GpPathIterator *iter;
  31     GpStatus stat;
  32
  33     GdipCreatePath(FillModeAlternate, &path);
  34     GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
  35
  36     /* NULL args */
  37     stat = GdipCreatePathIter(NULL, NULL);
  38     expect(InvalidParameter, stat);
  39     iter = NULL;
  40     stat = GdipCreatePathIter(&iter, NULL);
  41     expect(Ok, stat);
  42     ok(iter != NULL, "Expected iterator to be created\n");
  43     GdipDeletePathIter(iter);
  44     stat = GdipCreatePathIter(NULL, path);
  45     expect(InvalidParameter, stat);
  46     stat = GdipDeletePathIter(NULL);
  47     expect(InvalidParameter, stat);
  48
  49     /* valid args */
  50     stat = GdipCreatePathIter(&iter, path);
  51     expect(Ok, stat);
  52
  53     GdipDeletePathIter(iter);
  54     GdipDeletePath(path);
  55 }
  56
  57 static void test_hascurve(void)
  58 {
  59     GpPath *path;
  60     GpPathIterator *iter;
  61     GpStatus stat;
  62     BOOL hasCurve;
  63
  64     GdipCreatePath(FillModeAlternate, &path);
  65     GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
  66
  67     stat = GdipCreatePathIter(&iter, path);
  68     expect(Ok, stat);
  69
  70     /* NULL args
  71        BOOL out argument is local in wrapper class method,
  72        so it always has not-NULL address */
  73     stat = GdipPathIterHasCurve(NULL, &hasCurve);
  74     expect(InvalidParameter, stat);
  75
  76     /* valid args */
  77     stat = GdipPathIterHasCurve(iter, &hasCurve);
  78     expect(Ok, stat);
  79     expect(FALSE, hasCurve);
  80
  81     GdipDeletePathIter(iter);
  82
  83     GdipAddPathEllipse(path, 0.0, 0.0, 35.0, 70.0);
  84
  85     stat = GdipCreatePathIter(&iter, path);
  86     expect(Ok, stat);
  87
  88     stat = GdipPathIterHasCurve(iter, &hasCurve);
  89     expect(Ok, stat);
  90     expect(TRUE, hasCurve);
  91
  92     GdipDeletePathIter(iter);
  93     GdipDeletePath(path);
  94 }
  95
  96 static void test_nextmarker(void)
  97 {
  98     GpPath *path;
  99     GpPathIterator *iter;
 100     GpStatus stat;
 101     INT start, end;
 102     INT result;
 103
 104     /* NULL args
 105        BOOL out argument is local in wrapper class method,
 106        so it always has not-NULL address */
 107     stat = GdipPathIterNextMarker(NULL, &result, NULL, NULL);
 108     expect(InvalidParameter, stat);
 109     stat = GdipPathIterNextMarker(NULL, &result, &start, NULL);
 110     expect(InvalidParameter, stat);
 111     stat = GdipPathIterNextMarker(NULL, &result, NULL, &end);
 112     expect(InvalidParameter, stat);
 113
 114     GdipCreatePath(FillModeAlternate, &path);
 115     GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
 116
 117     /* no markers */
 118     GdipCreatePathIter(&iter, path);
 119     start = end = result = (INT)0xdeadbeef;
 120     stat = GdipPathIterNextMarker(iter, &result, &start, &end);
 121     expect(Ok, stat);
 122     expect(0, start);
 123     expect(3, end);
 124     expect(4, result);
 125     start = end = result = (INT)0xdeadbeef;
 126     stat = GdipPathIterNextMarker(iter, &result, &start, &end);
 127     /* start/end remain unchanged */
 128     expect((INT)0xdeadbeef, start);
 129     expect((INT)0xdeadbeef, end);
 130     expect(0, result);
 131     GdipDeletePathIter(iter);
 132
 133     /* one marker */
 134     GdipSetPathMarker(path);
 135     GdipCreatePathIter(&iter, path);
 136     start = end = result = (INT)0xdeadbeef;
 137     stat = GdipPathIterNextMarker(iter, &result, &start, &end);
 138     expect(Ok, stat);
 139     expect(0, start);
 140     expect(3, end);
 141     expect(4, result);
 142     start = end = result = (INT)0xdeadbeef;
 143     stat = GdipPathIterNextMarker(iter, &result, &start, &end);
 144     expect(Ok, stat);
 145     expect((INT)0xdeadbeef, start);
 146     expect((INT)0xdeadbeef, end);
 147     expect(0, result);
 148     GdipDeletePathIter(iter);
 149
 150     /* two markers */
 151     GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
 152     GdipSetPathMarker(path);
 153     GdipCreatePathIter(&iter, path);
 154     start = end = result = (INT)0xdeadbeef;
 155     stat = GdipPathIterNextMarker(iter, &result, &start, &end);
 156     expect(Ok, stat);
 157     expect(0, start);
 158     expect(3, end);
 159     expect(4, result);
 160     start = end = result = (INT)0xdeadbeef;
 161     stat = GdipPathIterNextMarker(iter, &result, &start, &end);
 162     expect(Ok, stat);
 163     expect(4, start);
 164     expect(5, end);
 165     expect(2, result);
 166     start = end = result = (INT)0xdeadbeef;
 167     stat = GdipPathIterNextMarker(iter, &result, &start, &end);
 168     expect(Ok, stat);
 169     expect((INT)0xdeadbeef, start);
 170     expect((INT)0xdeadbeef, end);
 171     expect(0, result);
 172     GdipDeletePathIter(iter);
 173
 174     GdipDeletePath(path);
 175 }
 176
 177 static void test_nextmarkerpath(void)
 178 {
 179     GpPath *path, *retpath;
 180     GpPathIterator *iter;
 181     GpStatus stat;
 182     INT result, count;
 183
 184     GdipCreatePath(FillModeAlternate, &path);
 185
 186     /* NULL */
 187     stat = GdipPathIterNextMarkerPath(NULL, NULL, NULL);
 188     expect(InvalidParameter, stat);
 189     stat = GdipPathIterNextMarkerPath(NULL, &result, NULL);
 190     expect(InvalidParameter, stat);
 191     stat = GdipPathIterNextMarkerPath(NULL, &result, path);
 192     expect(InvalidParameter, stat);
 193
 194     GdipAddPathRectangle(path, 5.0, 5.0, 100.0, 50.0);
 195
 196     /* no markers */
 197     GdipCreatePath(FillModeAlternate, &retpath);
 198     GdipCreatePathIter(&iter, path);
 199     result = -1;
 200     stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
 201     expect(Ok, stat);
 202     expect(4, result);
 203     count = -1;
 204     GdipGetPointCount(retpath, &count);
 205     expect(4, count);
 206     result = -1;
 207     stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
 208     expect(Ok, stat);
 209     expect(0, result);
 210     count = -1;
 211     GdipGetPointCount(retpath, &count);
 212     expect(4, count);
 213     GdipDeletePathIter(iter);
 214     GdipDeletePath(retpath);
 215
 216     /* one marker */
 217     GdipSetPathMarker(path);
 218     GdipCreatePath(FillModeAlternate, &retpath);
 219     GdipCreatePathIter(&iter, path);
 220     result = -1;
 221     stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
 222     expect(Ok, stat);
 223     expect(4, result);
 224     count = -1;
 225     GdipGetPointCount(retpath, &count);
 226     expect(4, count);
 227     result = -1;
 228     stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
 229     expect(Ok, stat);
 230     expect(0, result);
 231     count = -1;
 232     GdipGetPointCount(retpath, &count);
 233     expect(4, count);
 234     GdipDeletePathIter(iter);
 235     GdipDeletePath(retpath);
 236
 237     /* two markers */
 238     GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
 239     GdipSetPathMarker(path);
 240     GdipCreatePath(FillModeAlternate, &retpath);
 241     GdipCreatePathIter(&iter, path);
 242     result = -1;
 243     stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
 244     expect(Ok, stat);
 245     expect(4, result);
 246     result = -1;
 247     stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
 248     expect(Ok, stat);
 249     expect(2, result);
 250     result = -1;
 251     stat = GdipPathIterNextMarkerPath(iter, &result, retpath);
 252     expect(Ok, stat);
 253     expect(0, result);
 254     GdipDeletePathIter(iter);
 255     GdipDeletePath(retpath);
 256
 257     GdipDeletePath(path);
 258 }
 259
 260 static void test_getsubpathcount(void)
 261 {
 262     GpPath *path;
 263     GpPathIterator *iter;
 264     GpStatus stat;
 265     INT count;
 266
 267     /* NULL args */
 268     stat = GdipPathIterGetSubpathCount(NULL, NULL);
 269     expect(InvalidParameter, stat);
 270     stat = GdipPathIterGetSubpathCount(NULL, &count);
 271     expect(InvalidParameter, stat);
 272
 273     GdipCreatePath(FillModeAlternate, &path);
 274
 275     /* empty path */
 276     GdipCreatePathIter(&iter, path);
 277     stat = GdipPathIterGetSubpathCount(iter, &count);
 278     expect(Ok, stat);
 279     expect(0, count);
 280     GdipDeletePathIter(iter);
 281
 282     GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
 283
 284     /* open figure */
 285     GdipCreatePathIter(&iter, path);
 286     stat = GdipPathIterGetSubpathCount(iter, &count);
 287     expect(Ok, stat);
 288     expect(1, count);
 289     GdipDeletePathIter(iter);
 290
 291     /* manually start new figure */
 292     GdipStartPathFigure(path);
 293     GdipAddPathLine(path, 50.0, 50.0, 110.0, 40.0);
 294     GdipCreatePathIter(&iter, path);
 295     stat = GdipPathIterGetSubpathCount(iter, &count);
 296     expect(Ok, stat);
 297     expect(2, count);
 298     GdipDeletePathIter(iter);
 299
 300     GdipDeletePath(path);
 301 }
 302
 303 static void test_isvalid(void)
 304 {
 305     GpPath *path;
 306     GpPathIterator *iter;
 307     GpStatus stat;
 308     BOOL isvalid;
 309     INT start, end, result;
 310
 311     GdipCreatePath(FillModeAlternate, &path);
 312
 313     /* NULL args */
 314     GdipCreatePathIter(&iter, path);
 315     stat = GdipPathIterIsValid(NULL, NULL);
 316     expect(InvalidParameter, stat);
 317     stat = GdipPathIterIsValid(iter, NULL);
 318     expect(InvalidParameter, stat);
 319     stat = GdipPathIterIsValid(NULL, &isvalid);
 320     expect(InvalidParameter, stat);
 321     GdipDeletePathIter(iter);
 322
 323     /* on empty path */
 324     GdipCreatePathIter(&iter, path);
 325     isvalid = FALSE;
 326     stat = GdipPathIterIsValid(iter, &isvalid);
 327     expect(Ok, stat);
 328     expect(TRUE, isvalid);
 329     GdipDeletePathIter(iter);
 330
 331     /* no markers */
 332     GdipAddPathLine(path, 50.0, 50.0, 110.0, 40.0);
 333     GdipCreatePathIter(&iter, path);
 334     GdipPathIterNextMarker(iter, &result, &start, &end);
 335     isvalid = FALSE;
 336     stat = GdipPathIterIsValid(iter, &isvalid);
 337     expect(Ok, stat);
 338     expect(TRUE, isvalid);
 339     GdipDeletePathIter(iter);
 340
 341     GdipDeletePath(path);
 342 }
 343
 344 static void test_nextsubpathpath(void)
 345 {
 346     GpPath *path, *retpath;
 347     GpPathIterator *iter;
 348     GpStatus stat;
 349     BOOL closed;
 350     INT count, result;
 351
 352     GdipCreatePath(FillModeAlternate, &path);
 353
 354     /* NULL args */
 355     GdipCreatePath(FillModeAlternate, &retpath);
 356     GdipCreatePathIter(&iter, path);
 357     stat = GdipPathIterNextSubpathPath(NULL, NULL, NULL, NULL);
 358     expect(InvalidParameter, stat);
 359     stat = GdipPathIterNextSubpathPath(iter, NULL, NULL, NULL);
 360     expect(InvalidParameter, stat);
 361     stat = GdipPathIterNextSubpathPath(NULL, &result, NULL, NULL);
 362     expect(InvalidParameter, stat);
 363     stat = GdipPathIterNextSubpathPath(iter, &result, NULL, &closed);
 364     expect(Ok, stat);
 365     stat = GdipPathIterNextSubpathPath(iter, NULL, NULL, &closed);
 366     expect(InvalidParameter, stat);
 367     stat = GdipPathIterNextSubpathPath(iter, NULL, retpath, NULL);
 368     expect(InvalidParameter, stat);
 369     stat = GdipPathIterNextSubpathPath(iter, &result, retpath, NULL);
 370     expect(InvalidParameter, stat);
 371     GdipDeletePathIter(iter);
 372     GdipDeletePath(retpath);
 373
 374     /* empty path */
 375     GdipCreatePath(FillModeAlternate, &retpath);
 376     GdipCreatePathIter(&iter, path);
 377     result = -2;
 378     closed = TRUE;
 379     stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
 380     expect(Ok, stat);
 381     expect(0, result);
 382     expect(TRUE, closed);
 383     count = -1;
 384     GdipGetPointCount(retpath, &count);
 385     expect(0, count);
 386     GdipDeletePathIter(iter);
 387     GdipDeletePath(retpath);
 388
 389     /* open figure */
 390     GdipAddPathLine(path, 5.0, 5.0, 100.0, 50.0);
 391
 392     GdipCreatePath(FillModeAlternate, &retpath);
 393     GdipCreatePathIter(&iter, path);
 394     result = -2;
 395     closed = TRUE;
 396     stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
 397     expect(Ok, stat);
 398     expect(2, result);
 399     expect(FALSE, closed);
 400     count = -1;
 401     GdipGetPointCount(retpath, &count);
 402     expect(2, count);
 403     /* subsequent call */
 404     result = -2;
 405     closed = TRUE;
 406     stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
 407     expect(Ok, stat);
 408     expect(0, result);
 409     expect(TRUE, closed);
 410     count = -1;
 411     GdipGetPointCount(retpath, &count);
 412     expect(2, count);
 413     GdipDeletePathIter(iter);
 414
 415     /* closed figure, check does it extend retpath or reset it */
 416     GdipAddPathLine(retpath, 50.0, 55.0, 200.0, 150.0);
 417
 418     GdipClosePathFigure(path);
 419     GdipAddPathLine(path, 50.0, 55.0, 200.0, 150.0);
 420     GdipClosePathFigure(path);
 421
 422     GdipCreatePathIter(&iter, path);
 423     result = -2;
 424     closed = FALSE;
 425     stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
 426     expect(Ok, stat);
 427     expect(2, result);
 428     expect(TRUE, closed);
 429     count = -1;
 430     GdipGetPointCount(retpath, &count);
 431     expect(2, count);
 432     /* subsequent call */
 433     result = -2;
 434     closed = FALSE;
 435     stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
 436     expect(Ok, stat);
 437     expect(2, result);
 438     expect(TRUE, closed);
 439     count = -1;
 440     GdipGetPointCount(retpath, &count);
 441     expect(2, count);
 442     result = -2;
 443     closed = FALSE;
 444     stat = GdipPathIterNextSubpathPath(iter, &result, retpath, &closed);
 445     expect(Ok, stat);
 446     expect(0, result);
 447     expect(TRUE, closed);
 448     count = -1;
 449     GdipGetPointCount(retpath, &count);
 450     expect(2, count);
 451     GdipDeletePathIter(iter);
 452
 453     GdipDeletePath(retpath);
 454     GdipDeletePath(path);
 455 }
 456
 457 static void test_nextsubpath(void)
 458 {
 459     GpPath *path;
 460     GpPathIterator *iter;
 461     GpStatus stat;
 462     INT start, end, result;
 463     BOOL closed;
 464
 465     /* empty path */
 466     GdipCreatePath(FillModeAlternate, &path);
 467     GdipCreatePathIter(&iter, path);
 468
 469     result = -2;
 470     closed = TRUE;
 471     stat = GdipPathIterNextSubpath(iter, &result, &start, &end, &closed);
 472     expect(Ok, stat);
 473     expect(0, result);
 474     expect(TRUE, closed);
 475
 476     GdipDeletePathIter(iter);
 477     GdipDeletePath(path);
 478 }
 479
 480 static void test_nextpathtype(void)
 481 {
 482     GpPath *path;
 483     GpPathIterator *iter;
 484     GpStatus stat;
 485     INT start, end, result;
 486     BYTE type;
 487
 488     GdipCreatePath(FillModeAlternate, &path);
 489     GdipCreatePathIter(&iter, path);
 490
 491     /* NULL arguments */
 492     stat = GdipPathIterNextPathType(NULL, NULL, NULL, NULL, NULL);
 493     expect(InvalidParameter, stat);
 494     stat = GdipPathIterNextPathType(iter, NULL, NULL, NULL, NULL);
 495     expect(InvalidParameter, stat);
 496     stat = GdipPathIterNextPathType(iter, &result, NULL, NULL, NULL);
 497     expect(InvalidParameter, stat);
 498     stat = GdipPathIterNextPathType(iter, NULL, &type, NULL, NULL);
 499     expect(InvalidParameter, stat);
 500     stat = GdipPathIterNextPathType(iter, NULL, NULL, &start, &end);
 501     expect(InvalidParameter, stat);
 502     stat = GdipPathIterNextPathType(iter, NULL, &type, &start, &end);
 503     expect(InvalidParameter, stat);
 504     stat = GdipPathIterNextPathType(iter, &result, &type, NULL, NULL);
 505     expect(InvalidParameter, stat);
 506
 507     /* empty path */
 508     start = end = result = (INT)0xdeadbeef;
 509     stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
 510     todo_wine expect(Ok, stat);
 511     expect((INT)0xdeadbeef, start);
 512     expect((INT)0xdeadbeef, end);
 513     todo_wine expect(0, result);
 514     GdipDeletePathIter(iter);
 515
 516     /* single figure */
 517     GdipAddPathLine(path, 0.0, 0.0, 10.0, 30.0);
 518     GdipCreatePathIter(&iter, path);
 519     start = end = result = (INT)0xdeadbeef;
 520     type = 255; /* out of range */
 521     stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
 522     todo_wine expect(Ok, stat);
 523     expect((INT)0xdeadbeef, start);
 524     expect((INT)0xdeadbeef, end);
 525     expect(255, type);
 526     todo_wine expect(0, result);
 527     GdipDeletePathIter(iter);
 528
 529     GdipAddPathEllipse(path, 0.0, 0.0, 35.0, 70.0);
 530     GdipCreatePathIter(&iter, path);
 531     start = end = result = (INT)0xdeadbeef;
 532     type = 255; /* out of range */
 533     stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
 534     todo_wine expect(Ok, stat);
 535     expect((INT)0xdeadbeef, start);
 536     expect((INT)0xdeadbeef, end);
 537     expect(255, type);
 538     todo_wine expect(0, result);
 539     GdipDeletePathIter(iter);
 540
 541     /* closed */
 542     GdipClosePathFigure(path);
 543     GdipCreatePathIter(&iter, path);
 544     start = end = result = (INT)0xdeadbeef;
 545     type = 255; /* out of range */
 546     stat = GdipPathIterNextPathType(iter, &result, &type, &start, &end);
 547     todo_wine expect(Ok, stat);
 548     expect((INT)0xdeadbeef, start);
 549     expect((INT)0xdeadbeef, end);
 550     expect(255, type);
 551     todo_wine expect(0, result);
 552     GdipDeletePathIter(iter);
 553
 554     GdipDeletePath(path);
 555 }
 556
 557 START_TEST(pathiterator)
 558 {
 559     struct GdiplusStartupInput gdiplusStartupInput;
 560     ULONG_PTR gdiplusToken;
 561
 562     gdiplusStartupInput.GdiplusVersion              = 1;
 563     gdiplusStartupInput.DebugEventCallback          = NULL;
 564     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 565     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 566
 567     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 568
 569     test_constructor_destructor();
 570     test_hascurve();
 571     test_nextmarker();
 572     test_nextmarkerpath();
 573     test_getsubpathcount();
 574     test_isvalid();
 575     test_nextsubpathpath();
 576     test_nextsubpath();
 577     test_nextpathtype();
 578
 579     GdiplusShutdown(gdiplusToken);
 580 }