dlls/gdiplus/tests/brush.c

   1 /*
   2  * Unit test suite for brushes
   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 "wine/test.h"
  24 #include <math.h>
  25
  26 #define expect(expected, got) ok(got == expected, "Expected %.8x, got %.8x\n", expected, got)
  27 #define expectf(expected, got) ok(fabs(expected - got) < 0.0001, "Expected %.2f, got %.2f\n", expected, got)
  28
  29 static void test_constructor_destructor(void)
  30 {
  31     GpStatus status;
  32     GpSolidFill *brush = NULL;
  33
  34     status = GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
  35     expect(Ok, status);
  36     ok(brush != NULL, "Expected brush to be initialized\n");
  37
  38     status = GdipDeleteBrush(NULL);
  39     expect(InvalidParameter, status);
  40
  41     status = GdipDeleteBrush((GpBrush*) brush);
  42     expect(Ok, status);
  43 }
  44
  45 static void test_type(void)
  46 {
  47     GpStatus status;
  48     GpBrushType bt;
  49     GpSolidFill *brush = NULL;
  50
  51     GdipCreateSolidFill((ARGB)0xdeadbeef, &brush);
  52
  53     status = GdipGetBrushType((GpBrush*)brush, &bt);
  54     expect(Ok, status);
  55     expect(BrushTypeSolidColor, bt);
  56
  57     GdipDeleteBrush((GpBrush*) brush);
  58 }
  59 static GpPointF blendcount_ptf[] = {{0.0, 0.0},
  60                                     {50.0, 50.0}};
  61 static void test_gradientblendcount(void)
  62 {
  63     GpStatus status;
  64     GpPathGradient *brush;
  65     INT count;
  66
  67     status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &brush);
  68     expect(Ok, status);
  69
  70     status = GdipGetPathGradientBlendCount(NULL, NULL);
  71     expect(InvalidParameter, status);
  72     status = GdipGetPathGradientBlendCount(NULL, &count);
  73     expect(InvalidParameter, status);
  74     status = GdipGetPathGradientBlendCount(brush, NULL);
  75     expect(InvalidParameter, status);
  76
  77     status = GdipGetPathGradientBlendCount(brush, &count);
  78     expect(Ok, status);
  79     expect(1, count);
  80
  81     GdipDeleteBrush((GpBrush*) brush);
  82 }
  83
  84 static GpPointF getblend_ptf[] = {{0.0, 0.0},
  85                                   {50.0, 50.0}};
  86 static void test_getblend(void)
  87 {
  88     GpStatus status;
  89     GpPathGradient *brush;
  90     REAL blends[4];
  91     REAL pos[4];
  92
  93     status = GdipCreatePathGradient(getblend_ptf, 2, WrapModeClamp, &brush);
  94     expect(Ok, status);
  95
  96     /* check some invalid parameters combinations */
  97     status = GdipGetPathGradientBlend(NULL, NULL,  NULL, -1);
  98     expect(InvalidParameter, status);
  99     status = GdipGetPathGradientBlend(brush,NULL,  NULL, -1);
 100     expect(InvalidParameter, status);
 101     status = GdipGetPathGradientBlend(NULL, blends,NULL, -1);
 102     expect(InvalidParameter, status);
 103     status = GdipGetPathGradientBlend(NULL, NULL,  pos,  -1);
 104     expect(InvalidParameter, status);
 105     status = GdipGetPathGradientBlend(NULL, NULL,  NULL,  1);
 106     expect(InvalidParameter, status);
 107
 108     blends[0] = (REAL)0xdeadbeef;
 109     pos[0]    = (REAL)0xdeadbeef;
 110     status = GdipGetPathGradientBlend(brush, blends, pos, 1);
 111     expect(Ok, status);
 112     expectf(1.0, blends[0]);
 113     expectf((REAL)0xdeadbeef, pos[0]);
 114
 115     GdipDeleteBrush((GpBrush*) brush);
 116 }
 117
 118 static GpPointF getbounds_ptf[] = {{0.0, 20.0},
 119                                    {50.0, 50.0},
 120                                    {21.0, 25.0},
 121                                    {25.0, 46.0}};
 122 static void test_getbounds(void)
 123 {
 124     GpStatus status;
 125     GpPathGradient *brush;
 126     GpRectF bounds;
 127
 128     status = GdipCreatePathGradient(getbounds_ptf, 4, WrapModeClamp, &brush);
 129     expect(Ok, status);
 130
 131     status = GdipGetPathGradientRect(NULL, NULL);
 132     expect(InvalidParameter, status);
 133     status = GdipGetPathGradientRect(brush, NULL);
 134     expect(InvalidParameter, status);
 135     status = GdipGetPathGradientRect(NULL, &bounds);
 136     expect(InvalidParameter, status);
 137
 138     status = GdipGetPathGradientRect(brush, &bounds);
 139     expect(Ok, status);
 140     expectf(0.0, bounds.X);
 141     expectf(20.0, bounds.Y);
 142     expectf(50.0, bounds.Width);
 143     expectf(30.0, bounds.Height);
 144
 145     GdipDeleteBrush((GpBrush*) brush);
 146 }
 147
 148 static void test_getgamma(void)
 149 {
 150     GpStatus status;
 151     GpLineGradient *line;
 152     GpPointF start, end;
 153     BOOL gamma;
 154
 155     start.X = start.Y = 0.0;
 156     end.X = end.Y = 100.0;
 157
 158     status = GdipCreateLineBrush(&start, &end, (ARGB)0xdeadbeef, 0xdeadbeef, WrapModeTile, &line);
 159     expect(Ok, status);
 160
 161     /* NULL arguments */
 162     status = GdipGetLineGammaCorrection(NULL, NULL);
 163     expect(InvalidParameter, status);
 164     status = GdipGetLineGammaCorrection(line, NULL);
 165     expect(InvalidParameter, status);
 166     status = GdipGetLineGammaCorrection(NULL, &gamma);
 167     expect(InvalidParameter, status);
 168
 169     GdipDeleteBrush((GpBrush*)line);
 170 }
 171
 172 static void test_transform(void)
 173 {
 174     GpStatus status;
 175     GpTexture *texture;
 176     GpGraphics *graphics = NULL;
 177     GpBitmap *bitmap;
 178     HDC hdc = GetDC(0);
 179     GpMatrix *m, *m1;
 180     BOOL res;
 181
 182     status = GdipCreateMatrix2(2.0, 0.0, 0.0, 0.0, 0.0, 0.0, &m);
 183     expect(Ok, status);
 184
 185     status = GdipCreateFromHDC(hdc, &graphics);
 186     expect(Ok, status);
 187     status = GdipCreateBitmapFromGraphics(1, 1, graphics, &bitmap);
 188     expect(Ok, status);
 189
 190     status = GdipCreateTexture((GpImage*)bitmap, WrapModeTile, &texture);
 191     expect(Ok, status);
 192
 193     /* NULL */
 194     status = GdipGetTextureTransform(NULL, NULL);
 195     expect(InvalidParameter, status);
 196     status = GdipGetTextureTransform(texture, NULL);
 197     expect(InvalidParameter, status);
 198
 199     /* get default value - identity matrix */
 200     status = GdipGetTextureTransform(texture, m);
 201     expect(Ok, status);
 202     status = GdipIsMatrixIdentity(m, &res);
 203     expect(Ok, status);
 204     expect(TRUE, res);
 205     /* set and get then */
 206     status = GdipCreateMatrix2(2.0, 0.0, 0.0, 2.0, 0.0, 0.0, &m1);
 207     expect(Ok, status);
 208     status = GdipSetTextureTransform(texture, m1);
 209     expect(Ok, status);
 210     status = GdipGetTextureTransform(texture, m);
 211     expect(Ok, status);
 212     status = GdipIsMatrixEqual(m, m1, &res);
 213     expect(Ok, status);
 214     expect(TRUE, res);
 215     /* reset */
 216     status = GdipResetTextureTransform(texture);
 217     expect(Ok, status);
 218     status = GdipGetTextureTransform(texture, m);
 219     expect(Ok, status);
 220     status = GdipIsMatrixIdentity(m, &res);
 221     expect(Ok, status);
 222     expect(TRUE, res);
 223
 224     status = GdipDeleteBrush((GpBrush*)texture);
 225     expect(Ok, status);
 226
 227     status = GdipDeleteMatrix(m1);
 228     expect(Ok, status);
 229     status = GdipDeleteMatrix(m);
 230     expect(Ok, status);
 231     status = GdipDisposeImage((GpImage*)bitmap);
 232     expect(Ok, status);
 233     status = GdipDeleteGraphics(graphics);
 234     expect(Ok, status);
 235     ReleaseDC(0, hdc);
 236 }
 237
 238 static void test_texturewrap(void)
 239 {
 240     GpStatus status;
 241     GpTexture *texture;
 242     GpGraphics *graphics = NULL;
 243     GpBitmap *bitmap;
 244     HDC hdc = GetDC(0);
 245     GpWrapMode wrap;
 246
 247     status = GdipCreateFromHDC(hdc, &graphics);
 248     expect(Ok, status);
 249     status = GdipCreateBitmapFromGraphics(1, 1, graphics, &bitmap);
 250     expect(Ok, status);
 251
 252     status = GdipCreateTexture((GpImage*)bitmap, WrapModeTile, &texture);
 253     expect(Ok, status);
 254
 255     /* NULL */
 256     status = GdipGetTextureWrapMode(NULL, NULL);
 257     expect(InvalidParameter, status);
 258     status = GdipGetTextureWrapMode(texture, NULL);
 259     expect(InvalidParameter, status);
 260     status = GdipGetTextureWrapMode(NULL, &wrap);
 261     expect(InvalidParameter, status);
 262
 263     /* get */
 264     wrap = WrapModeClamp;
 265     status = GdipGetTextureWrapMode(texture, &wrap);
 266     expect(Ok, status);
 267     expect(WrapModeTile, wrap);
 268     /* set, then get */
 269     wrap = WrapModeClamp;
 270     status = GdipSetTextureWrapMode(texture, wrap);
 271     expect(Ok, status);
 272     wrap = WrapModeTile;
 273     status = GdipGetTextureWrapMode(texture, &wrap);
 274     expect(Ok, status);
 275     expect(WrapModeClamp, wrap);
 276
 277     status = GdipDeleteBrush((GpBrush*)texture);
 278     expect(Ok, status);
 279     status = GdipDisposeImage((GpImage*)bitmap);
 280     expect(Ok, status);
 281     status = GdipDeleteGraphics(graphics);
 282     expect(Ok, status);
 283     ReleaseDC(0, hdc);
 284 }
 285
 286 static void test_gradientgetrect(void)
 287 {
 288     GpLineGradient *brush;
 289     GpMatrix *transform;
 290     REAL elements[6];
 291     GpRectF rectf;
 292     GpStatus status;
 293     GpPointF pt1, pt2;
 294
 295     status = GdipCreateMatrix(&transform);
 296     expect(Ok, status);
 297
 298     pt1.X = pt1.Y = 1.0;
 299     pt2.X = pt2.Y = 100.0;
 300     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 301     expect(Ok, status);
 302     memset(&rectf, 0, sizeof(GpRectF));
 303     status = GdipGetLineRect(brush, &rectf);
 304     expect(Ok, status);
 305     expectf(1.0, rectf.X);
 306     expectf(1.0, rectf.Y);
 307     expectf(99.0, rectf.Width);
 308     expectf(99.0, rectf.Height);
 309     status = GdipGetLineTransform(brush, transform);
 310     todo_wine expect(Ok, status);
 311     if (status == Ok)
 312     {
 313         status = GdipGetMatrixElements(transform, elements);
 314         expect(Ok, status);
 315         expectf(1.0, elements[0]);
 316         expectf(1.0, elements[1]);
 317         expectf(-1.0, elements[2]);
 318         expectf(1.0, elements[3]);
 319         expectf(50.50, elements[4]);
 320         expectf(-50.50, elements[5]);
 321     }
 322     status = GdipDeleteBrush((GpBrush*)brush);
 323     expect(Ok, status);
 324     /* vertical gradient */
 325     pt1.X = pt1.Y = pt2.X = 0.0;
 326     pt2.Y = 10.0;
 327     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 328     expect(Ok, status);
 329     memset(&rectf, 0, sizeof(GpRectF));
 330     status = GdipGetLineRect(brush, &rectf);
 331     expect(Ok, status);
 332     expectf(-5.0, rectf.X);
 333     expectf(0.0, rectf.Y);
 334     expectf(10.0, rectf.Width);
 335     expectf(10.0, rectf.Height);
 336     status = GdipGetLineTransform(brush, transform);
 337     todo_wine expect(Ok, status);
 338     if (status == Ok)
 339     {
 340         status = GdipGetMatrixElements(transform, elements);
 341         expect(Ok, status);
 342         expectf(0.0, elements[0]);
 343         expectf(1.0, elements[1]);
 344         expectf(-1.0, elements[2]);
 345         expectf(0.0, elements[3]);
 346         expectf(5.0, elements[4]);
 347         expectf(5.0, elements[5]);
 348     }
 349     status = GdipDeleteBrush((GpBrush*)brush);
 350     expect(Ok, status);
 351     /* horizontal gradient */
 352     pt1.X = pt1.Y = pt2.Y = 0.0;
 353     pt2.X = 10.0;
 354     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 355     expect(Ok, status);
 356     memset(&rectf, 0, sizeof(GpRectF));
 357     status = GdipGetLineRect(brush, &rectf);
 358     expect(Ok, status);
 359     expectf(0.0, rectf.X);
 360     expectf(-5.0, rectf.Y);
 361     expectf(10.0, rectf.Width);
 362     expectf(10.0, rectf.Height);
 363     status = GdipGetLineTransform(brush, transform);
 364     todo_wine expect(Ok, status);
 365     if (status == Ok)
 366     {
 367         status = GdipGetMatrixElements(transform, elements);
 368         expect(Ok, status);
 369         expectf(1.0, elements[0]);
 370         expectf(0.0, elements[1]);
 371         expectf(0.0, elements[2]);
 372         expectf(1.0, elements[3]);
 373         expectf(0.0, elements[4]);
 374         expectf(0.0, elements[5]);
 375     }
 376     status = GdipDeleteBrush((GpBrush*)brush);
 377     expect(Ok, status);
 378     /* slope = -1 */
 379     pt1.X = pt1.Y = 0.0;
 380     pt2.X = 20.0;
 381     pt2.Y = -20.0;
 382     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 383     expect(Ok, status);
 384     memset(&rectf, 0, sizeof(GpRectF));
 385     status = GdipGetLineRect(brush, &rectf);
 386     expect(Ok, status);
 387     expectf(0.0, rectf.X);
 388     expectf(-20.0, rectf.Y);
 389     expectf(20.0, rectf.Width);
 390     expectf(20.0, rectf.Height);
 391     status = GdipGetLineTransform(brush, transform);
 392     todo_wine expect(Ok, status);
 393     if (status == Ok)
 394     {
 395         status = GdipGetMatrixElements(transform, elements);
 396         expect(Ok, status);
 397         expectf(1.0, elements[0]);
 398         expectf(-1.0, elements[1]);
 399         expectf(1.0, elements[2]);
 400         expectf(1.0, elements[3]);
 401         expectf(10.0, elements[4]);
 402         expectf(10.0, elements[5]);
 403     }
 404     status = GdipDeleteBrush((GpBrush*)brush);
 405     expect(Ok, status);
 406     /* slope = 1/100 */
 407     pt1.X = pt1.Y = 0.0;
 408     pt2.X = 100.0;
 409     pt2.Y = 1.0;
 410     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 411     expect(Ok, status);
 412     memset(&rectf, 0, sizeof(GpRectF));
 413     status = GdipGetLineRect(brush, &rectf);
 414     expect(Ok, status);
 415     expectf(0.0, rectf.X);
 416     expectf(0.0, rectf.Y);
 417     expectf(100.0, rectf.Width);
 418     expectf(1.0, rectf.Height);
 419     status = GdipGetLineTransform(brush, transform);
 420     todo_wine expect(Ok, status);
 421     if (status == Ok)
 422     {
 423         status = GdipGetMatrixElements(transform, elements);
 424         expect(Ok,status);
 425         expectf(1.0, elements[0]);
 426         expectf(0.01, elements[1]);
 427         expectf(-0.02, elements[2]);
 428         /* expectf(2.0, elements[3]); */
 429         expectf(0.01, elements[4]);
 430         /* expectf(-1.0, elements[5]); */
 431     }
 432     status = GdipDeleteBrush((GpBrush*)brush);
 433     expect(Ok,status);
 434     /* zero height rect */
 435     rectf.X = rectf.Y = 10.0;
 436     rectf.Width = 100.0;
 437     rectf.Height = 0.0;
 438     status = GdipCreateLineBrushFromRect(&rectf, 0, 0, LinearGradientModeVertical,
 439         WrapModeTile, &brush);
 440     expect(OutOfMemory, status);
 441     /* zero width rect */
 442     rectf.X = rectf.Y = 10.0;
 443     rectf.Width = 0.0;
 444     rectf.Height = 100.0;
 445     status = GdipCreateLineBrushFromRect(&rectf, 0, 0, LinearGradientModeHorizontal,
 446         WrapModeTile, &brush);
 447     expect(OutOfMemory, status);
 448     /* from rect with LinearGradientModeHorizontal */
 449     rectf.X = rectf.Y = 10.0;
 450     rectf.Width = rectf.Height = 100.0;
 451     status = GdipCreateLineBrushFromRect(&rectf, 0, 0, LinearGradientModeHorizontal,
 452         WrapModeTile, &brush);
 453     expect(Ok, status);
 454     memset(&rectf, 0, sizeof(GpRectF));
 455     status = GdipGetLineRect(brush, &rectf);
 456     expect(Ok, status);
 457     expectf(10.0, rectf.X);
 458     expectf(10.0, rectf.Y);
 459     expectf(100.0, rectf.Width);
 460     expectf(100.0, rectf.Height);
 461     status = GdipGetLineTransform(brush, transform);
 462     todo_wine expect(Ok, status);
 463     if (status == Ok)
 464     {
 465         status = GdipGetMatrixElements(transform, elements);
 466         expect(Ok,status);
 467         expectf(1.0, elements[0]);
 468         expectf(0.0, elements[1]);
 469         expectf(0.0, elements[2]);
 470         expectf(1.0, elements[3]);
 471         expectf(0.0, elements[4]);
 472         expectf(0.0, elements[5]);
 473     }
 474     status = GdipDeleteBrush((GpBrush*)brush);
 475     expect(Ok,status);
 476     /* passing negative Width/Height to LinearGradientModeHorizontal */
 477     rectf.X = rectf.Y = 10.0;
 478     rectf.Width = rectf.Height = -100.0;
 479     status = GdipCreateLineBrushFromRect(&rectf, 0, 0, LinearGradientModeHorizontal,
 480         WrapModeTile, &brush);
 481     expect(Ok, status);
 482     memset(&rectf, 0, sizeof(GpRectF));
 483     status = GdipGetLineRect(brush, &rectf);
 484     expect(Ok, status);
 485     expectf(10.0, rectf.X);
 486     expectf(10.0, rectf.Y);
 487     expectf(-100.0, rectf.Width);
 488     expectf(-100.0, rectf.Height);
 489     status = GdipGetLineTransform(brush, transform);
 490     todo_wine expect(Ok, status);
 491     if (status == Ok)
 492     {
 493         status = GdipGetMatrixElements(transform, elements);
 494         expect(Ok,status);
 495         expectf(1.0, elements[0]);
 496         expectf(0.0, elements[1]);
 497         expectf(0.0, elements[2]);
 498         expectf(1.0, elements[3]);
 499         expectf(0.0, elements[4]);
 500         expectf(0.0, elements[5]);
 501     }
 502     status = GdipDeleteBrush((GpBrush*)brush);
 503     expect(Ok,status);
 504
 505     GdipDeleteMatrix(transform);
 506 }
 507
 508 static void test_lineblend(void)
 509 {
 510     GpLineGradient *brush;
 511     GpStatus status;
 512     GpPointF pt1, pt2;
 513     INT count=10;
 514     int i;
 515     const REAL factors[5] = {0.0f, 0.1f, 0.5f, 0.9f, 1.0f};
 516     const REAL positions[5] = {0.0f, 0.2f, 0.5f, 0.8f, 1.0f};
 517     const REAL two_positions[2] = {0.0f, 1.0f};
 518     const ARGB colors[5] = {0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffffffff};
 519     REAL res_factors[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
 520     REAL res_positions[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
 521     ARGB res_colors[6] = {0xdeadbeef, 0, 0, 0, 0};
 522
 523     pt1.X = pt1.Y = pt2.Y = pt2.X = 1.0;
 524     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 525     expect(OutOfMemory, status);
 526
 527     pt1.X = pt1.Y = 1.0;
 528     pt2.X = pt2.Y = 100.0;
 529     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 530     expect(Ok, status);
 531
 532     status = GdipGetLineBlendCount(NULL, &count);
 533     expect(InvalidParameter, status);
 534
 535     status = GdipGetLineBlendCount(brush, NULL);
 536     expect(InvalidParameter, status);
 537
 538     status = GdipGetLineBlendCount(brush, &count);
 539     expect(Ok, status);
 540     expect(1, count);
 541
 542     status = GdipGetLineBlend(NULL, res_factors, res_positions, 1);
 543     expect(InvalidParameter, status);
 544
 545     status = GdipGetLineBlend(brush, NULL, res_positions, 1);
 546     expect(InvalidParameter, status);
 547
 548     status = GdipGetLineBlend(brush, res_factors, NULL, 1);
 549     expect(InvalidParameter, status);
 550
 551     status = GdipGetLineBlend(brush, res_factors, res_positions, 0);
 552     expect(InvalidParameter, status);
 553
 554     status = GdipGetLineBlend(brush, res_factors, res_positions, -1);
 555     expect(InvalidParameter, status);
 556
 557     status = GdipGetLineBlend(brush, res_factors, res_positions, 1);
 558     expect(Ok, status);
 559
 560     status = GdipGetLineBlend(brush, res_factors, res_positions, 2);
 561     expect(Ok, status);
 562
 563     status = GdipSetLineBlend(NULL, factors, positions, 5);
 564     expect(InvalidParameter, status);
 565
 566     status = GdipSetLineBlend(brush, NULL, positions, 5);
 567     expect(InvalidParameter, status);
 568
 569     status = GdipSetLineBlend(brush, factors, NULL, 5);
 570     expect(InvalidParameter, status);
 571
 572     status = GdipSetLineBlend(brush, factors, positions, 0);
 573     expect(InvalidParameter, status);
 574
 575     status = GdipSetLineBlend(brush, factors, positions, -1);
 576     expect(InvalidParameter, status);
 577
 578     /* leave off the 0.0 position */
 579     status = GdipSetLineBlend(brush, &factors[1], &positions[1], 4);
 580     expect(InvalidParameter, status);
 581
 582     /* leave off the 1.0 position */
 583     status = GdipSetLineBlend(brush, factors, positions, 4);
 584     expect(InvalidParameter, status);
 585
 586     status = GdipSetLineBlend(brush, factors, positions, 5);
 587     expect(Ok, status);
 588
 589     status = GdipGetLineBlendCount(brush, &count);
 590     expect(Ok, status);
 591     expect(5, count);
 592
 593     status = GdipGetLineBlend(brush, res_factors, res_positions, 4);
 594     expect(InsufficientBuffer, status);
 595
 596     status = GdipGetLineBlend(brush, res_factors, res_positions, 5);
 597     expect(Ok, status);
 598
 599     for (i=0; i<5; i++)
 600     {
 601         expectf(factors[i], res_factors[i]);
 602         expectf(positions[i], res_positions[i]);
 603     }
 604
 605     status = GdipGetLineBlend(brush, res_factors, res_positions, 6);
 606     expect(Ok, status);
 607
 608     status = GdipSetLineBlend(brush, factors, positions, 1);
 609     expect(Ok, status);
 610
 611     status = GdipGetLineBlendCount(brush, &count);
 612     expect(Ok, status);
 613     expect(1, count);
 614
 615     status = GdipGetLineBlend(brush, res_factors, res_positions, 1);
 616     expect(Ok, status);
 617
 618     status = GdipGetLinePresetBlendCount(NULL, &count);
 619     expect(InvalidParameter, status);
 620
 621     status = GdipGetLinePresetBlendCount(brush, NULL);
 622     expect(InvalidParameter, status);
 623
 624     status = GdipGetLinePresetBlendCount(brush, &count);
 625     expect(Ok, status);
 626     expect(0, count);
 627
 628     status = GdipGetLinePresetBlend(NULL, res_colors, res_positions, 1);
 629     expect(InvalidParameter, status);
 630
 631     status = GdipGetLinePresetBlend(brush, NULL, res_positions, 1);
 632     expect(InvalidParameter, status);
 633
 634     status = GdipGetLinePresetBlend(brush, res_colors, NULL, 1);
 635     expect(InvalidParameter, status);
 636
 637     status = GdipGetLinePresetBlend(brush, res_colors, res_positions, 0);
 638     expect(InvalidParameter, status);
 639
 640     status = GdipGetLinePresetBlend(brush, res_colors, res_positions, -1);
 641     expect(InvalidParameter, status);
 642
 643     status = GdipGetLinePresetBlend(brush, res_colors, res_positions, 1);
 644     expect(InvalidParameter, status);
 645
 646     status = GdipGetLinePresetBlend(brush, res_colors, res_positions, 2);
 647     expect(GenericError, status);
 648
 649     status = GdipSetLinePresetBlend(NULL, colors, positions, 5);
 650     expect(InvalidParameter, status);
 651
 652     status = GdipSetLinePresetBlend(brush, NULL, positions, 5);
 653     expect(InvalidParameter, status);
 654
 655     status = GdipSetLinePresetBlend(brush, colors, NULL, 5);
 656     expect(InvalidParameter, status);
 657
 658     status = GdipSetLinePresetBlend(brush, colors, positions, 0);
 659     expect(InvalidParameter, status);
 660
 661     status = GdipSetLinePresetBlend(brush, colors, positions, -1);
 662     expect(InvalidParameter, status);
 663
 664     status = GdipSetLinePresetBlend(brush, colors, positions, 1);
 665     expect(InvalidParameter, status);
 666
 667     /* leave off the 0.0 position */
 668     status = GdipSetLinePresetBlend(brush, &colors[1], &positions[1], 4);
 669     expect(InvalidParameter, status);
 670
 671     /* leave off the 1.0 position */
 672     status = GdipSetLinePresetBlend(brush, colors, positions, 4);
 673     expect(InvalidParameter, status);
 674
 675     status = GdipSetLinePresetBlend(brush, colors, positions, 5);
 676     expect(Ok, status);
 677
 678     status = GdipGetLinePresetBlendCount(brush, &count);
 679     expect(Ok, status);
 680     expect(5, count);
 681
 682     status = GdipGetLinePresetBlend(brush, res_colors, res_positions, 4);
 683     expect(InsufficientBuffer, status);
 684
 685     status = GdipGetLinePresetBlend(brush, res_colors, res_positions, 5);
 686     expect(Ok, status);
 687
 688     for (i=0; i<5; i++)
 689     {
 690         expect(colors[i], res_colors[i]);
 691         expectf(positions[i], res_positions[i]);
 692     }
 693
 694     status = GdipGetLinePresetBlend(brush, res_colors, res_positions, 6);
 695     expect(Ok, status);
 696
 697     status = GdipSetLinePresetBlend(brush, colors, two_positions, 2);
 698     expect(Ok, status);
 699
 700     status = GdipDeleteBrush((GpBrush*)brush);
 701     expect(Ok, status);
 702 }
 703
 704 static void test_linelinearblend(void)
 705 {
 706     GpLineGradient *brush;
 707     GpStatus status;
 708     GpPointF pt1, pt2;
 709     INT count=10;
 710     REAL res_factors[3] = {0.3f};
 711     REAL res_positions[3] = {0.3f};
 712
 713     status = GdipSetLineLinearBlend(NULL, 0.6, 0.8);
 714     expect(InvalidParameter, status);
 715
 716     pt1.X = pt1.Y = 1.0;
 717     pt2.X = pt2.Y = 100.0;
 718     status = GdipCreateLineBrush(&pt1, &pt2, 0, 0, WrapModeTile, &brush);
 719     expect(Ok, status);
 720
 721
 722     status = GdipSetLineLinearBlend(brush, 0.6, 0.8);
 723     expect(Ok, status);
 724
 725     status = GdipGetLineBlendCount(brush, &count);
 726     expect(Ok, status);
 727     expect(3, count);
 728
 729     status = GdipGetLineBlend(brush, res_factors, res_positions, 3);
 730     expect(Ok, status);
 731     expectf(0.0, res_factors[0]);
 732     expectf(0.0, res_positions[0]);
 733     expectf(0.8, res_factors[1]);
 734     expectf(0.6, res_positions[1]);
 735     expectf(0.0, res_factors[2]);
 736     expectf(1.0, res_positions[2]);
 737
 738
 739     status = GdipSetLineLinearBlend(brush, 0.0, 0.8);
 740     expect(Ok, status);
 741
 742     status = GdipGetLineBlendCount(brush, &count);
 743     expect(Ok, status);
 744     expect(2, count);
 745
 746     status = GdipGetLineBlend(brush, res_factors, res_positions, 3);
 747     expect(Ok, status);
 748     expectf(0.8, res_factors[0]);
 749     expectf(0.0, res_positions[0]);
 750     expectf(0.0, res_factors[1]);
 751     expectf(1.0, res_positions[1]);
 752
 753
 754     status = GdipSetLineLinearBlend(brush, 1.0, 0.8);
 755     expect(Ok, status);
 756
 757     status = GdipGetLineBlendCount(brush, &count);
 758     expect(Ok, status);
 759     expect(2, count);
 760
 761     status = GdipGetLineBlend(brush, res_factors, res_positions, 3);
 762     expect(Ok, status);
 763     expectf(0.0, res_factors[0]);
 764     expectf(0.0, res_positions[0]);
 765     expectf(0.8, res_factors[1]);
 766     expectf(1.0, res_positions[1]);
 767
 768     status = GdipDeleteBrush((GpBrush*)brush);
 769     expect(Ok, status);
 770 }
 771
 772 static void test_gradientsurroundcolorcount(void)
 773 {
 774     GpStatus status;
 775     GpPathGradient *grad;
 776     ARGB color[3];
 777     INT count;
 778
 779     status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &grad);
 780     expect(Ok, status);
 781
 782     count = 0;
 783     status = GdipGetPathGradientSurroundColorCount(grad, &count);
 784     expect(Ok, status);
 785     expect(2, count);
 786
 787     color[0] = color[1] = color[2] = 0xdeadbeef;
 788     count = 3;
 789     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 790     expect(Ok, status);
 791     expect(1, count);
 792     expect(0xffffffff, color[0]);
 793     expect(0xffffffff, color[1]);
 794     expect(0xdeadbeef, color[2]);
 795
 796     color[0] = color[1] = color[2] = 0xdeadbeef;
 797     count = 2;
 798     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 799     expect(Ok, status);
 800     expect(1, count);
 801     expect(0xffffffff, color[0]);
 802     expect(0xffffffff, color[1]);
 803     expect(0xdeadbeef, color[2]);
 804
 805     color[0] = color[1] = color[2] = 0xdeadbeef;
 806     count = 1;
 807     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 808     expect(InvalidParameter, status);
 809     expect(1, count);
 810     expect(0xdeadbeef, color[0]);
 811     expect(0xdeadbeef, color[1]);
 812     expect(0xdeadbeef, color[2]);
 813
 814     color[0] = color[1] = color[2] = 0xdeadbeef;
 815     count = 0;
 816     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 817     expect(InvalidParameter, status);
 818     expect(0, count);
 819     expect(0xdeadbeef, color[0]);
 820     expect(0xdeadbeef, color[1]);
 821     expect(0xdeadbeef, color[2]);
 822
 823     count = 3;
 824     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 825     expect(InvalidParameter, status);
 826
 827     count = 2;
 828
 829     color[0] = 0x00ff0000;
 830     color[1] = 0x0000ff00;
 831
 832     status = GdipSetPathGradientSurroundColorsWithCount(NULL, color, &count);
 833     expect(InvalidParameter, status);
 834
 835     status = GdipSetPathGradientSurroundColorsWithCount(grad, NULL, &count);
 836     expect(InvalidParameter, status);
 837
 838     /* WinXP crashes on this test */
 839     if(0)
 840     {
 841         status = GdipSetPathGradientSurroundColorsWithCount(grad, color, NULL);
 842         expect(InvalidParameter, status);
 843     }
 844
 845     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 846     expect(Ok, status);
 847     expect(2, count);
 848
 849     status = GdipGetPathGradientSurroundColorCount(NULL, &count);
 850     expect(InvalidParameter, status);
 851
 852     status = GdipGetPathGradientSurroundColorCount(grad, NULL);
 853     expect(InvalidParameter, status);
 854
 855     count = 0;
 856     status = GdipGetPathGradientSurroundColorCount(grad, &count);
 857     expect(Ok, status);
 858     expect(2, count);
 859
 860     color[0] = color[1] = color[2] = 0xdeadbeef;
 861     count = 2;
 862     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 863     expect(Ok, status);
 864     expect(2, count);
 865     expect(0x00ff0000, color[0]);
 866     expect(0x0000ff00, color[1]);
 867     expect(0xdeadbeef, color[2]);
 868
 869     count = 1;
 870     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 871     expect(Ok, status);
 872     expect(1, count);
 873
 874     count = 0;
 875     status = GdipGetPathGradientSurroundColorCount(grad, &count);
 876     expect(Ok, status);
 877     expect(2, count);
 878
 879     /* If all colors are the same, count is set to 1. */
 880     color[0] = color[1] = 0;
 881     count = 2;
 882     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 883     expect(Ok, status);
 884     expect(2, count);
 885
 886     color[0] = color[1] = color[2] = 0xdeadbeef;
 887     count = 2;
 888     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 889     expect(Ok, status);
 890     expect(1, count);
 891     expect(0x00000000, color[0]);
 892     expect(0x00000000, color[1]);
 893     expect(0xdeadbeef, color[2]);
 894
 895     color[0] = color[1] = 0xff00ff00;
 896     count = 2;
 897     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 898     expect(Ok, status);
 899     expect(2, count);
 900
 901     color[0] = color[1] = color[2] = 0xdeadbeef;
 902     count = 2;
 903     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 904     expect(Ok, status);
 905     expect(1, count);
 906     expect(0xff00ff00, color[0]);
 907     expect(0xff00ff00, color[1]);
 908     expect(0xdeadbeef, color[2]);
 909
 910     count = 0;
 911     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 912     expect(InvalidParameter, status);
 913     expect(0, count);
 914
 915     GdipDeleteBrush((GpBrush*)grad);
 916
 917     status = GdipCreatePathGradient(getbounds_ptf, 3, WrapModeClamp, &grad);
 918     expect(Ok, status);
 919
 920     color[0] = color[1] = color[2] = 0xdeadbeef;
 921     count = 3;
 922     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 923     expect(Ok, status);
 924     expect(1, count);
 925     expect(0xffffffff, color[0]);
 926     expect(0xffffffff, color[1]);
 927     expect(0xffffffff, color[2]);
 928
 929     color[0] = color[1] = color[2] = 0xdeadbeef;
 930     count = 2;
 931     status = GdipGetPathGradientSurroundColorsWithCount(grad, color, &count);
 932     expect(InvalidParameter, status);
 933     expect(2, count);
 934     expect(0xdeadbeef, color[0]);
 935     expect(0xdeadbeef, color[1]);
 936     expect(0xdeadbeef, color[2]);
 937
 938     count = 0;
 939     status = GdipGetPathGradientSurroundColorCount(grad, &count);
 940     expect(Ok, status);
 941     expect(3, count);
 942
 943     GdipDeleteBrush((GpBrush*)grad);
 944 }
 945
 946 static void test_pathgradientpath(void)
 947 {
 948     GpStatus status;
 949     GpPath *path=NULL;
 950     GpPathGradient *grad=NULL;
 951
 952     status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &grad);
 953     expect(Ok, status);
 954
 955     status = GdipGetPathGradientPath(grad, NULL);
 956     expect(NotImplemented, status);
 957
 958     status = GdipCreatePath(FillModeWinding, &path);
 959     expect(Ok, status);
 960
 961     status = GdipGetPathGradientPath(NULL, path);
 962     expect(NotImplemented, status);
 963
 964     status = GdipGetPathGradientPath(grad, path);
 965     expect(NotImplemented, status);
 966
 967     status = GdipDeletePath(path);
 968     expect(Ok, status);
 969
 970     status = GdipDeleteBrush((GpBrush*)grad);
 971     expect(Ok, status);
 972 }
 973
 974 static void test_pathgradientcenterpoint(void)
 975 {
 976     static const GpPointF path_points[] = {{0,0}, {3,0}, {0,4}};
 977     GpStatus status;
 978     GpPathGradient *grad;
 979     GpPointF point;
 980
 981     status = GdipCreatePathGradient(path_points+1, 2, WrapModeClamp, &grad);
 982     expect(Ok, status);
 983
 984     status = GdipGetPathGradientCenterPoint(NULL, &point);
 985     expect(InvalidParameter, status);
 986
 987     status = GdipGetPathGradientCenterPoint(grad, NULL);
 988     expect(InvalidParameter, status);
 989
 990     status = GdipGetPathGradientCenterPoint(grad, &point);
 991     expect(Ok, status);
 992     expectf(1.5, point.X);
 993     expectf(2.0, point.Y);
 994
 995     status = GdipSetPathGradientCenterPoint(NULL, &point);
 996     expect(InvalidParameter, status);
 997
 998     status = GdipSetPathGradientCenterPoint(grad, NULL);
 999     expect(InvalidParameter, status);
1000
1001     point.X = 10.0;
1002     point.Y = 15.0;
1003     status = GdipSetPathGradientCenterPoint(grad, &point);
1004     expect(Ok, status);
1005
1006     point.X = point.Y = -1;
1007     status = GdipGetPathGradientCenterPoint(grad, &point);
1008     expect(Ok, status);
1009     expectf(10.0, point.X);
1010     expectf(15.0, point.Y);
1011
1012     status = GdipDeleteBrush((GpBrush*)grad);
1013     expect(Ok, status);
1014
1015     status = GdipCreatePathGradient(path_points, 3, WrapModeClamp, &grad);
1016     expect(Ok, status);
1017
1018     status = GdipGetPathGradientCenterPoint(grad, &point);
1019     expect(Ok, status);
1020     todo_wine expectf(1.0, point.X);
1021     todo_wine expectf(4.0/3.0, point.Y);
1022
1023     status = GdipDeleteBrush((GpBrush*)grad);
1024     expect(Ok, status);
1025 }
1026
1027 static void test_pathgradientpresetblend(void)
1028 {
1029     static const GpPointF path_points[] = {{0,0}, {3,0}, {0,4}};
1030     GpStatus status;
1031     GpPathGradient *grad;
1032     INT count;
1033     int i;
1034     const REAL positions[5] = {0.0f, 0.2f, 0.5f, 0.8f, 1.0f};
1035     const REAL two_positions[2] = {0.0f, 1.0f};
1036     const ARGB colors[5] = {0xff0000ff, 0xff00ff00, 0xff00ffff, 0xffff0000, 0xffffffff};
1037     REAL res_positions[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
1038     ARGB res_colors[6] = {0xdeadbeef, 0, 0, 0, 0};
1039
1040     status = GdipCreatePathGradient(path_points+1, 2, WrapModeClamp, &grad);
1041     expect(Ok, status);
1042
1043     status = GdipGetPathGradientPresetBlendCount(NULL, &count);
1044     expect(InvalidParameter, status);
1045
1046     status = GdipGetPathGradientPresetBlendCount(grad, NULL);
1047     expect(InvalidParameter, status);
1048
1049     status = GdipGetPathGradientPresetBlendCount(grad, &count);
1050     expect(Ok, status);
1051     expect(0, count);
1052
1053     status = GdipGetPathGradientPresetBlend(NULL, res_colors, res_positions, 1);
1054     expect(InvalidParameter, status);
1055
1056     status = GdipGetPathGradientPresetBlend(grad, NULL, res_positions, 1);
1057     expect(InvalidParameter, status);
1058
1059     status = GdipGetPathGradientPresetBlend(grad, res_colors, NULL, 1);
1060     expect(InvalidParameter, status);
1061
1062     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 0);
1063     expect(InvalidParameter, status);
1064
1065     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, -1);
1066     expect(OutOfMemory, status);
1067
1068     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 1);
1069     expect(InvalidParameter, status);
1070
1071     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 2);
1072     expect(GenericError, status);
1073
1074     status = GdipSetPathGradientPresetBlend(NULL, colors, positions, 5);
1075     expect(InvalidParameter, status);
1076
1077     status = GdipSetPathGradientPresetBlend(grad, NULL, positions, 5);
1078     expect(InvalidParameter, status);
1079
1080     if (0)
1081     {
1082         /* crashes on windows xp */
1083         status = GdipSetPathGradientPresetBlend(grad, colors, NULL, 5);
1084         expect(InvalidParameter, status);
1085     }
1086
1087     status = GdipSetPathGradientPresetBlend(grad, colors, positions, 0);
1088     expect(InvalidParameter, status);
1089
1090     status = GdipSetPathGradientPresetBlend(grad, colors, positions, -1);
1091     expect(InvalidParameter, status);
1092
1093     status = GdipSetPathGradientPresetBlend(grad, colors, positions, 1);
1094     expect(InvalidParameter, status);
1095
1096     /* leave off the 0.0 position */
1097     status = GdipSetPathGradientPresetBlend(grad, &colors[1], &positions[1], 4);
1098     expect(InvalidParameter, status);
1099
1100     /* leave off the 1.0 position */
1101     status = GdipSetPathGradientPresetBlend(grad, colors, positions, 4);
1102     expect(InvalidParameter, status);
1103
1104     status = GdipSetPathGradientPresetBlend(grad, colors, positions, 5);
1105     expect(Ok, status);
1106
1107     status = GdipGetPathGradientPresetBlendCount(grad, &count);
1108     expect(Ok, status);
1109     expect(5, count);
1110
1111     if (0)
1112     {
1113         /* Native GdipGetPathGradientPresetBlend seems to copy starting from
1114          * the end of each array and do no bounds checking. This is so braindead
1115          * I'm not going to copy it. */
1116
1117         res_colors[0] = 0xdeadbeef;
1118         res_positions[0] = 0.3;
1119
1120         status = GdipGetPathGradientPresetBlend(grad, &res_colors[1], &res_positions[1], 4);
1121         expect(Ok, status);
1122
1123         expect(0xdeadbeef, res_colors[0]);
1124         expectf(0.3, res_positions[0]);
1125
1126         for (i=1; i<5; i++)
1127         {
1128             expect(colors[i], res_colors[i]);
1129             expectf(positions[i], res_positions[i]);
1130         }
1131
1132         status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 6);
1133         expect(Ok, status);
1134
1135         for (i=0; i<5; i++)
1136         {
1137             expect(colors[i], res_colors[i+1]);
1138             expectf(positions[i], res_positions[i+1]);
1139         }
1140     }
1141
1142     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 5);
1143     expect(Ok, status);
1144
1145     for (i=0; i<5; i++)
1146     {
1147         expect(colors[i], res_colors[i]);
1148         expectf(positions[i], res_positions[i]);
1149     }
1150
1151     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 0);
1152     expect(InvalidParameter, status);
1153
1154     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, -1);
1155     expect(OutOfMemory, status);
1156
1157     status = GdipGetPathGradientPresetBlend(grad, res_colors, res_positions, 1);
1158     expect(InvalidParameter, status);
1159
1160     status = GdipSetPathGradientPresetBlend(grad, colors, two_positions, 2);
1161     expect(Ok, status);
1162
1163     status = GdipDeleteBrush((GpBrush*)grad);
1164     expect(Ok, status);
1165 }
1166
1167 static void test_pathgradientblend(void)
1168 {
1169     static const GpPointF path_points[] = {{0,0}, {3,0}, {0,4}};
1170     GpPathGradient *brush;
1171     GpStatus status;
1172     INT count, i;
1173     const REAL factors[5] = {0.0f, 0.1f, 0.5f, 0.9f, 1.0f};
1174     const REAL positions[5] = {0.0f, 0.2f, 0.5f, 0.8f, 1.0f};
1175     REAL res_factors[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
1176     REAL res_positions[6] = {0.3f, 0.0f, 0.0f, 0.0f, 0.0f};
1177
1178     status = GdipCreatePathGradient(path_points, 3, WrapModeClamp, &brush);
1179     expect(Ok, status);
1180
1181     status = GdipGetPathGradientBlendCount(NULL, &count);
1182     expect(InvalidParameter, status);
1183
1184     status = GdipGetPathGradientBlendCount(brush, NULL);
1185     expect(InvalidParameter, status);
1186
1187     status = GdipGetPathGradientBlendCount(brush, &count);
1188     expect(Ok, status);
1189     expect(1, count);
1190
1191     status = GdipGetPathGradientBlend(NULL, res_factors, res_positions, 1);
1192     expect(InvalidParameter, status);
1193
1194     status = GdipGetPathGradientBlend(brush, NULL, res_positions, 1);
1195     expect(InvalidParameter, status);
1196
1197     status = GdipGetPathGradientBlend(brush, res_factors, NULL, 1);
1198     expect(InvalidParameter, status);
1199
1200     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 0);
1201     expect(InvalidParameter, status);
1202
1203     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, -1);
1204     expect(InvalidParameter, status);
1205
1206     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 1);
1207     expect(Ok, status);
1208
1209     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 2);
1210     expect(Ok, status);
1211
1212     status = GdipSetPathGradientBlend(NULL, factors, positions, 5);
1213     expect(InvalidParameter, status);
1214
1215     status = GdipSetPathGradientBlend(brush, NULL, positions, 5);
1216     expect(InvalidParameter, status);
1217
1218     status = GdipSetPathGradientBlend(brush, factors, NULL, 5);
1219     expect(InvalidParameter, status);
1220
1221     status = GdipSetPathGradientBlend(brush, factors, positions, 0);
1222     expect(InvalidParameter, status);
1223
1224     status = GdipSetPathGradientBlend(brush, factors, positions, -1);
1225     expect(InvalidParameter, status);
1226
1227     /* leave off the 0.0 position */
1228     status = GdipSetPathGradientBlend(brush, &factors[1], &positions[1], 4);
1229     expect(InvalidParameter, status);
1230
1231     /* leave off the 1.0 position */
1232     status = GdipSetPathGradientBlend(brush, factors, positions, 4);
1233     expect(InvalidParameter, status);
1234
1235     status = GdipSetPathGradientBlend(brush, factors, positions, 5);
1236     expect(Ok, status);
1237
1238     status = GdipGetPathGradientBlendCount(brush, &count);
1239     expect(Ok, status);
1240     expect(5, count);
1241
1242     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 4);
1243     expect(InsufficientBuffer, status);
1244
1245     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 5);
1246     expect(Ok, status);
1247
1248     for (i=0; i<5; i++)
1249     {
1250         expectf(factors[i], res_factors[i]);
1251         expectf(positions[i], res_positions[i]);
1252     }
1253
1254     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 6);
1255     expect(Ok, status);
1256
1257     status = GdipSetPathGradientBlend(brush, factors, positions, 1);
1258     expect(Ok, status);
1259
1260     status = GdipGetPathGradientBlendCount(brush, &count);
1261     expect(Ok, status);
1262     expect(1, count);
1263
1264     status = GdipGetPathGradientBlend(brush, res_factors, res_positions, 1);
1265     expect(Ok, status);
1266
1267     status = GdipDeleteBrush((GpBrush*)brush);
1268     expect(Ok, status);
1269 }
1270
1271 START_TEST(brush)
1272 {
1273     struct GdiplusStartupInput gdiplusStartupInput;
1274     ULONG_PTR gdiplusToken;
1275
1276     gdiplusStartupInput.GdiplusVersion              = 1;
1277     gdiplusStartupInput.DebugEventCallback          = NULL;
1278     gdiplusStartupInput.SuppressBackgroundThread    = 0;
1279     gdiplusStartupInput.SuppressExternalCodecs      = 0;
1280
1281     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
1282
1283     test_constructor_destructor();
1284     test_type();
1285     test_gradientblendcount();
1286     test_getblend();
1287     test_getbounds();
1288     test_getgamma();
1289     test_transform();
1290     test_texturewrap();
1291     test_gradientgetrect();
1292     test_lineblend();
1293     test_linelinearblend();
1294     test_gradientsurroundcolorcount();
1295     test_pathgradientpath();
1296     test_pathgradientcenterpoint();
1297     test_pathgradientpresetblend();
1298     test_pathgradientblend();
1299
1300     GdiplusShutdown(gdiplusToken);
1301 }