ReactOS  r76032
SetDIBitsToDevice.c
Go to the documentation of this file.
1 /*
2  * PROJECT: ReactOS api tests
3  * LICENSE: GPL - See COPYING in the top level directory
4  * PURPOSE: Test for SetDIBitsToDevice
5  * PROGRAMMERS: Timo Kreuzer
6  */
7 
8 #include <apitest.h>
9 
10 #include <wingdi.h>
11 #include "init.h"
12 
13 static void
15 {
16  UCHAR ajBmiBuffer[sizeof(BITMAPINFO) + 4];
17  PBITMAPINFO pbmi = (PBITMAPINFO)ajBmiBuffer;
18  ULONG aulBits[16];
19  INT ret;
20 
21  /* Setup the bitmap info */
22  pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
23  pbmi->bmiHeader.biWidth = 2;
24  pbmi->bmiHeader.biHeight = -4;
25  pbmi->bmiHeader.biPlanes = 1;
26  pbmi->bmiHeader.biBitCount = 32;
27  pbmi->bmiHeader.biCompression = BI_RGB;
28  pbmi->bmiHeader.biSizeImage = 0;
29  pbmi->bmiHeader.biXPelsPerMeter = 0;
30  pbmi->bmiHeader.biYPelsPerMeter = 0;
31  pbmi->bmiHeader.biClrUsed = 0;
32  pbmi->bmiHeader.biClrImportant = 0;
33 
34  /* Test a normal operation */
35  SetLastError(0xdeadc0de);
37  0, // XDest,
38  0, // YDest,
39  2, // dwWidth,
40  2, // dwHeight,
41  0, // XSrc,
42  0, // YSrc,
43  0, // uStartScan,
44  2, // cScanLines,
45  aulBits, // lpvBits,
46  pbmi,
48  ok_dec(ret, 2);
49  ok_err(0xdeadc0de);
50 
51  /* Test hdc == NULL */
52  SetLastError(0xdeadc0de);
53  ret = SetDIBitsToDevice(NULL,
54  0, // XDest,
55  0, // YDest,
56  2, // dwWidth,
57  2, // dwHeight,
58  0, // XSrc,
59  0, // YSrc,
60  0, // uStartScan,
61  2, // cScanLines,
62  aulBits, // lpvBits,
63  pbmi,
65  ok_dec(ret, 0);
67 
68  /* Test truncated hdc */
69  SetLastError(0xdeadc0de);
70  ret = SetDIBitsToDevice((HDC)((ULONG_PTR)ghdcDIB32 & 0xFFFF),
71  0, // XDest,
72  0, // YDest,
73  2, // dwWidth,
74  2, // dwHeight,
75  0, // XSrc,
76  0, // YSrc,
77  0, // uStartScan,
78  2, // cScanLines,
79  aulBits, // lpvBits,
80  pbmi,
82  ok_dec(ret, 0);
84 
85  /* Test invalid ColorUse */
86  SetLastError(0xdeadc0de);
88  0, // XDest,
89  0, // YDest,
90  2, // dwWidth,
91  2, // dwHeight,
92  0, // XSrc,
93  0, // YSrc,
94  0, // uStartScan,
95  2, // cScanLines,
96  aulBits, // lpvBits,
97  pbmi,
98  7);
99  ok_dec(ret, 0);
100  ok_err(0xdeadc0de);
101 
102  /* test unaligned buffer */
103  SetLastError(0xdeadc0de);
105  0, // XDest,
106  0, // YDest,
107  2, // dwWidth,
108  2, // dwHeight,
109  0, // XSrc,
110  0, // YSrc,
111  0, // uStartScan,
112  2, // cScanLines,
113  (BYTE*)aulBits + 1, // lpvBits,
114  pbmi,
116  ok_dec(ret, 2);
117  ok_err(0xdeadc0de);
118 
119  /* test unaligned and huge scanline buffer */
120  SetLastError(0xdeadc0de);
122  0, // XDest,
123  0, // YDest,
124  2, // dwWidth,
125  2, // dwHeight,
126  0, // XSrc,
127  0, // YSrc,
128  0, // uStartScan,
129  20000000, // cScanLines,
130  (BYTE*)aulBits + 1, // lpvBits,
131  pbmi,
133  todo_ros ok_dec(ret, 0);
134  ok_err(0xdeadc0de);
135 
136  /* test unaligned illegal buffer */
137  SetLastError(0xdeadc0de);
139  0, // XDest,
140  0, // YDest,
141  2, // dwWidth,
142  2, // dwHeight,
143  0, // XSrc,
144  0, // YSrc,
145  0, // uStartScan,
146  2, // cScanLines,
147  (BYTE*)0x7fffffff, // lpvBits,
148  pbmi,
150  todo_ros ok_dec(ret, 0);
151  ok_err(0xdeadc0de);
152 
153  /* Test negative XDest */
154  SetLastError(0xdeadc0de);
156  -100, // XDest,
157  0, // YDest,
158  2, // dwWidth,
159  2, // dwHeight,
160  0, // XSrc,
161  0, // YSrc,
162  0, // uStartScan,
163  2, // cScanLines,
164  aulBits, // lpvBits,
165  pbmi,
167  ok_dec(ret, 2);
168  ok_err(0xdeadc0de);
169 
170  /* Test huge XDest */
171  SetLastError(0xdeadc0de);
173  LONG_MAX, // XDest,
174  0, // YDest,
175  2, // dwWidth,
176  2, // dwHeight,
177  0, // XSrc,
178  0, // YSrc,
179  0, // uStartScan,
180  2, // cScanLines,
181  aulBits, // lpvBits,
182  pbmi,
184  ok_dec(ret, 2);
185  ok_err(0xdeadc0de);
186 
187  /* Test XSrc outside of the DIB */
188  SetLastError(0xdeadc0de);
190  0, // XDest,
191  0, // YDest,
192  2, // dwWidth,
193  2, // dwHeight,
194  100, // XSrc,
195  0, // YSrc,
196  0, // uStartScan,
197  2, // cScanLines,
198  aulBits, // lpvBits,
199  pbmi,
201  ok_dec(ret, 2);
202  ok_err(0xdeadc0de);
203 
204  /* Test YSrc outside of the DIB */
205  SetLastError(0xdeadc0de);
207  0, // XDest,
208  0, // YDest,
209  2, // dwWidth,
210  2, // dwHeight,
211  0, // XSrc,
212  100, // YSrc,
213  0, // uStartScan,
214  2, // cScanLines,
215  aulBits, // lpvBits,
216  pbmi,
218  ok_dec(ret, 2);
219  ok_err(0xdeadc0de);
220 
221  /* Test uStartScan outside of the DIB */
222  SetLastError(0xdeadc0de);
224  0, // XDest,
225  0, // YDest,
226  2, // dwWidth,
227  2, // dwHeight,
228  0, // XSrc,
229  0, // YSrc,
230  100, // uStartScan,
231  5, // cScanLines,
232  aulBits, // lpvBits,
233  pbmi,
235  ok_dec(ret, 5);
236  ok_err(0xdeadc0de);
237 
238  /* Test cScanLines larger than the DIB */
239  SetLastError(0xdeadc0de);
241  0, // XDest,
242  0, // YDest,
243  2, // dwWidth,
244  2, // dwHeight,
245  0, // XSrc,
246  0, // YSrc,
247  0, // uStartScan,
248  7, // cScanLines,
249  aulBits, // lpvBits,
250  pbmi,
252  todo_ros ok_dec(ret, 7);
253  ok_err(0xdeadc0de);
254 
255  /* Test large cScanlines */
256  SetLastError(0xdeadc0de);
258  0, // XDest,
259  0, // YDest,
260  2, // dwWidth,
261  2, // dwHeight,
262  0, // XSrc,
263  0, // YSrc,
264  0, // uStartScan,
265  2000, // cScanLines,
266  aulBits, // lpvBits,
267  pbmi,
269  todo_ros ok_dec(ret, 0);
270  ok_err(0xdeadc0de);
271 
272  /* Test uStartScan and cScanLines larger than the DIB */
273  SetLastError(0xdeadc0de);
275  0, // XDest,
276  0, // YDest,
277  2, // dwWidth,
278  2, // dwHeight,
279  0, // XSrc,
280  0, // YSrc,
281  100, // uStartScan,
282  7, // cScanLines,
283  aulBits, // lpvBits,
284  pbmi,
286  ok_dec(ret, 7);
287  ok_err(0xdeadc0de);
288 
289  /* Test lpvBits == NULL */
290  SetLastError(0xdeadc0de);
292  0, // XDest,
293  0, // YDest,
294  2, // dwWidth,
295  2, // dwHeight,
296  0, // XSrc,
297  0, // YSrc,
298  0, // uStartScan,
299  2, // cScanLines,
300  NULL, // lpvBits,
301  pbmi,
303  ok_dec(ret, 0);
304  ok_err(0xdeadc0de);
305 
306  /* Test pbmi == NULL */
307  SetLastError(0xdeadc0de);
309  0, // XDest,
310  0, // YDest,
311  2, // dwWidth,
312  2, // dwHeight,
313  0, // XSrc,
314  0, // YSrc,
315  0, // uStartScan,
316  2, // cScanLines,
317  aulBits, // lpvBits,
318  NULL,
320  ok_dec(ret, 0);
321  ok_err(0xdeadc0de);
322 
323  /* Test huge positive DIB height, result is limited to dwHeight */
324  pbmi->bmiHeader.biHeight = 10000;
325  SetLastError(0xdeadc0de);
327  0, // XDest,
328  1, // YDest,
329  2, // dwWidth,
330  3, // dwHeight,
331  0, // XSrc,
332  1, // YSrc,
333  0, // uStartScan,
334  7, // cScanLines,
335  aulBits, // lpvBits,
336  pbmi,
338  ok_dec(ret, 4);
339  ok_err(0xdeadc0de);
340 
341  /* Test huge negative DIB height */
342  pbmi->bmiHeader.biHeight = -10000;
343  SetLastError(0xdeadc0de);
345  0, // XDest,
346  0, // YDest,
347  2, // dwWidth,
348  2, // dwHeight,
349  0, // XSrc,
350  0, // YSrc,
351  0, // uStartScan,
352  7, // cScanLines,
353  aulBits, // lpvBits,
354  pbmi,
356  ok_dec(ret, 7);
357  ok_err(0xdeadc0de);
358 
359  /* Test what happens when we cause an integer overflow */
360  pbmi->bmiHeader.biHeight = LONG_MIN;
361  SetLastError(0xdeadc0de);
363  0, // XDest,
364  0, // YDest,
365  2, // dwWidth,
366  2, // dwHeight,
367  0, // XSrc,
368  0, // YSrc,
369  0, // uStartScan,
370  2, // cScanLines,
371  aulBits, // lpvBits,
372  pbmi,
374  ok_dec(ret, 2);
375  ok_err(0xdeadc0de);
376 
377  /* Now also test a huge value of uStartScan */
378  SetLastError(0xdeadc0de);
380  0, // XDest,
381  0, // YDest,
382  2, // dwWidth,
383  2, // dwHeight,
384  0, // XSrc,
385  0, // YSrc,
386  abs(pbmi->bmiHeader.biHeight) - 3, // uStartScan,
387  9, // cScanLines,
388  aulBits, // lpvBits,
389  pbmi,
391  ok_dec(ret, 3);
392  ok_err(0xdeadc0de);
393 
394  /* Now also test a huge value of uStartScan */
395  pbmi->bmiHeader.biHeight = LONG_MIN + 1;
396  SetLastError(0xdeadc0de);
398  0, // XDest,
399  0, // YDest,
400  2, // dwWidth,
401  2, // dwHeight,
402  0, // XSrc,
403  0, // YSrc,
404  abs(pbmi->bmiHeader.biHeight) - 3, // uStartScan,
405  9, // cScanLines,
406  aulBits, // lpvBits,
407  pbmi,
409  ok_dec(ret, 5);
410  ok_err(0xdeadc0de);
411 
412  /* Now also test a huge value of uStartScan */
413  pbmi->bmiHeader.biHeight = LONG_MIN + 7;
414  SetLastError(0xdeadc0de);
416  0, // XDest,
417  0, // YDest,
418  2, // dwWidth,
419  2, // dwHeight,
420  0, // XSrc,
421  0, // YSrc,
422  abs(pbmi->bmiHeader.biHeight) - 3, // uStartScan,
423  32, // cScanLines,
424  aulBits, // lpvBits,
425  pbmi,
427  ok_dec(ret, 17);
428  ok_err(0xdeadc0de);
429 
430  /* Test invalid bitmap info header */
431  pbmi->bmiHeader.biSize = 0;
432  SetLastError(0xdeadc0de);
434  0, // XDest,
435  0, // YDest,
436  2, // dwWidth,
437  2, // dwHeight,
438  0, // XSrc,
439  0, // YSrc,
440  0, // uStartScan,
441  2, // cScanLines,
442  aulBits, // lpvBits,
443  pbmi,
445  ok_dec(ret, 0);
446  ok_err(0xdeadc0de);
447 
448 }
449 
450 
451 static void
453 {
454  UCHAR ajBmiBuffer[sizeof(BITMAPINFO) + 4];
455  PBITMAPINFO pbmi = (PBITMAPINFO)ajBmiBuffer;
456  ULONG aulBits[16];
457  INT ret;
458 
459  /* Setup the bitmap info */
460  pbmi->bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
461  pbmi->bmiHeader.biWidth = 2;
462  pbmi->bmiHeader.biHeight = -2;
463  pbmi->bmiHeader.biPlanes = 1;
464  pbmi->bmiHeader.biBitCount = 32;
465  pbmi->bmiHeader.biCompression = BI_RGB;
466  pbmi->bmiHeader.biSizeImage = 0;
467  pbmi->bmiHeader.biXPelsPerMeter = 0;
468  pbmi->bmiHeader.biYPelsPerMeter = 0;
469  pbmi->bmiHeader.biClrUsed = 0;
470  pbmi->bmiHeader.biClrImportant = 0;
471 
472  /* Set pixels */
473  aulBits[0] = 0x11000000;
474  aulBits[1] = 0x00000011;
475  aulBits[2] = 0xFF000000;
476  aulBits[3] = 0x000000FF;
477 
478 
479  memset(gpDIB32, 0, sizeof(*gpDIB32));
481  0, // XDest,
482  0, // YDest,
483  2, // dwWidth,
484  2, // dwHeight,
485  0, // XSrc,
486  0, // YSrc,
487  0, // uStartScan,
488  2, // cScanLines,
489  aulBits, // lpvBits,
490  pbmi,
492 
493  ok_dec(ret, 2);
494  ok_hex((*gpDIB32)[0][0], 0x11000000);
495  ok_hex((*gpDIB32)[0][1], 0x00000011);
496  ok_hex((*gpDIB32)[0][2], 0x00000000);
497  ok_hex((*gpDIB32)[0][3], 0x00000000);
498  ok_hex((*gpDIB32)[1][0], 0xFF000000);
499  ok_hex((*gpDIB32)[1][1], 0x000000FF);
500  ok_hex((*gpDIB32)[1][2], 0x00000000);
501  ok_hex((*gpDIB32)[1][3], 0x00000000);
502 
503  memset(gpDIB32, 0, sizeof(*gpDIB32));
505  0, // XDest,
506  1, // YDest,
507  2, // dwWidth,
508  2, // dwHeight,
509  0, // XSrc,
510  0, // YSrc,
511  0, // uStartScan,
512  2, // cScanLines,
513  aulBits, // lpvBits,
514  pbmi,
516 
517  ok_dec(ret, 2);
518  ok_hex((*gpDIB32)[0][0], 0x00000000);
519  ok_hex((*gpDIB32)[0][1], 0x00000000);
520  ok_hex((*gpDIB32)[0][2], 0x00000000);
521  ok_hex((*gpDIB32)[0][3], 0x00000000);
522  ok_hex((*gpDIB32)[1][0], 0x11000000);
523  ok_hex((*gpDIB32)[1][1], 0x00000011);
524  ok_hex((*gpDIB32)[1][2], 0x00000000);
525  ok_hex((*gpDIB32)[1][3], 0x00000000);
526  ok_hex((*gpDIB32)[2][0], 0xFF000000);
527  ok_hex((*gpDIB32)[2][1], 0x000000FF);
528  ok_hex((*gpDIB32)[2][2], 0x00000000);
529  ok_hex((*gpDIB32)[2][3], 0x00000000);
530 
531  memset(gpDIB32, 0, sizeof(*gpDIB32));
533  0, // XDest,
534  0, // YDest,
535  2, // dwWidth,
536  2, // dwHeight,
537  0, // XSrc,
538  0, // YSrc,
539  0, // uStartScan,
540  1, // cScanLines,
541  aulBits, // lpvBits,
542  pbmi,
544 
545  ok_dec(ret, 1);
546  todo_ros ok_hex((*gpDIB32)[0][0], 0x00000000);
547  todo_ros ok_hex((*gpDIB32)[0][1], 0x00000000);
548  ok_hex((*gpDIB32)[0][2], 0x00000000);
549  ok_hex((*gpDIB32)[0][3], 0x00000000);
550  todo_ros ok_hex((*gpDIB32)[1][0], 0x11000000);
551  todo_ros ok_hex((*gpDIB32)[1][1], 0x00000011);
552  ok_hex((*gpDIB32)[1][2], 0x00000000);
553  ok_hex((*gpDIB32)[1][3], 0x00000000);
554 #if 0
555 
556  memset(gpDIB32, 0, sizeof(*gpDIB32));
558  0, // XDest,
559  0, // YDest,
560  2, // dwWidth,
561  2, // dwHeight,
562  0, // XSrc,
563  0, // YSrc,
564  1, // uStartScan,
565  1, // cScanLines,
566  aulBits, // lpvBits,
567  pbmi,
569 
570  ok_dec(ret, 1);
571  todo_ros ok_hex(pulDIB32Bits[0], 0x11000000);
572  todo_ros ok_hex(pulDIB32Bits[1], 0x00000011);
573  ok_hex(pulDIB32Bits[2], 0x00000000);
574  ok_hex(pulDIB32Bits[3], 0x00000000);
575  todo_ros ok_hex(pulDIB32Bits[4], 0x00000000);
576  todo_ros ok_hex(pulDIB32Bits[5], 0x00000000);
577  ok_hex(pulDIB32Bits[6], 0x00000000);
578  ok_hex(pulDIB32Bits[7], 0x00000000);
579 
580  /*****************/
581 
582  /* Use bottom-up bitmap */
583  pbmi->bmiHeader.biHeight = 2;
584 
585  memset(gpDIB32, 0, sizeof(*gpDIB32));
587  0, // XDest,
588  0, // YDest,
589  2, // dwWidth,
590  2, // dwHeight,
591  0, // XSrc,
592  0, // YSrc,
593  0, // uStartScan,
594  2, // cScanLines,
595  aulBits, // lpvBits,
596  pbmi,
598 
599  ok_dec(ret, 2);
600  ok_hex(pulDIB32Bits[0], 0xFF000000);
601  ok_hex(pulDIB32Bits[1], 0x000000FF);
602  ok_hex(pulDIB32Bits[2], 0x00000000);
603  ok_hex(pulDIB32Bits[3], 0x00000000);
604  ok_hex(pulDIB32Bits[4], 0x11000000);
605  ok_hex(pulDIB32Bits[5], 0x00000011);
606  ok_hex(pulDIB32Bits[6], 0x00000000);
607  ok_hex(pulDIB32Bits[7], 0x00000000);
608 
609  memset(gpDIB32, 0, sizeof(*gpDIB32));
611  0, // XDest,
612  1, // YDest,
613  2, // dwWidth,
614  2, // dwHeight,
615  0, // XSrc,
616  0, // YSrc,
617  0, // uStartScan,
618  2, // cScanLines,
619  aulBits, // lpvBits,
620  pbmi,
622 
623  ok_dec(ret, 2);
624  ok_hex(pulDIB32Bits[0], 0x00000000);
625  ok_hex(pulDIB32Bits[1], 0x00000000);
626  ok_hex(pulDIB32Bits[2], 0x00000000);
627  ok_hex(pulDIB32Bits[3], 0x00000000);
628  ok_hex(pulDIB32Bits[4], 0xFF000000);
629  ok_hex(pulDIB32Bits[5], 0x000000FF);
630  ok_hex(pulDIB32Bits[6], 0x00000000);
631  ok_hex(pulDIB32Bits[7], 0x00000000);
632  ok_hex(pulDIB32Bits[8], 0x11000000);
633  ok_hex(pulDIB32Bits[9], 0x00000011);
634  ok_hex(pulDIB32Bits[10], 0x00000000);
635  ok_hex(pulDIB32Bits[11], 0x00000000);
636 
637  memset(gpDIB32, 0, sizeof(*gpDIB32));
639  0, // XDest,
640  0, // YDest,
641  2, // dwWidth,
642  2, // dwHeight,
643  0, // XSrc,
644  0, // YSrc,
645  0, // uStartScan,
646  1, // cScanLines,
647  aulBits, // lpvBits,
648  pbmi,
650 
651  ok_dec(ret, 1);
652  todo_ros ok_hex(pulDIB32Bits[0], 0x00000000);
653  todo_ros ok_hex(pulDIB32Bits[1], 0x00000000);
654  ok_hex(pulDIB32Bits[2], 0x00000000);
655  ok_hex(pulDIB32Bits[3], 0x00000000);
656  todo_ros ok_hex(pulDIB32Bits[4], 0x11000000);
657  todo_ros ok_hex(pulDIB32Bits[5], 0x00000011);
658  ok_hex(pulDIB32Bits[6], 0x00000000);
659  ok_hex(pulDIB32Bits[7], 0x00000000);
660 
661 
662  memset(gpDIB32, 0, sizeof(*gpDIB32));
664  0, // XDest,
665  0, // YDest,
666  2, // dwWidth,
667  2, // dwHeight,
668  0, // XSrc,
669  0, // YSrc,
670  1, // uStartScan,
671  1, // cScanLines,
672  aulBits, // lpvBits,
673  pbmi,
675 
676  ok_dec(ret, 1);
677  todo_ros ok_hex(pulDIB32Bits[0], 0x11000000);
678  todo_ros ok_hex(pulDIB32Bits[1], 0x00000011);
679  ok_hex(pulDIB32Bits[2], 0x00000000);
680  ok_hex(pulDIB32Bits[3], 0x00000000);
681  todo_ros ok_hex(pulDIB32Bits[4], 0x00000000);
682  todo_ros ok_hex(pulDIB32Bits[5], 0x00000000);
683  ok_hex(pulDIB32Bits[6], 0x00000000);
684  ok_hex(pulDIB32Bits[7], 0x00000000);
685 #endif
686 }
687 
688 
690 {
691  InitStuff();
692 
695 
696 
697 }
#define HDC
Definition: msvc.h:22
#define abs(i)
Definition: fconv.c:206
_In_ HBITMAP _In_ UINT _In_ UINT _Inout_ LPBITMAPINFO pbmi
Definition: ntgdi.h:2780
struct tagBITMAPINFOHEADER BITMAPINFOHEADER
START_TEST(SetDIBitsToDevice)
#define ERROR_INVALID_HANDLE
Definition: compat.h:88
#define ok_err(error)
Definition: FindFiles.c:41
int32_t INT
Definition: typedefs.h:56
uint32_t ULONG_PTR
Definition: typedefs.h:63
ULONG(* gpDIB32)[8][8]
Definition: init.c:11
#define ok_dec(expression, result)
Definition: test.h:765
static void Test_SetDIBitsToDevice_Params()
smooth NULL
Definition: ftsmooth.c:557
#define todo_ros
Definition: test.h:148
#define ok_hex(expression, result)
Definition: test.h:758
#define SetLastError(x)
Definition: compat.h:409
BOOL InitStuff(void)
Definition: init.c:96
#define LONG_MAX
Definition: limits.h:43
unsigned char UCHAR
Definition: xmlstorage.h:181
int ret
static void Test_SetDIBitsToDevice()
unsigned char BYTE
Definition: ntddk_ex.h:96
int WINAPI SetDIBitsToDevice(_In_ HDC, _In_ int, _In_ int, _In_ DWORD, _In_ DWORD, _In_ int, _In_ int, _In_ UINT, _In_ UINT, _In_ CONST VOID *, _In_ CONST BITMAPINFO *, _In_ UINT)
unsigned int ULONG
Definition: retypes.h:1
#define LONG_MIN
Definition: limits.h:42
struct tagBITMAPINFO * PBITMAPINFO
HDC ghdcDIB32
Definition: init.c:9
#define DIB_RGB_COLORS
Definition: wingdi.h:365
#define memset(x, y, z)
Definition: compat.h:39
#define BI_RGB
Definition: precomp.h:35
struct tagBITMAPINFO BITMAPINFO