gdiplus: Implemented GdipIsVisiblePathPoint with tests.
[wine] / dlls / gdiplus / tests / image.c
1 /*
2  * Unit test suite for images
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 <math.h>
22
23 #include "initguid.h"
24 #include "windows.h"
25 #include "gdiplus.h"
26 #include "wine/test.h"
27
28 #define expect(expected, got) ok(((UINT)got) == ((UINT)expected), "Expected %.8x, got %.8x\n", (UINT)expected, (UINT)got)
29
30 static void test_Scan0(void)
31 {
32     GpBitmap *bm;
33     GpStatus stat;
34     BYTE buff[360];
35
36     bm = NULL;
37     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
38     expect(Ok, stat);
39     ok(NULL != bm, "Expected bitmap to be initialized\n");
40     if (stat == Ok)
41         GdipDisposeImage((GpImage*)bm);
42
43     bm = (GpBitmap*)0xdeadbeef;
44     stat = GdipCreateBitmapFromScan0(10, -10, 10, PixelFormat24bppRGB, NULL, &bm);
45     expect(InvalidParameter, stat);
46     ok( !bm, "expected null bitmap\n" );
47
48     bm = (GpBitmap*)0xdeadbeef;
49     stat = GdipCreateBitmapFromScan0(-10, 10, 10, PixelFormat24bppRGB, NULL, &bm);
50     expect(InvalidParameter, stat);
51     ok( !bm, "expected null bitmap\n" );
52
53     bm = (GpBitmap*)0xdeadbeef;
54     stat = GdipCreateBitmapFromScan0(10, 0, 10, PixelFormat24bppRGB, NULL, &bm);
55     expect(InvalidParameter, stat);
56     ok( !bm, "expected null bitmap\n" );
57
58     bm = NULL;
59     stat = GdipCreateBitmapFromScan0(10, 10, 12, PixelFormat24bppRGB, buff, &bm);
60     expect(Ok, stat);
61     ok(NULL != bm, "Expected bitmap to be initialized\n");
62     if (stat == Ok)
63         GdipDisposeImage((GpImage*)bm);
64
65     bm = (GpBitmap*) 0xdeadbeef;
66     stat = GdipCreateBitmapFromScan0(10, 10, 10, PixelFormat24bppRGB, buff, &bm);
67     expect(InvalidParameter, stat);
68     ok( !bm, "expected null bitmap\n" );
69
70     bm = (GpBitmap*)0xdeadbeef;
71     stat = GdipCreateBitmapFromScan0(10, 10, 0, PixelFormat24bppRGB, buff, &bm);
72     expect(InvalidParameter, stat);
73     ok( bm == (GpBitmap*)0xdeadbeef, "expected deadbeef bitmap\n" );
74
75     bm = NULL;
76     stat = GdipCreateBitmapFromScan0(10, 10, -8, PixelFormat24bppRGB, buff, &bm);
77     todo_wine{
78         expect(Ok, stat);
79         ok(NULL != bm, "Expected bitmap to be initialized\n");
80     }
81     if (stat == Ok)
82         GdipDisposeImage((GpImage*)bm);
83
84     bm = (GpBitmap*)0xdeadbeef;
85     stat = GdipCreateBitmapFromScan0(10, 10, -10, PixelFormat24bppRGB, buff, &bm);
86     expect(InvalidParameter, stat);
87     ok( !bm, "expected null bitmap\n" );
88 }
89
90 static void test_GetImageDimension(void)
91 {
92     GpBitmap *bm;
93     GpStatus stat;
94     const REAL WIDTH = 10.0, HEIGHT = 20.0;
95     REAL w,h;
96
97     bm = (GpBitmap*)0xdeadbeef;
98     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
99     expect(Ok,stat);
100     ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
101     ok(NULL != bm, "Expected bitmap to not be NULL\n");
102
103     stat = GdipGetImageDimension(NULL,&w,&h);
104     expect(InvalidParameter, stat);
105
106     stat = GdipGetImageDimension((GpImage*)bm,NULL,&h);
107     expect(InvalidParameter, stat);
108
109     stat = GdipGetImageDimension((GpImage*)bm,&w,NULL);
110     expect(InvalidParameter, stat);
111
112     w = -1;
113     h = -1;
114     stat = GdipGetImageDimension((GpImage*)bm,&w,&h);
115     expect(Ok, stat);
116     ok(fabs(WIDTH - w) < 0.0001, "Width wrong\n");
117     ok(fabs(HEIGHT - h) < 0.0001, "Height wrong\n");
118     GdipDisposeImage((GpImage*)bm);
119 }
120
121 static void test_GdipImageGetFrameDimensionsCount(void)
122 {
123     GpBitmap *bm;
124     GpStatus stat;
125     const REAL WIDTH = 10.0, HEIGHT = 20.0;
126     UINT w;
127
128     bm = (GpBitmap*)0xdeadbeef;
129     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB,NULL, &bm);
130     expect(Ok,stat);
131     ok((GpBitmap*)0xdeadbeef != bm, "Expected bitmap to not be 0xdeadbeef\n");
132     ok(NULL != bm, "Expected bitmap to not be NULL\n");
133
134     stat = GdipImageGetFrameDimensionsCount(NULL,&w);
135     expect(InvalidParameter, stat);
136
137     stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,NULL);
138     expect(InvalidParameter, stat);
139
140     w = -1;
141     stat = GdipImageGetFrameDimensionsCount((GpImage*)bm,&w);
142     expect(Ok, stat);
143     expect(1, w);
144     GdipDisposeImage((GpImage*)bm);
145 }
146
147 static void test_LoadingImages(void)
148 {
149     GpStatus stat;
150
151     stat = GdipCreateBitmapFromFile(0, 0);
152     expect(InvalidParameter, stat);
153
154     stat = GdipCreateBitmapFromFile(0, (GpBitmap**)0xdeadbeef);
155     expect(InvalidParameter, stat);
156
157     stat = GdipLoadImageFromFile(0, 0);
158     expect(InvalidParameter, stat);
159
160     stat = GdipLoadImageFromFile(0, (GpImage**)0xdeadbeef);
161     expect(InvalidParameter, stat);
162
163     stat = GdipLoadImageFromFileICM(0, 0);
164     expect(InvalidParameter, stat);
165
166     stat = GdipLoadImageFromFileICM(0, (GpImage**)0xdeadbeef);
167     expect(InvalidParameter, stat);
168 }
169
170 static void test_SavingImages(void)
171 {
172     GpStatus stat;
173     GpBitmap *bm;
174     UINT n;
175     UINT s;
176     const REAL WIDTH = 10.0, HEIGHT = 20.0;
177     REAL w, h;
178     ImageCodecInfo *codecs;
179     static const WCHAR filename[] = { 'a','.','b','m','p',0 };
180
181     codecs = NULL;
182
183     stat = GdipSaveImageToFile(0, 0, 0, 0);
184     expect(InvalidParameter, stat);
185
186     bm = NULL;
187     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
188     expect(Ok, stat);
189     if (!bm)
190         return;
191
192     /* invalid params */
193     stat = GdipSaveImageToFile((GpImage*)bm, 0, 0, 0);
194     expect(InvalidParameter, stat);
195
196     stat = GdipSaveImageToFile((GpImage*)bm, filename, 0, 0);
197     expect(InvalidParameter, stat);
198
199     /* encoder tests should succeed -- already tested */
200     stat = GdipGetImageEncodersSize(&n, &s);
201     if (stat != Ok || n == 0) goto cleanup;
202
203     codecs = GdipAlloc(s);
204     if (!codecs) goto cleanup;
205
206     stat = GdipGetImageEncoders(n, s, codecs);
207     if (stat != Ok) goto cleanup;
208
209     stat = GdipSaveImageToFile((GpImage*)bm, filename, &codecs[0].Clsid, 0);
210     expect(stat, Ok);
211
212     GdipDisposeImage((GpImage*)bm);
213     bm = 0;
214
215     /* re-load and check image stats */
216     stat = GdipLoadImageFromFile(filename, (GpImage**)&bm);
217     expect(stat, Ok);
218     if (stat != Ok) goto cleanup;
219
220     stat = GdipGetImageDimension((GpImage*)bm, &w, &h);
221     if (stat != Ok) goto cleanup;
222
223     ok((fabs(w - WIDTH) < 0.01) && (fabs(h - HEIGHT) < 0.01),
224        "Saved image dimensions are different!\n");
225
226  cleanup:
227     GdipFree(codecs);
228     if (bm)
229         GdipDisposeImage((GpImage*)bm);
230     ok(DeleteFileW(filename), "Delete failed.\n");
231 }
232
233 static void test_encoders(void)
234 {
235     GpStatus stat;
236     UINT n;
237     UINT s;
238     ImageCodecInfo *codecs;
239     int i;
240     int bmp_found;
241
242     static const WCHAR bmp_format[] = {'B', 'M', 'P', 0};
243
244     stat = GdipGetImageEncodersSize(&n, &s);
245     expect(stat, Ok);
246
247     codecs = GdipAlloc(s);
248     if (!codecs)
249         return;
250
251     stat = GdipGetImageEncoders(n, s, NULL);
252     expect(GenericError, stat);
253
254     stat = GdipGetImageEncoders(0, s, codecs);
255     expect(GenericError, stat);
256
257     stat = GdipGetImageEncoders(n, s-1, codecs);
258     expect(GenericError, stat);
259
260     stat = GdipGetImageEncoders(n, s+1, codecs);
261     expect(GenericError, stat);
262
263     stat = GdipGetImageEncoders(n, s, codecs);
264     expect(stat, Ok);
265
266     bmp_found = FALSE;
267     for (i = 0; i < n; i++)
268         {
269             if (CompareStringW(LOCALE_SYSTEM_DEFAULT, 0,
270                                codecs[i].FormatDescription, -1,
271                                bmp_format, -1) == CSTR_EQUAL) {
272                 bmp_found = TRUE;
273                 break;
274             }
275         }
276     if (!bmp_found)
277         ok(FALSE, "No BMP codec found.\n");
278
279     GdipFree(codecs);
280 }
281
282 static void test_LockBits(void)
283 {
284     GpStatus stat;
285     GpBitmap *bm;
286     GpRect rect;
287     BitmapData bd;
288     const INT WIDTH = 10, HEIGHT = 20;
289
290     bm = NULL;
291     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
292     expect(Ok, stat);
293
294     rect.X = 2;
295     rect.Y = 3;
296     rect.Width = 4;
297     rect.Height = 5;
298
299     /* read-only */
300     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
301     expect(Ok, stat);
302
303     if (stat == Ok) {
304         stat = GdipBitmapUnlockBits(bm, &bd);
305         expect(Ok, stat);
306     }
307
308     /* read-only, with NULL rect -> whole bitmap lock */
309     stat = GdipBitmapLockBits(bm, NULL, ImageLockModeRead, PixelFormat24bppRGB, &bd);
310     expect(Ok, stat);
311     expect(bd.Width,  WIDTH);
312     expect(bd.Height, HEIGHT);
313
314     if (stat == Ok) {
315         stat = GdipBitmapUnlockBits(bm, &bd);
316         expect(Ok, stat);
317     }
318
319     /* read-only, consecutive */
320     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
321     expect(Ok, stat);
322
323     if (stat == Ok) {
324         stat = GdipBitmapUnlockBits(bm, &bd);
325         expect(Ok, stat);
326     }
327
328     stat = GdipDisposeImage((GpImage*)bm);
329     expect(Ok, stat);
330     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
331     expect(Ok, stat);
332
333     /* read x2 */
334     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
335     expect(Ok, stat);
336     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
337     expect(WrongState, stat);
338
339     stat = GdipBitmapUnlockBits(bm, &bd);
340     expect(Ok, stat);
341
342     stat = GdipDisposeImage((GpImage*)bm);
343     expect(Ok, stat);
344     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
345     expect(Ok, stat);
346
347     /* write, no modification */
348     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
349     expect(Ok, stat);
350
351     if (stat == Ok) {
352         stat = GdipBitmapUnlockBits(bm, &bd);
353         expect(Ok, stat);
354     }
355
356     /* write, consecutive */
357     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
358     expect(Ok, stat);
359
360     if (stat == Ok) {
361         stat = GdipBitmapUnlockBits(bm, &bd);
362         expect(Ok, stat);
363     }
364
365     stat = GdipDisposeImage((GpImage*)bm);
366     expect(Ok, stat);
367     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
368     expect(Ok, stat);
369
370     /* write, modify */
371     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeWrite, PixelFormat24bppRGB, &bd);
372     expect(Ok, stat);
373
374     if (stat == Ok) {
375         if (bd.Scan0)
376             ((char*)bd.Scan0)[2] = 0xff;
377
378         stat = GdipBitmapUnlockBits(bm, &bd);
379         expect(Ok, stat);
380     }
381
382     stat = GdipDisposeImage((GpImage*)bm);
383     expect(Ok, stat);
384
385     /* dispose locked */
386     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
387     expect(Ok, stat);
388     stat = GdipBitmapLockBits(bm, &rect, ImageLockModeRead, PixelFormat24bppRGB, &bd);
389     expect(Ok, stat);
390     stat = GdipDisposeImage((GpImage*)bm);
391     expect(Ok, stat);
392 }
393
394 static void test_GdipCreateBitmapFromHBITMAP(void)
395 {
396     GpBitmap* gpbm = NULL;
397     HBITMAP hbm = NULL;
398     HPALETTE hpal = NULL;
399     GpStatus stat;
400     BYTE buff[1000];
401     LOGPALETTE* LogPal = NULL;
402     REAL width, height;
403     const REAL WIDTH1 = 5;
404     const REAL HEIGHT1 = 15;
405     const REAL WIDTH2 = 10;
406     const REAL HEIGHT2 = 20;
407     HDC hdc;
408     BITMAPINFO bmi;
409
410     stat = GdipCreateBitmapFromHBITMAP(NULL, NULL, NULL);
411     expect(InvalidParameter, stat);
412
413     hbm = CreateBitmap(WIDTH1, HEIGHT1, 1, 1, NULL);
414     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, NULL);
415     expect(InvalidParameter, stat);
416
417     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
418     expect(Ok, stat);
419     expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
420     ok(fabs(WIDTH1 - width) < .0001, "width wrong\n");
421     ok(fabs(HEIGHT1 - height) < .0001, "height wrong\n");
422     if (stat == Ok)
423         GdipDisposeImage((GpImage*)gpbm);
424     GlobalFree(hbm);
425
426     hbm = CreateBitmap(WIDTH2, HEIGHT2, 1, 1, &buff);
427     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
428     expect(Ok, stat);
429     expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
430     ok(fabs(WIDTH2 - width) < .0001, "width wrong\n");
431     ok(fabs(HEIGHT2 - height) < .0001, "height wrong\n");
432     if (stat == Ok)
433         GdipDisposeImage((GpImage*)gpbm);
434     GlobalFree(hbm);
435
436     hdc = CreateCompatibleDC(0);
437     ok(hdc != NULL, "CreateCompatibleDC failed\n");
438     bmi.bmiHeader.biSize = sizeof(bmi.bmiHeader);
439     bmi.bmiHeader.biHeight = HEIGHT1;
440     bmi.bmiHeader.biWidth = WIDTH1;
441     bmi.bmiHeader.biBitCount = 24;
442     bmi.bmiHeader.biPlanes = 1;
443     bmi.bmiHeader.biCompression = BI_RGB;
444
445     hbm = CreateDIBSection(hdc, &bmi, DIB_RGB_COLORS, NULL, NULL, 0);
446     ok(hbm != NULL, "CreateDIBSection failed\n");
447
448     stat = GdipCreateBitmapFromHBITMAP(hbm, NULL, &gpbm);
449     expect(Ok, stat);
450     expect(Ok, GdipGetImageDimension((GpImage*) gpbm, &width, &height));
451     ok(fabs(WIDTH1 - width) < .0001, "width wrong\n");
452     ok(fabs(HEIGHT1 - height) < .0001, "height wrong\n");
453     if (stat == Ok)
454         GdipDisposeImage((GpImage*)gpbm);
455
456     LogPal = GdipAlloc(sizeof(LOGPALETTE));
457     ok(LogPal != NULL, "unable to allocate LOGPALETTE\n");
458     LogPal->palVersion = 0x300;
459     hpal = CreatePalette(LogPal);
460     ok(hpal != NULL, "CreatePalette failed\n");
461     GdipFree(LogPal);
462
463     stat = GdipCreateBitmapFromHBITMAP(hbm, hpal, &gpbm);
464     todo_wine
465     {
466         expect(Ok, stat);
467     }
468     if (stat == Ok)
469         GdipDisposeImage((GpImage*)gpbm);
470
471     GlobalFree(hpal);
472     GlobalFree(hbm);
473 }
474
475 static void test_GdipGetImageFlags(void)
476 {
477     GpImage *img;
478     GpStatus stat;
479     UINT flags;
480
481     img = (GpImage*)0xdeadbeef;
482
483     stat = GdipGetImageFlags(NULL, NULL);
484     expect(InvalidParameter, stat);
485
486     stat = GdipGetImageFlags(NULL, &flags);
487     expect(InvalidParameter, stat);
488
489     stat = GdipGetImageFlags(img, NULL);
490     expect(InvalidParameter, stat);
491 }
492
493 static void test_GdipCloneImage(void)
494 {
495     GpStatus stat;
496     GpRectF rectF;
497     GpUnit unit;
498     GpBitmap *bm;
499     GpImage *image_src, *image_dest = NULL;
500     const INT WIDTH = 10, HEIGHT = 20;
501
502     /* Create an image, clone it, delete the original, make sure the copy works */
503     stat = GdipCreateBitmapFromScan0(WIDTH, HEIGHT, 0, PixelFormat24bppRGB, NULL, &bm);
504     expect(Ok, stat);
505
506     image_src = ((GpImage*)bm);
507     stat = GdipCloneImage(image_src, &image_dest);
508     expect(Ok, stat);
509
510     stat = GdipDisposeImage((GpImage*)bm);
511     expect(Ok, stat);
512     stat = GdipGetImageBounds(image_dest, &rectF, &unit);
513     expect(Ok, stat);
514
515     /* Treat FP values carefully */
516     ok(fabsf(rectF.Width-WIDTH)<1e-5, "Expected: %d, got %.05f\n", WIDTH, rectF.Width);
517     ok(fabsf(rectF.Height-HEIGHT)<1e-5, "Expected: %d, got %.05f\n", HEIGHT, rectF.Height);
518
519     stat = GdipDisposeImage(image_dest);
520     expect(Ok, stat);
521 }
522
523 static void test_testcontrol(void)
524 {
525     GpStatus stat;
526     DWORD param;
527
528     param = 0;
529     stat = GdipTestControl(TestControlGetBuildNumber, &param);
530     expect(Ok, stat);
531     ok(param != 0, "Build number expected, got %u\n", param);
532 }
533
534 static void test_fromhicon(void)
535 {
536     static const BYTE bmp_bits[1024];
537     HBITMAP hbmMask, hbmColor;
538     ICONINFO info;
539     HICON hIcon;
540     GpStatus stat;
541     GpBitmap *bitmap = NULL;
542     UINT dim;
543     ImageType type;
544     PixelFormat format;
545     GUID raw;
546     WCHAR bufferW[39];
547     char buffer[39];
548     char buffer2[39];
549
550     /* NULL */
551     stat = GdipCreateBitmapFromHICON(NULL, NULL);
552     expect(InvalidParameter, stat);
553     stat = GdipCreateBitmapFromHICON(NULL, &bitmap);
554     expect(InvalidParameter, stat);
555
556     /* color icon 1 bit */
557     hbmMask = CreateBitmap(16, 16, 1, 1, bmp_bits);
558     ok(hbmMask != 0, "CreateBitmap failed\n");
559     hbmColor = CreateBitmap(16, 16, 1, 1, bmp_bits);
560     ok(hbmColor != 0, "CreateBitmap failed\n");
561     info.fIcon = TRUE;
562     info.xHotspot = 8;
563     info.yHotspot = 8;
564     info.hbmMask = hbmMask;
565     info.hbmColor = hbmColor;
566     hIcon = CreateIconIndirect(&info);
567     ok(hIcon != 0, "CreateIconIndirect failed\n");
568     DeleteObject(hbmMask);
569     DeleteObject(hbmColor);
570
571     stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
572     expect(Ok, stat);
573     if(stat == Ok){
574        /* check attributes */
575        stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
576        expect(Ok, stat);
577        expect(16, dim);
578        stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
579        expect(Ok, stat);
580        expect(16, dim);
581        stat = GdipGetImageType((GpImage*)bitmap, &type);
582        expect(Ok, stat);
583        expect(ImageTypeBitmap, type);
584        stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
585        expect(PixelFormat32bppARGB, format);
586        /* raw format */
587        stat = GdipGetImageRawFormat((GpImage*)bitmap, &raw);
588        StringFromGUID2(&raw, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
589        WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer, sizeof(buffer), NULL, NULL);
590        StringFromGUID2(&ImageFormatMemoryBMP, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
591        WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer2, sizeof(buffer2), NULL, NULL);
592        todo_wine ok(IsEqualGUID(&raw, &ImageFormatMemoryBMP), "Expected format %s, got %s\n", buffer2, buffer);
593        GdipDisposeImage((GpImage*)bitmap);
594     }
595     DestroyIcon(hIcon);
596
597     /* color icon 8 bpp */
598     hbmMask = CreateBitmap(16, 16, 1, 8, bmp_bits);
599     ok(hbmMask != 0, "CreateBitmap failed\n");
600     hbmColor = CreateBitmap(16, 16, 1, 8, bmp_bits);
601     ok(hbmColor != 0, "CreateBitmap failed\n");
602     info.fIcon = TRUE;
603     info.xHotspot = 8;
604     info.yHotspot = 8;
605     info.hbmMask = hbmMask;
606     info.hbmColor = hbmColor;
607     hIcon = CreateIconIndirect(&info);
608     ok(hIcon != 0, "CreateIconIndirect failed\n");
609     DeleteObject(hbmMask);
610     DeleteObject(hbmColor);
611
612     stat = GdipCreateBitmapFromHICON(hIcon, &bitmap);
613     expect(Ok, stat);
614     if(stat == Ok){
615         /* check attributes */
616         stat = GdipGetImageHeight((GpImage*)bitmap, &dim);
617         expect(Ok, stat);
618         expect(16, dim);
619         stat = GdipGetImageWidth((GpImage*)bitmap, &dim);
620         expect(Ok, stat);
621         expect(16, dim);
622         stat = GdipGetImageType((GpImage*)bitmap, &type);
623         expect(Ok, stat);
624         expect(ImageTypeBitmap, type);
625         stat = GdipGetImagePixelFormat((GpImage*)bitmap, &format);
626         expect(PixelFormat32bppARGB, format);
627         /* raw format */
628         stat = GdipGetImageRawFormat((GpImage*)bitmap, &raw);
629         StringFromGUID2(&raw, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
630         WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer, sizeof(buffer), NULL, NULL);
631         StringFromGUID2(&ImageFormatMemoryBMP, bufferW, sizeof(bufferW)/sizeof(bufferW[0]));
632         WideCharToMultiByte(CP_ACP, 0, bufferW, sizeof(bufferW)/sizeof(bufferW[0]), buffer2, sizeof(buffer2), NULL, NULL);
633         todo_wine ok(IsEqualGUID(&raw, &ImageFormatMemoryBMP), "Expected format %s, got %s\n", buffer2, buffer);
634         GdipDisposeImage((GpImage*)bitmap);
635     }
636     DestroyIcon(hIcon);
637 }
638
639 START_TEST(image)
640 {
641     struct GdiplusStartupInput gdiplusStartupInput;
642     ULONG_PTR gdiplusToken;
643
644     gdiplusStartupInput.GdiplusVersion              = 1;
645     gdiplusStartupInput.DebugEventCallback          = NULL;
646     gdiplusStartupInput.SuppressBackgroundThread    = 0;
647     gdiplusStartupInput.SuppressExternalCodecs      = 0;
648
649     GdiplusStartup(&gdiplusToken, &gdiplusStartupInput, NULL);
650
651     test_Scan0();
652     test_GetImageDimension();
653     test_GdipImageGetFrameDimensionsCount();
654     test_LoadingImages();
655     test_SavingImages();
656     test_encoders();
657     test_LockBits();
658     test_GdipCreateBitmapFromHBITMAP();
659     test_GdipGetImageFlags();
660     test_GdipCloneImage();
661     test_testcontrol();
662     test_fromhicon();
663
664     GdiplusShutdown(gdiplusToken);
665 }