git.oblomov.eu Git - wine/blob - 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;
 777     INT count = 3;
 778
 779     status = GdipCreatePathGradient(blendcount_ptf, 2, WrapModeClamp, &grad);
 780     expect(Ok, status);
 781
 782     color = GdipAlloc(sizeof(ARGB[3]));
 783
 784     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 785     expect(InvalidParameter, status);
 786     GdipFree(color);
 787
 788     count = 2;
 789
 790     color = GdipAlloc(sizeof(ARGB[2]));
 791
 792     color[0] = 0x00ff0000;
 793     color[1] = 0x0000ff00;
 794
 795     status = GdipSetPathGradientSurroundColorsWithCount(NULL, color, &count);
 796     expect(InvalidParameter, status);
 797
 798     status = GdipSetPathGradientSurroundColorsWithCount(grad, NULL, &count);
 799     expect(InvalidParameter, status);
 800
 801     /* WinXP crashes on this test */
 802     if(0)
 803     {
 804         status = GdipSetPathGradientSurroundColorsWithCount(grad, color, NULL);
 805         expect(InvalidParameter, status);
 806     }
 807
 808     status = GdipSetPathGradientSurroundColorsWithCount(grad, color, &count);
 809     todo_wine expect(Ok, status);
 810     expect(2, count);
 811
 812     status = GdipGetPathGradientSurroundColorCount(NULL, &count);
 813     expect(InvalidParameter, status);
 814
 815     status = GdipGetPathGradientSurroundColorCount(grad, NULL);
 816     expect(InvalidParameter, status);
 817
 818     count = 0;
 819     status = GdipGetPathGradientSurroundColorCount(grad, &count);
 820     todo_wine expect(Ok, status);
 821     todo_wine expect(2, count);
 822
 823     GdipFree(color);
 824     GdipDeleteBrush((GpBrush*)grad);
 825 }
 826
 827 START_TEST(brush)
 828 {
 829     struct GdiplusStartupInput gdiplusStartupInput;
 830     ULONG_PTR gdiplusToken;
 831
 832     gdiplusStartupInput.GdiplusVersion              = 1;
 833     gdiplusStartupInput.DebugEventCallback          = NULL;
 834     gdiplusStartupInput.SuppressBackgroundThread    = 0;
 835     gdiplusStartupInput.SuppressExternalCodecs      = 0;
 836
 837     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
 838
 839     test_constructor_destructor();
 840     test_type();
 841     test_gradientblendcount();
 842     test_getblend();
 843     test_getbounds();
 844     test_getgamma();
 845     test_transform();
 846     test_texturewrap();
 847     test_gradientgetrect();
 848     test_lineblend();
 849     test_linelinearblend();
 850     test_gradientsurroundcolorcount();
 851
 852     GdiplusShutdown(gdiplusToken);
 853 }