git.oblomov.eu Git - wine/blob - dlls/gdi32/tests/dib.c

   1 /*
   2  * DIB driver tests.
   3  *
   4  * Copyright 2011 Huw Davies
   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 <stdarg.h>
  22 #include <stdio.h>
  23 #include <math.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "wingdi.h"
  28 #include "winuser.h"
  29 #include "wincrypt.h"
  30
  31 #include "wine/test.h"
  32
  33 static HCRYPTPROV crypt_prov;
  34 static DWORD (WINAPI *pSetLayout)(HDC hdc, DWORD layout);
  35
  36 static const DWORD rop3[256] =
  37 {
  38     0x000042, 0x010289, 0x020C89, 0x0300AA, 0x040C88, 0x0500A9, 0x060865, 0x0702C5,
  39     0x080F08, 0x090245, 0x0A0329, 0x0B0B2A, 0x0C0324, 0x0D0B25, 0x0E08A5, 0x0F0001,
  40     0x100C85, 0x1100A6, 0x120868, 0x1302C8, 0x140869, 0x1502C9, 0x165CCA, 0x171D54,
  41     0x180D59, 0x191CC8, 0x1A06C5, 0x1B0768, 0x1C06CA, 0x1D0766, 0x1E01A5, 0x1F0385,
  42     0x200F09, 0x210248, 0x220326, 0x230B24, 0x240D55, 0x251CC5, 0x2606C8, 0x271868,
  43     0x280369, 0x2916CA, 0x2A0CC9, 0x2B1D58, 0x2C0784, 0x2D060A, 0x2E064A, 0x2F0E2A,
  44     0x30032A, 0x310B28, 0x320688, 0x330008, 0x3406C4, 0x351864, 0x3601A8, 0x370388,
  45     0x38078A, 0x390604, 0x3A0644, 0x3B0E24, 0x3C004A, 0x3D18A4, 0x3E1B24, 0x3F00EA,
  46     0x400F0A, 0x410249, 0x420D5D, 0x431CC4, 0x440328, 0x450B29, 0x4606C6, 0x47076A,
  47     0x480368, 0x4916C5, 0x4A0789, 0x4B0605, 0x4C0CC8, 0x4D1954, 0x4E0645, 0x4F0E25,
  48     0x500325, 0x510B26, 0x5206C9, 0x530764, 0x5408A9, 0x550009, 0x5601A9, 0x570389,
  49     0x580785, 0x590609, 0x5A0049, 0x5B18A9, 0x5C0649, 0x5D0E29, 0x5E1B29, 0x5F00E9,
  50     0x600365, 0x6116C6, 0x620786, 0x630608, 0x640788, 0x650606, 0x660046, 0x6718A8,
  51     0x6858A6, 0x690145, 0x6A01E9, 0x6B178A, 0x6C01E8, 0x6D1785, 0x6E1E28, 0x6F0C65,
  52     0x700CC5, 0x711D5C, 0x720648, 0x730E28, 0x740646, 0x750E26, 0x761B28, 0x7700E6,
  53     0x7801E5, 0x791786, 0x7A1E29, 0x7B0C68, 0x7C1E24, 0x7D0C69, 0x7E0955, 0x7F03C9,
  54     0x8003E9, 0x810975, 0x820C49, 0x831E04, 0x840C48, 0x851E05, 0x8617A6, 0x8701C5,
  55     0x8800C6, 0x891B08, 0x8A0E06, 0x8B0666, 0x8C0E08, 0x8D0668, 0x8E1D7C, 0x8F0CE5,
  56     0x900C45, 0x911E08, 0x9217A9, 0x9301C4, 0x9417AA, 0x9501C9, 0x960169, 0x97588A,
  57     0x981888, 0x990066, 0x9A0709, 0x9B07A8, 0x9C0704, 0x9D07A6, 0x9E16E6, 0x9F0345,
  58     0xA000C9, 0xA11B05, 0xA20E09, 0xA30669, 0xA41885, 0xA50065, 0xA60706, 0xA707A5,
  59     0xA803A9, 0xA90189, 0xAA0029, 0xAB0889, 0xAC0744, 0xAD06E9, 0xAE0B06, 0xAF0229,
  60     0xB00E05, 0xB10665, 0xB21974, 0xB30CE8, 0xB4070A, 0xB507A9, 0xB616E9, 0xB70348,
  61     0xB8074A, 0xB906E6, 0xBA0B09, 0xBB0226, 0xBC1CE4, 0xBD0D7D, 0xBE0269, 0xBF08C9,
  62     0xC000CA, 0xC11B04, 0xC21884, 0xC3006A, 0xC40E04, 0xC50664, 0xC60708, 0xC707AA,
  63     0xC803A8, 0xC90184, 0xCA0749, 0xCB06E4, 0xCC0020, 0xCD0888, 0xCE0B08, 0xCF0224,
  64     0xD00E0A, 0xD1066A, 0xD20705, 0xD307A4, 0xD41D78, 0xD50CE9, 0xD616EA, 0xD70349,
  65     0xD80745, 0xD906E8, 0xDA1CE9, 0xDB0D75, 0xDC0B04, 0xDD0228, 0xDE0268, 0xDF08C8,
  66     0xE003A5, 0xE10185, 0xE20746, 0xE306EA, 0xE40748, 0xE506E5, 0xE61CE8, 0xE70D79,
  67     0xE81D74, 0xE95CE6, 0xEA02E9, 0xEB0849, 0xEC02E8, 0xED0848, 0xEE0086, 0xEF0A08,
  68     0xF00021, 0xF10885, 0xF20B05, 0xF3022A, 0xF40B0A, 0xF50225, 0xF60265, 0xF708C5,
  69     0xF802E5, 0xF90845, 0xFA0089, 0xFB0A09, 0xFC008A, 0xFD0A0A, 0xFE02A9, 0xFF0062
  70 };
  71
  72 static inline BOOL rop_uses_src(DWORD rop)
  73 {
  74     return (((rop & 0xcc0000) >> 2) != (rop & 0x330000));
  75 }
  76
  77 static const char *sha1_graphics_a8r8g8b8[] =
  78 {
  79     "a3cadd34d95d3d5cc23344f69aab1c2e55935fcf",
  80     "2426172d9e8fec27d9228088f382ef3c93717da9",
  81     "9e8f27ca952cdba01dbf25d07c34e86a7820c012",
  82     "664fac17803859a4015c6ae29e5538e314d5c827",
  83     "17b2c177bdce5e94433574a928bda5c94a8cdfa5",
  84     "fe6cc678fb13a3ead67839481bf22348adc69f52",
  85     "d51bd330cec510cdccf5394328bd8e5411901e9e",
  86     "df4aebf98d91f11be560dd232123b3ae327303d7",
  87     "f2af53dd073a09b1031d0032d28da35c82adc566",
  88     "eb5a963a6f7b25533ddfb8915e70865d037bd156",
  89     "c387917268455017aa0b28bed73aa6554044bbb3",
  90     "dcae44fee010dbf7a107797a503923fd8b1abe2e",
  91     "6c530622a025d872a642e8f950867884d7b136cb",
  92     "7c07d91b8f68fb31821701b3dcb96de018bf0c66",
  93     "b2261353decda2712b83538ab434a49ce21f3172",
  94     "35f731c0f6356b8f30651bb3cbe0d922c49deba5",
  95     "9b9874c1c1d92afa554137e191d34ea33acc322f",
  96     "c311dd74325e8cebfc8529a6d24a6fa4ecb7137e",
  97     "d7398de15b2837a58a62a701ca1b3384625afec4",
  98     "a78b28472bb7ff480ddedd06b9cf2daa775fa7ae",
  99     "5246ef357e7317b9d141a3294d300c195da76cb7",
 100     "87f6b6a19f021ca5912d285e14ce2ff9474d79f3",
 101     "e2a8eef4aeda3a0f6c950075acba38f1f9e0814d",
 102     "8b66f14d51ecdeea12bc993302bb9b7d3ec085a1",
 103     "7da9dd3d40d44d92deb9883fb7110443c2d5769a",
 104     "e358efb1c11172e40855de620bdb8a8e545cd790",
 105     "9e0c2596c6ecb4f1bc97b18ec3ca493d37626608",
 106     "58806549380c964e7a53ad54821d2eb86fa5b9ce",
 107     "7fc30d3058c235ce39088de0a598b8c7fe7ca61f",
 108     "52a6c769c227f2bb1949097c4c87fed5ee0cbcb1",
 109     "8a010d4c5af51fcc34d51be3197878782bdf63e7",
 110     "c84c2c33e22eb7e5c4a2faad3b3b99a359d77528",
 111     "41bcc1f57c60bdec3c4d1e749084a12867f91224",
 112     "94645300d6eb51020a7ef8261dee2941cd51b5df",
 113     "c56f5bdc9cac4f0bc81c33295d9aed8eaf4cb1f2",
 114     "21cdfde38ac7edbb241ec83d82f31286e90c4629",
 115     NULL
 116 };
 117
 118 static const char *sha1_graphics_a8b8g8r8[] =
 119 {
 120     "a3cadd34d95d3d5cc23344f69aab1c2e55935fcf",
 121     "e0bc877697093ed440e125154e247ca9d65e933c",
 122     "c6d7faf5a502299f99d59eef3f7650bd63dbe108",
 123     "9d8c05c3ebd786e7d052418e905a80a64bf7853d",
 124     "3da12af0a810fd993fa3dbe23328a4fcd2b6c92a",
 125     "b91c8f21cc4d7994abc551feff5b6927d267a9db",
 126     "d49dd2c6a37e975b6dc3d201ccc217a788b30284",
 127     "ca6753f9eb44529cf8c67cd6abcd4ed1ef758904",
 128     "18c3ae944e0afb6c43c21cde093ddb22a27611e4",
 129     "b753ebb39d90210cc717f57b53dd439f7de6b077",
 130     "38c017dd1fff26b492a57e09f3ce2c4370faf225",
 131     "94368cea5033b435454daa56d55546310675131e",
 132     "bf57a6a37fb107d29ed3d45695919887abcb7902",
 133     "3db0f8bcca3d94920aa57be6321202b8c3c08822",
 134     "1f1fc165a4dae7ba118ddccb58a279bfe3876b0a",
 135     "8e09abb108e137c99527ab4c9bd07d95b9254bbb",
 136     "b0178632775d29bec2b16de7b9b8287115c40d0f",
 137     "ca7e859647b9498b53fdd92543ad8aea98ff46f3",
 138     "3369889a67d6c79a24ee15f7d14374f9995215e4",
 139     "473a1fd07df800c87a5d3286b642ace10c61c6af",
 140     "10cd25a0ed5cd8f978d7d68236f81d949b938e84",
 141     "b8951d2b20518fd129e5113a5f429626893913bf",
 142     "4851c5b7d5bc18590e787c0c218a592ef504e738",
 143     "9aa506e3df33e0d5298755aa4144e10eb4b5adcf",
 144     "abdf003699364fe45fab7dc61e67c606d0063b40",
 145     "89abaadff4e68c738cf9251c51e3609564843381",
 146     "f6aa3f907f620b9f3493f03cb3b4b292df3a9545",
 147     "77d0ad32938147aa4038c1eced232b7b5a5f88f3",
 148     "43d36e57b702ce56eb250bf53f1ecc4680990cfe",
 149     "fd6e0ebb52710ebcdd8dd69931165c83c4930b41",
 150     "71b9756fdfeedce1e6db201176d21a981b881662",
 151     "5319528d9af750c172ae62ee85ddb2eaef73b193",
 152     "b7ce8aa3c328eedaed7306234ed9bae67708e627",
 153     "19b32a0daa91201725b5e13820c343d0a84ff698",
 154     "abca6a80a99b05722d2d87ce2a8b94ef1ae549e1",
 155     "2ba70994d0b4ce87fdf6fbc33ada11252178061e",
 156     NULL
 157 };
 158
 159 static const char *sha1_graphics_24[] =
 160 {
 161     "e993b15c9bd14fb45a15310450b7083c44e42665",
 162     "edbd7bab3d957fbc85e89612197cf918f5f5af20",
 163     "6a7efb3b6e0b49336df1bd2937ca09a11d976531",
 164     "236eb5ca9da70ec7cc719cd2fd291bab14000257",
 165     "f98023c7cd8c068f2d7a77ce3600004b90ea12d6",
 166     "5c4cb9cea2226fc671bb4a11f8253343ee94bb4b",
 167     "fd4be592483623dbc800fe28210a1f0daa71999b",
 168     "788b8de98c47974fa9f232a6042ae4ca546ddb7d",
 169     "a8772e6c44ba633fb384a7c4b50b435f1406107e",
 170     "883bc8f305c602edca785e21cd00f488583fb13f",
 171     "3bac4e80993f49dc3926e30524115fca9d7a8026",
 172     "91369e35be29059a0665782541db4c8b324c6bb2",
 173     "0fa8cf332a56bb6d7e14e85861fdd60f51d70501",
 174     "593d694cdcc8349b3bfc8257041dbcb27e61da45",
 175     "1036b91d93e31cd1d4740d0c8642e115e5a38188",
 176     "1898073cdb35ca4d2b21bba933ac16a0b4297317",
 177     "5068bff794553cf5a3145ae407c9a2984357844c",
 178     "413a7989969c229dee4ab1798362f32f96cf0a10",
 179     "0bb222e540b82720d4971e4a2fc626899af03e03",
 180     "adc20832d8c43f1cf372d8392535492013cd2306",
 181     "45649794dcbcabda487f66f7a80fc1bec79047a1",
 182     "367c2dc1e91ff9ea0e984d6fb3000cfb4e0ae7e9",
 183     "b4df692ac70a5f9f303270df4641ab014c6cbf46",
 184     "8bc3128ba47891366fd7b02fde7ca19100e64b9f",
 185     "e649e00efe7fea1eb8b17f7867fe089e5270c44b",
 186     "a0bffbbfb0adf6f188479c88da04e25d76ab4822",
 187     "92a1ab214dd8027c407814420449119466c92840",
 188     "b58f19c1800344a2b8e017eb784705bdb2bd8450",
 189     "5747a6d5c6ce79731c55e8cf33f7da3025cd35fd",
 190     "955390669afed2369b15b32fa519f2f921cdf1a0",
 191     "201906f7d763b930a98c97f8eeab417f2b65e723",
 192     "5313357d50c40c05a3b3a83d0d2013a138c955a1",
 193     "701c5af1d0c28294ce7d804b5697643c430d22a0",
 194     "b0a959745b2db1d9f449e68e4479a4f36301879c",
 195     "63f764b9bd2f4876ab1ee0f3c0eb55b5a7de5212",
 196     "e171f6ec77bca91d6b8559911bce296c0bac469e",
 197     NULL
 198 };
 199
 200 static const char *sha1_graphics_r5g5b5[] =
 201 {
 202     "2a2ab8b3c019e70b788ade028b0e9e53ffc529ae",
 203     "847005cf7371f511bcc837251cde07b1796f6113",
 204     "a8f75743a930843ec14d516cd048b6e0468e5d89",
 205     "d094f51ce9b9daa9c1d9594ea88be2a2db651459",
 206     "cf3928e240c9149788e1635b115a4e5baea0dd8f",
 207     "a9034a905daa91757b4f63345c0e40638cd53ca8",
 208     "15ee915d989e49bb9bab5b834d8f355bd067cd8f",
 209     "99474fecf11df7b7035c35be6b8b697be9889418",
 210     "cbc2898717f97ebb07c0c7cc04abde936dc5b584",
 211     "29c896b591fdf4ddd23e5c0da1818c37e4686d94",
 212     "4b5b275d33c1ebfe5bdc61df2ad125e865b800fa",
 213     "92df731fa1f89550d9d4f7ea36c13f2e57c4b02a",
 214     "420e39ff3bdd04c4b6cc2c98e99cb7993c7a0de5",
 215     "1fabf0fdd046857b1974e31c1c1764fa9d1a762f",
 216     "449092689226a1172b6086ba1181d6b6d6499f26",
 217     "1a92a60f190d33ef06d9decb56fd3fdd33f3af03",
 218     "e61f5978c2e28c0c6d8f5eefe0f840c975586efc",
 219     "897d16f4d6a6ddad685d23ed7828d4f676539b75",
 220     "9d21bcfdeaf1ca5d47eb823bdefc24d7a95f4f56",
 221     "6daaf945a955928c5c124c880522ca4634fb2343",
 222     "12a288390d16e1efa99d4185301de48a4d433b14",
 223     "ea92af2538b76f41a3a03eaa11ac395c9b6197c4",
 224     "3a50ce21b3563a604b4fc9f247a30f5a981f1ba6",
 225     "d7d97e28ed316f6596c737eb83baa5948d86b673",
 226     "ecc2991277d7314f55b00e0f284ae3703aeef81e",
 227     "656bf3b7121bcd620a0a3ad488f0d66604824577",
 228     "d7d8493b5fa7a3a8323d6ac84245093a79f052c1",
 229     "df5dafe96e528c2cc7fd11e4934e298f53cec34b",
 230     "a49530722328ae88fd765792ac0c657efbcce75d",
 231     "aa46aa2226e3121eaefa9d0836418e0b69262d69",
 232     "333f3f2cf3ff15736d59f92a33c45323d3987d6d",
 233     "a6fd83542c3826132e88d3f5e304d604c0056fad",
 234     "a8d6a5285a927ba3a3be34b06a06c70a20d4c1b3",
 235     "e428d213ad02651287894f093413949dcb369208",
 236     "7df915bedcc5951a1b6f828490f7dbb93212e835",
 237     NULL
 238 };
 239
 240 static const char *sha1_graphics_r4g4b4[] =
 241 {
 242     "2a2ab8b3c019e70b788ade028b0e9e53ffc529ae",
 243     "cfa0ab83ee93283ad914c3748f0532da1697af1d",
 244     "8bd18697d1ef27492805667a0bc956343ac08667",
 245     "e8501c830321584474654f90e40eaf27dc21e6a8",
 246     "d95ab10fcfb8447b41742e89f1ae8cd297a32fc4",
 247     "821177710961d2cb5f7e7dfc0e06e767b6042753",
 248     "667124365ffadeea1d8791bedda77a0c7b898de8",
 249     "c9f23e684b600dea17575b4b17175fbd9106c3a9",
 250     "7678876e50eae35d1eaa096aae25afaa0b864bf3",
 251     "fb52b0c373a5f2a60b981604b120962942d2447a",
 252     "5ab8dd07436681d762fa04ad7c6d71291c488924",
 253     "0167981d9e1490a2ebd396ff7582f0943aa8e1b8",
 254     "115a6bd382410a4a1d3c1fa71d8bf02536863e38",
 255     "65c6d1228e3b6d63d42647f14217bc1658b70d9a",
 256     "25fcb75aa687aac35b8f72640889fe92413e00c5",
 257     "3bddf9d53e89560b083302b146cd33791b13d941",
 258     "a81504498c7a7bb46340ce74476a42f70f2730b1",
 259     "e61a4f2657a444d8c49f84fb944f9f847667bf2b",
 260     "32b6e0aa79b7e96cd0ab2da167f6463c011023a8",
 261     "1d283aa4d2b2114f7809fe59357d590c7c779aa7",
 262     "29640e2ddd2d3016da14507c3ce9b2ce32f39bb4",
 263     "57ebf8becac1524543da120e88e9cc57ecfdec49",
 264     "d591232bbc2592462c819a9486750f64180518fd",
 265     "0e183a4c30b3da345129cffe33fe0fc593d8666b",
 266     "f14d9a4bd8a365b7c8f068a0dad481b6eb2b178b",
 267     "8933450132bf949ba4bc28626968425b5ed2867d",
 268     "9928a8f28a66c00069a124f7171b248817005763",
 269     "e4a9dcc3e565cd3a6b7087dd1433f3898bb9cdb2",
 270     "eca4f9b16b3bddfd0735fdd792e0ccaadfb9ba49",
 271     "233e588cf660e2c9b552cf02065cf63fa6655864",
 272     "0740ff74dcd259d9a644ba51ad77ff0d40348951",
 273     "a3345acaf272f2e288626906e3056cd0ced70499",
 274     "957a86fbe8a96dd068db65e4e624a52bcc84af46",
 275     "13b0f240054dc57ba0e2dfde74048496304a2c7f",
 276     "51ef267eb9c15487c9430f505e8a6c929eb2170c",
 277     NULL
 278 };
 279
 280 static const char *sha1_graphics_8[] =
 281 {
 282     "41728d7ff2bb425b5fc06521adeabf6cc73136f3",
 283     "512246d4886ab889a090b167ba194577cb95272e",
 284     "921e852d4564cb9e5ac15ff68b5207bebea871d1",
 285     "9636b0ebefc443ea11949ccd28f6ca454277dd41",
 286     "aa9050da55e6b6957c60b7d603fce539cb5c0048",
 287     "e2b93aca15fb1233ac09a713dced1f4cd950b1e4",
 288     "3e3a603fc26cc305aa27f88da7d2a3b0073877d8",
 289     "390b2bf70daba36310683f46af9cd50b9a061396",
 290     "82d21737e9a7247397a6c983a9b6d9a0452dd74d",
 291     "2a8460af91675e01cbe9384eb6cd3eb2cb420960",
 292     "1af53b1218ee9844fcda891b836d42f6b2f66bd5",
 293     "da1cc34a9d9b779fc7849e03e214096026506464",
 294     "5ba8f99ca034666effa556748c49a0f5a015125f",
 295     "b67ba2f55659c75ac72c1112494461bb3086e1a4",
 296     "73e2859ce849f756f954718ce3c90f02e31712b6",
 297     "b1dff0f5dd233b44ee568878c5d3f8ae1d80c6d9",
 298     "1f27dc1a1316fb7a4a78fe40fcd4bdae3aaad218",
 299     "6e375e1485a1e45ac6ab10af49645d5fb2e76dff",
 300     "cfc67c325c7cdf96d90af9b3cceb8d0504cbb3b0",
 301     "7262364067e03c7fa498af1d59d228d6c63b460e",
 302     "5241241a355a667ef0834049adf4218e8b3f16b8",
 303     "db22d666690948eb966f75b796c72c7150a5c4b9",
 304     "1f13ea0034db4b0ffa4ddcff9664fd892058f9cd",
 305     "3caf512cfddfd463d0750cfe3cadb58548eb2ae8",
 306     "4e5e7d5fd64818b2b3d3e793c88f603b699d2f0f",
 307     "c4efce8f7ed2d380ea5dc6fe1ef8448a27827532",
 308     "bdc0a354635b879871077c5b712570e469863c99",
 309     "d599bf210423fe3adbb4f1de87d9360de97827d0",
 310     "bae7c8b789e4e9b336c03c4daee3bce63fe039d9",
 311     "cc01f17928f7780cefd423ea653b072eea723a1b",
 312     "c005662a47f14c2f1b7c7fb3b0ef0fc390c6ea6a",
 313     "675cde16a6ad2bcd8d7e72780b07a0ccd8d0393a",
 314     "ea39ac62ca2f815a1d029340c6465994b6f03cb0",
 315     "9a603513cd81acf70cf8b27b0d544e7f672e9d40",
 316     "f4a334e69535de74ee5ed54be93a75120a66e54a",
 317     NULL
 318 };
 319
 320 static const char *sha1_graphics_4[] =
 321 {
 322     "fa867e2976a549ecd3b1fa67df54963232fcef8c",
 323     "256d742b4da96b373b4fa5663d0ad3b5faab5c8e",
 324     "d96d8f4232b930bccd53b903b5efaf8c0bdb16f4",
 325     "9401799e6116c35e5f0e5bdca07ea25316757a72",
 326     "482ae2b0ef1d64752b5ef11cc7f35a33eb55d07c",
 327     "dcfb3e01100b41c0f75a1c5f84b6de6b90138281",
 328     "2505598845fa026ea7187582461efbf06cb6904f",
 329     "3981a19363beca8f28d32a5928ac296fd22a5296",
 330     "01404024ebb2c266d17d734059524d874491650f",
 331     "c87bbff3f83b8ec11bb03cfa9bc9ee5166c4c7ef",
 332     "f35c5d62853be78c5d39fb2f45200dc262aa8e18",
 333     "46e94a55f5f58a6b915078d8ffdc725f53aab516",
 334     "665bbbc749a5ffeedc0d62aef0661a5ce845b017",
 335     "1f26a01730f67d40ea711a50d9d801bac15a642e",
 336     "3b53d24178cfacba53103a44dfd5d072b15a6781",
 337     "c52cfd57f26037723d37192722fc3a217f280c9e",
 338     "e34da6500cf2e424d980714d92737cf6c31a7bda",
 339     "d17f4358ae529f920960ed89e535902ee13b0033",
 340     "0f44e12ecd1ea7e39433890443626d4fc35204a4",
 341     "eb38683e812fd13dca971ba8f4cfd2b6820d3524",
 342     "73bbc83f88f1aaa6df0158b63e70bb3165163163",
 343     "0dc2690a5c58a2907a8ab06693ebfab6698172eb",
 344     "39c16648cf6c261be71a33cec41867f28e119b94",
 345     "26ad5116562e7b58c76a26eaf521e2e40899e944",
 346     "1bcc54eaf8e3c2b7c59ecccb23c240181d7ba8b8",
 347     "4f827ca6927f15191588456f985bf29d2a3b3c24",
 348     "e7de769c3d12ea9dd223bef4881c578823bec67e",
 349     "6fb102d020e5554116feefc8482104f3ae2036d2",
 350     "ae546ffd30b837afc7dfcb5c9ce4f01d15b35ddc",
 351     "20c9eb3276c08fdce35755e349bec94b04929812",
 352     "628d837163a25c6520f19c0602383176dbad528e",
 353     "b5a12cff7100290ad43f5ed17a321b42de048893",
 354     "b672afbeeafb44194a821f0def81a8892872937e",
 355     "db0124045882b598feea192186cf7eb7a0387866",
 356     "602d91471378fe24a2d0248bd8a92b624f099fea",
 357     NULL
 358 };
 359
 360 static const char *sha1_graphics_1[] =
 361 {
 362     "23366004515f3bc46796ea505d748f8d0f97fbe1",
 363     "ad674a4104c6a1eacaee8f20effdfe31775b4409",
 364     "a7cc69f957d7b533a0a330859a143d701daac73c",
 365     "a955bf088c5edb129289ce65caace48ec95632e4",
 366     "5316d3c558c254479883133cf58cd07ab521d3f0",
 367     "fcbfdb5d60716ea05f2d1896fae7a6e7a8249d35",
 368     "2c140b39cc8d21358fded8959cd655f03d7f0f89",
 369     "121423a38b4ac4743bd516e0a7e88a3863796313",
 370     "7c17635c6c7f62dbf8fd4773d0c503358553d2c7",
 371     "21d5d9e47bb07de2cf7bc99b7725390d03a6cde6",
 372     "f69ee65ea25676429a28eea79b5b9cb9206b8d01",
 373     "39ff81f77ef4ee772367ed1a63785987c060126e",
 374     "4c686508a994ca4c7a0a73b8c0fe52423c180d9c",
 375     "b0cc1f5e244ae0c0835a9866a46abdfcd56d1cb1",
 376     "7ddf19df5bbdf4475b6ec1bc042425e382502864",
 377     "144c9a846e5e37ac6efd5ed3a97ec231479e8fca",
 378     "c5ffc59048bf786b5646ad6226cd8633965de9ef",
 379     "40fadc2d24c713b04ff96f7dc26e70e85f26c55e",
 380     "400a21caa01e015096ee1afcf1b54e7f8ec515bd",
 381     "0ff4b49797e30e3555aab45219adf449a9a560ff",
 382     "280327328ca940c212ce24fe72e0b00014072767",
 383     "144c9a846e5e37ac6efd5ed3a97ec231479e8fca",
 384     "b85463875f755b85f1464b1b6275912bcbad6c9f",
 385     "816f200969feecc788b61dfeecf05b1790984401",
 386     "a4964d8bbf80fe785f906bc0f7c5b113242a58fc",
 387     "a5d204cc7342d40b765ca042f8668e22601c4ff9",
 388     "adb2818f6d3845dd140bc0f9abdbaa89d2a8c3de",
 389     "0a76e0121facb103857130bc6e12185ad77fc3fa",
 390     "02aede714773d654d0fc2f640afaa133ec718ad5",
 391     "13cc63972aee4f6ae27091a8af18de01f1d3a5da",
 392     "3bb745ccb08402ce6fac6ee26fb8d7aad2dba27e",
 393     "b26699f62661e16a1dc452d24c88ce363a1f2998",
 394     "4d95c3d1e170f004c80aa8c52feafb8e0e90760e",
 395     "c14832e69ec3585c15987b3d69d5007236fa9814",
 396     "e44ea620b0c47125a34193537ab9d219a52ad028",
 397     "d1e6091caa4482d3142df3b958606c41ebf4698e",
 398     "07c1116d8286fb665a1005de220eadc3d5999aaf",
 399     "4afb0649488f6e6f7d3a2b8bf438d82f2c88f4d1",
 400     "f2fe295317e795a88edd0b2c52618b8cb0e7f2ce",
 401     "ffc78c075d4be66806f6c59180772d5eed963dc0",
 402     "c86eeaeed09871dee4b43722ba512d2d3af7f4d0",
 403     "24b1a6241c81dbb950cfbe5da6798fd59eb36266",
 404     "1007d3b531b4bc3553d4547bc88443fc1f497cf6",
 405     "b71ca46be287598f716bb04fac0a52ad139c70db",
 406     "6589e48498e30ab036fbfe94d73427b2b1238a69",
 407     "4dce919117d2e41df9f5d4d0de14f97ae650046d",
 408     "22c2e078f69d73b7a5cb3f7dcbb8fbaa007ef3ac",
 409     "be36cda370650e6d5fb0570aeb8ced491d0c2b1c",
 410     "4c34cb8e47f9ff4b4348aa2d40cce7cb54d65cb0",
 411     "18f4497e43903e8df5b27da4ceebf62b15550a87",
 412     NULL
 413 };
 414
 415 static inline DWORD get_stride(BITMAPINFO *bmi)
 416 {
 417     return ((bmi->bmiHeader.biBitCount * bmi->bmiHeader.biWidth + 31) >> 3) & ~3;
 418 }
 419
 420 static inline DWORD get_dib_size(BITMAPINFO *bmi)
 421 {
 422     return get_stride(bmi) * abs(bmi->bmiHeader.biHeight);
 423 }
 424
 425 static char *hash_dib(BITMAPINFO *bmi, void *bits)
 426 {
 427     DWORD dib_size = get_dib_size(bmi);
 428     HCRYPTHASH hash;
 429     char *buf;
 430     BYTE hash_buf[20];
 431     DWORD hash_size = sizeof(hash_buf);
 432     int i;
 433     static const char *hex = "0123456789abcdef";
 434
 435     if(!crypt_prov) return NULL;
 436
 437     if(!CryptCreateHash(crypt_prov, CALG_SHA1, 0, 0, &hash)) return NULL;
 438
 439     CryptHashData(hash, bits, dib_size, 0);
 440
 441     CryptGetHashParam(hash, HP_HASHVAL, NULL, &hash_size, 0);
 442     if(hash_size != sizeof(hash_buf)) return NULL;
 443
 444     CryptGetHashParam(hash, HP_HASHVAL, hash_buf, &hash_size, 0);
 445     CryptDestroyHash(hash);
 446
 447     buf = HeapAlloc(GetProcessHeap(), 0, hash_size * 2 + 1);
 448
 449     for(i = 0; i < hash_size; i++)
 450     {
 451         buf[i * 2] = hex[hash_buf[i] >> 4];
 452         buf[i * 2 + 1] = hex[hash_buf[i] & 0xf];
 453     }
 454     buf[i * 2] = '\0';
 455
 456     return buf;
 457 }
 458
 459 static void compare_hash_broken_todo(BITMAPINFO *bmi, BYTE *bits, const char ***sha1, const char *info, int num_broken, BOOL todo)
 460 {
 461     char *hash = hash_dib(bmi, bits);
 462     BOOL ok_cond;
 463     int i;
 464
 465     if(!hash)
 466     {
 467         skip("SHA1 hashing unavailable on this platform\n");
 468         return;
 469     }
 470
 471     for(i = 0; i <= num_broken; i++)
 472     {
 473         if((*sha1)[i] == NULL)
 474         {
 475             ok((*sha1)[i] != NULL, "missing hash, got \"%s\",\n", hash);
 476             return;
 477         }
 478     }
 479
 480     ok_cond = !strcmp(hash, **sha1);
 481
 482     for(i = 1; i <= num_broken; i++)
 483         ok_cond = ok_cond || broken( !strcmp(hash, (*sha1)[i]) );
 484
 485     if(todo)
 486         todo_wine ok( ok_cond, "%d: %s: expected hash %s got %s\n",
 487                       bmi->bmiHeader.biBitCount, info, **sha1, hash );
 488     else
 489         ok( ok_cond, "%d: %s: expected hash %s got %s\n",
 490             bmi->bmiHeader.biBitCount, info, **sha1, hash );
 491
 492     *sha1 += num_broken + 1;
 493
 494     HeapFree(GetProcessHeap(), 0, hash);
 495 }
 496
 497 static void compare_hash(BITMAPINFO *bmi, BYTE *bits, const char ***sha1, const char *info)
 498 {
 499     compare_hash_broken_todo(bmi, bits, sha1, info, 0, FALSE);
 500 }
 501
 502 static const RECT bias_check[] =
 503 {
 504     {100, 100, 200, 150},
 505     {100, 100, 150, 200},
 506     {100, 100,  50, 200},
 507     {100, 100,   0, 150},
 508     {100, 100,   0,  50},
 509     {100, 100,  50,   0},
 510     {100, 100, 150,   0},
 511     {100, 100, 200,  50}
 512 };
 513
 514 static const RECT hline_clips[] =
 515 {
 516     {120, 120, 140, 120}, /* unclipped */
 517     {100, 122, 140, 122}, /* l edgecase */
 518     { 99, 124, 140, 124}, /* l edgecase clipped */
 519     {120, 126, 200, 126}, /* r edgecase */
 520     {120, 128, 201, 128}, /* r edgecase clipped */
 521     { 99, 130, 201, 130}, /* l and r clipped */
 522     {120, 100, 140, 100}, /* t edgecase */
 523     {120,  99, 140,  99}, /* t edgecase clipped */
 524     {120, 199, 140, 199}, /* b edgecase */
 525     {120, 200, 140, 200}, /* b edgecase clipped */
 526     {120, 132, 310, 132}, /* inside two clip rects */
 527     { 10, 134, 101, 134}, /* r end on l edgecase */
 528     { 10, 136, 100, 136}, /* r end on l edgecase clipped */
 529     {199, 138, 220, 138}, /* l end on r edgecase */
 530     {200, 140, 220, 140}  /* l end on r edgecase clipped */
 531 };
 532
 533 static const RECT vline_clips[] =
 534 {
 535     {120, 120, 120, 140}, /* unclipped */
 536     {100, 120, 100, 140}, /* l edgecase */
 537     { 99, 120,  99, 140}, /* l edgecase clipped */
 538     {199, 120, 199, 140}, /* r edgecase */
 539     {200, 120, 200, 140}, /* r edgecase clipped */
 540     {122,  99, 122, 201}, /* t and b clipped */
 541     {124, 100, 124, 140}, /* t edgecase */
 542     {126,  99, 126, 140}, /* t edgecase clipped */
 543     {128, 120, 128, 200}, /* b edgecase */
 544     {130, 120, 130, 201}, /* b edgecase clipped */
 545     {132,  12, 132, 140}, /* inside two clip rects */
 546     {134,  90, 134, 101}, /* b end on t edgecase */
 547     {136,  90, 136, 100}, /* b end on t edgecase clipped */
 548     {138, 199, 138, 220}, /* t end on b edgecase */
 549     {140, 200, 140, 220}  /* t end on b edgecase clipped */
 550 };
 551
 552 static const RECT line_clips[] =
 553 {
 554     { 90, 110, 310, 120},
 555     { 90, 120, 295, 130},
 556     { 90, 190, 110, 240}, /* totally clipped, moving outcodes */
 557     { 90, 130, 100, 135}, /* totally clipped, end pt on l edge */
 558     { 90, 132, 101, 137}, /* end pt just inside l edge */
 559     {200, 140, 210, 141}, /* totally clipped, start pt on r edge */
 560     {199, 142, 210, 143}  /* start pt just inside r edge */
 561 };
 562
 563 static const RECT patblt_clips[] =
 564 {
 565     {120, 120, 140, 126}, /* unclipped */
 566     {100, 130, 140, 136}, /* l edgecase */
 567     { 99, 140, 140, 146}, /* l edgecase clipped */
 568     {180, 130, 200, 136}, /* r edgecase */
 569     {180, 140, 201, 146}, /* r edgecase clipped */
 570     {120, 100, 130, 110}, /* t edgecase */
 571     {140,  99, 150, 110}, /* t edgecase clipped */
 572     {120, 180, 130, 200}, /* b edgecase */
 573     {140, 180, 150, 201}, /* b edgecase */
 574     {199, 150, 210, 156}, /* l edge on r edgecase */
 575     {200, 160, 210, 166}, /* l edge on r edgecase clipped */
 576     { 90, 150, 101, 156}, /* r edge on l edgecase */
 577     { 90, 160, 100, 166}, /* r edge on l edgecase clipped */
 578     {160,  90, 166, 101}, /* b edge on t edgecase */
 579     {170,  90, 176, 101}, /* b edge on t edgecase clipped */
 580     {160, 199, 166, 210}, /* t edge on b edgecase */
 581     {170, 200, 176, 210}, /* t edge on b edgecase clipped */
 582 };
 583
 584 static const RECT rectangles[] =
 585 {
 586     {10,   11, 100, 101},
 587     {250, 100, 350,  10},
 588     {120,  10, 120,  20}, /* zero width */
 589     {120,  10, 130,  10}, /* zero height */
 590     {120,  40, 121,  41}, /* 1 x 1 */
 591     {130,  50, 132,  52}, /* 2 x 2 */
 592     {140,  60, 143,  63}, /* 3 x 3 */
 593     {150,  70, 154,  74}, /* 4 x 4 */
 594     {120,  20, 121,  30}, /* width == 1 */
 595     {130,  20, 132,  30}, /* width == 2 */
 596     {140,  20, 143,  30}, /* width == 3 */
 597     {200,  20, 210,  21}, /* height == 1 */
 598     {200,  30, 210,  32}, /* height == 2 */
 599     {200,  40, 210,  43}  /* height == 3 */
 600 };
 601
 602 static const BITMAPINFOHEADER dib_brush_header_8888 = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 32, BI_RGB, 0, 0, 0, 0, 0};
 603 static const BITMAPINFOHEADER dib_brush_header_24   = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 24, BI_RGB, 0, 0, 0, 0, 0};
 604 static const BITMAPINFOHEADER dib_brush_header_555  = {sizeof(BITMAPINFOHEADER), 16, -16, 1, 16, BI_RGB, 0, 0, 0, 0, 0};
 605 static const BITMAPINFOHEADER dib_brush_header_8    = {sizeof(BITMAPINFOHEADER), 16, -16, 1,  8, BI_RGB, 0, 0, 0, 0, 0};
 606 static const BITMAPINFOHEADER dib_brush_header_4    = {sizeof(BITMAPINFOHEADER), 16, -16, 1,  4, BI_RGB, 0, 0, 0, 0, 0};
 607 static const BITMAPINFOHEADER dib_brush_header_1    = {sizeof(BITMAPINFOHEADER), 16, -16, 1,  1, BI_RGB, 0, 0, 0, 0, 0};
 608
 609 static void draw_graphics(HDC hdc, BITMAPINFO *bmi, BYTE *bits, const char ***sha1)
 610 {
 611     DWORD dib_size = get_dib_size(bmi);
 612     HPEN solid_pen, dashed_pen, orig_pen;
 613     HBRUSH solid_brush, dib_brush, hatch_brush, orig_brush;
 614     INT i, y, hatch_style;
 615     HRGN hrgn, hrgn2;
 616     BYTE dib_brush_buf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD) + 16 * 16 * sizeof(DWORD)]; /* Enough for 16 x 16 at 32 bpp */
 617     BITMAPINFO *brush_bi = (BITMAPINFO*)dib_brush_buf;
 618     BYTE *brush_bits;
 619     BOOL dib_is_1bpp = (bmi->bmiHeader.biBitCount == 1);
 620
 621     memset(bits, 0xcc, dib_size);
 622     compare_hash(bmi, bits, sha1, "empty");
 623
 624     solid_pen = CreatePen(PS_SOLID, 1, RGB(0, 0, 0xff));
 625     orig_pen = SelectObject(hdc, solid_pen);
 626     SetBrushOrgEx(hdc, 0, 0, NULL);
 627
 628     /* horizontal and vertical lines */
 629     for(i = 1; i <= 16; i++)
 630     {
 631         SetROP2(hdc, i);
 632         MoveToEx(hdc, 10, i * 3, NULL);
 633         LineTo(hdc, 100, i * 3); /* l -> r */
 634         MoveToEx(hdc, 100, 50 + i * 3, NULL);
 635         LineTo(hdc, 10, 50 + i * 3); /* r -> l */
 636         MoveToEx(hdc, 120 + i * 3, 10, NULL);
 637         LineTo(hdc, 120 + i * 3, 100); /* t -> b */
 638         MoveToEx(hdc, 170 + i * 3, 100, NULL);
 639         LineTo(hdc, 170 + i * 3, 10); /* b -> t */
 640     }
 641     compare_hash(bmi, bits, sha1, "h and v solid lines");
 642     memset(bits, 0xcc, dib_size);
 643
 644     /* diagonal lines */
 645     SetROP2(hdc, R2_COPYPEN);
 646     for(i = 0; i < 16; i++)
 647     {
 648         double s = sin(M_PI * i / 8.0);
 649         double c = cos(M_PI * i / 8.0);
 650
 651         MoveToEx(hdc, 200.5 + 10 * c, 200.5 + 10 * s, NULL);
 652         LineTo(hdc, 200.5 + 100 * c, 200.5 + 100 * s);
 653     }
 654     compare_hash(bmi, bits, sha1, "diagonal solid lines");
 655     memset(bits, 0xcc, dib_size);
 656
 657     for(i = 0; i < sizeof(bias_check) / sizeof(bias_check[0]); i++)
 658     {
 659         MoveToEx(hdc, bias_check[i].left, bias_check[i].top, NULL);
 660         LineTo(hdc, bias_check[i].right, bias_check[i].bottom);
 661     }
 662     compare_hash(bmi, bits, sha1, "more diagonal solid lines");
 663     memset(bits, 0xcc, dib_size);
 664
 665     /* solid brush PatBlt */
 666     solid_brush = CreateSolidBrush(RGB(0x33, 0xaa, 0xff));
 667     orig_brush = SelectObject(hdc, solid_brush);
 668
 669     for(i = 0, y = 10; i < 256; i++)
 670     {
 671         BOOL ret;
 672
 673         ret = PatBlt(hdc, 10, y, 100, 10, rop3[i]);
 674
 675         if(rop_uses_src(rop3[i]))
 676             ok(ret == FALSE, "got TRUE for %x\n", rop3[i]);
 677         else
 678         {
 679             ok(ret, "got FALSE for %x\n", rop3[i]);
 680             y += 20;
 681         }
 682
 683     }
 684     compare_hash(bmi, bits, sha1, "solid patblt");
 685     memset(bits, 0xcc, dib_size);
 686
 687     /* clipped lines */
 688     hrgn = CreateRectRgn(10, 10, 200, 20);
 689     hrgn2 = CreateRectRgn(100, 100, 200, 200);
 690     CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
 691     SetRectRgn(hrgn2, 290, 100, 300, 200);
 692     CombineRgn(hrgn, hrgn, hrgn2, RGN_OR);
 693     ExtSelectClipRgn(hdc, hrgn, RGN_COPY);
 694     DeleteObject(hrgn2);
 695
 696     for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
 697     {
 698         MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
 699         LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
 700     }
 701     compare_hash(bmi, bits, sha1, "clipped solid hlines");
 702     memset(bits, 0xcc, dib_size);
 703
 704     for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
 705     {
 706         MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
 707         LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
 708     }
 709     compare_hash(bmi, bits, sha1, "clipped solid vlines");
 710     memset(bits, 0xcc, dib_size);
 711
 712     for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
 713     {
 714         MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
 715         LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
 716     }
 717     compare_hash(bmi, bits, sha1, "clipped solid diagonal lines");
 718     memset(bits, 0xcc, dib_size);
 719
 720     /* clipped PatBlt */
 721     for(i = 0; i < sizeof(patblt_clips) / sizeof(patblt_clips[0]); i++)
 722     {
 723         PatBlt(hdc, patblt_clips[i].left, patblt_clips[i].top,
 724                patblt_clips[i].right - patblt_clips[i].left,
 725                patblt_clips[i].bottom - patblt_clips[i].top, PATCOPY);
 726     }
 727     compare_hash(bmi, bits, sha1, "clipped patblt");
 728     memset(bits, 0xcc, dib_size);
 729
 730     /* clipped dashed lines */
 731     dashed_pen = CreatePen(PS_DASH, 1, RGB(0xff, 0, 0));
 732     SelectObject(hdc, dashed_pen);
 733     SetBkMode(hdc, TRANSPARENT);
 734     SetBkColor(hdc, RGB(0, 0xff, 0));
 735
 736     for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
 737     {
 738         MoveToEx(hdc, hline_clips[i].left, hline_clips[i].top, NULL);
 739         LineTo(hdc, hline_clips[i].right, hline_clips[i].bottom);
 740     }
 741     compare_hash(bmi, bits, sha1, "clipped dashed hlines");
 742     memset(bits, 0xcc, dib_size);
 743
 744     for(i = 0; i < sizeof(hline_clips)/sizeof(hline_clips[0]); i++)
 745     {
 746         MoveToEx(hdc, hline_clips[i].right - 1, hline_clips[i].bottom, NULL);
 747         LineTo(hdc, hline_clips[i].left - 1, hline_clips[i].top);
 748     }
 749     compare_hash(bmi, bits, sha1, "clipped dashed hlines r -> l");
 750     memset(bits, 0xcc, dib_size);
 751
 752     for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
 753     {
 754         MoveToEx(hdc, vline_clips[i].left, vline_clips[i].top, NULL);
 755         LineTo(hdc, vline_clips[i].right, vline_clips[i].bottom);
 756     }
 757     compare_hash(bmi, bits, sha1, "clipped dashed vlines");
 758     memset(bits, 0xcc, dib_size);
 759
 760     for(i = 0; i < sizeof(vline_clips)/sizeof(vline_clips[0]); i++)
 761     {
 762         MoveToEx(hdc, vline_clips[i].right, vline_clips[i].bottom - 1, NULL);
 763         LineTo(hdc, vline_clips[i].left, vline_clips[i].top - 1);
 764     }
 765     compare_hash(bmi, bits, sha1, "clipped dashed vlines b -> t");
 766     memset(bits, 0xcc, dib_size);
 767
 768     for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
 769     {
 770         MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
 771         LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
 772     }
 773     compare_hash(bmi, bits, sha1, "clipped dashed diagonal lines");
 774     memset(bits, 0xcc, dib_size);
 775
 776     SetBkMode(hdc, OPAQUE);
 777
 778     for(i = 0; i < sizeof(line_clips)/sizeof(line_clips[0]); i++)
 779     {
 780         MoveToEx(hdc, line_clips[i].left, line_clips[i].top, NULL);
 781         LineTo(hdc, line_clips[i].right, line_clips[i].bottom);
 782     }
 783     compare_hash(bmi, bits, sha1, "clipped opaque dashed diagonal lines");
 784     memset(bits, 0xcc, dib_size);
 785
 786     ExtSelectClipRgn(hdc, NULL, RGN_COPY);
 787
 788     /* 8888 DIB pattern brush */
 789
 790     brush_bi->bmiHeader = dib_brush_header_8888;
 791     brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
 792     memset(brush_bits, 0, 16 * 16 * sizeof(DWORD));
 793     brush_bits[2] = 0xff;
 794     brush_bits[6] = 0xff;
 795     brush_bits[14] = 0xff;
 796     brush_bits[65] = 0xff;
 797     brush_bits[69] = 0xff;
 798     brush_bits[72] = 0xff;
 799
 800     dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 801
 802     SelectObject(hdc, dib_brush);
 803     SetBrushOrgEx(hdc, 1, 1, NULL);
 804
 805     for(i = 0, y = 10; i < 256; i++)
 806     {
 807         BOOL ret;
 808
 809         if(!rop_uses_src(rop3[i]))
 810         {
 811             ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
 812             ok(ret, "got FALSE for %x\n", rop3[i]);
 813             y += 25;
 814         }
 815     }
 816     compare_hash_broken_todo(bmi, bits, sha1, "top-down 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
 817     memset(bits, 0xcc, dib_size);
 818
 819     SelectObject(hdc, orig_brush);
 820     DeleteObject(dib_brush);
 821
 822     /* 8888 bottom-up DIB pattern brush */
 823
 824     brush_bi->bmiHeader.biHeight = -brush_bi->bmiHeader.biHeight;
 825
 826     dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 827
 828     SelectObject(hdc, dib_brush);
 829
 830     /* This used to set the x origin to 100 as well, but
 831        there's a Windows bug for 24 bpp where the brush's x offset
 832        is incorrectly calculated for rops that involve both D and P */
 833     SetBrushOrgEx(hdc, 4, 100, NULL);
 834
 835     for(i = 0, y = 10; i < 256; i++)
 836     {
 837         BOOL ret;
 838
 839         if(!rop_uses_src(rop3[i]))
 840         {
 841             ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
 842             ok(ret, "got FALSE for %x\n", rop3[i]);
 843             y += 25;
 844         }
 845     }
 846     compare_hash_broken_todo(bmi, bits, sha1, "bottom-up 8888 dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
 847     memset(bits, 0xcc, dib_size);
 848
 849     SelectObject(hdc, orig_brush);
 850     DeleteObject(dib_brush);
 851
 852     /* 24 bpp dib pattern brush */
 853
 854     brush_bi->bmiHeader = dib_brush_header_24;
 855     brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
 856     memset(brush_bits, 0, 16 * 16 * 3);
 857     brush_bits[0] = brush_bits[3] = brush_bits[6] = brush_bits[8] = 0xff;
 858     brush_bits[49] = brush_bits[52] = 0xff;
 859
 860     dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 861
 862     SelectObject(hdc, dib_brush);
 863     SetBrushOrgEx(hdc, 1, 1, NULL);
 864
 865     for(i = 0, y = 10; i < 256; i++)
 866     {
 867         BOOL ret;
 868
 869         if(!rop_uses_src(rop3[i]))
 870         {
 871             ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
 872             ok(ret, "got FALSE for %x\n", rop3[i]);
 873             y += 25;
 874         }
 875     }
 876     compare_hash_broken_todo(bmi, bits, sha1, "top-down 24 bpp brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
 877     memset(bits, 0xcc, dib_size);
 878
 879     SelectObject(hdc, orig_brush);
 880     DeleteObject(dib_brush);
 881
 882     /* 555 dib pattern brush */
 883
 884     brush_bi->bmiHeader = dib_brush_header_555;
 885     brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER);
 886     memset(brush_bits, 0, 16 * 16 * sizeof(WORD));
 887     brush_bits[0] = brush_bits[1] = 0xff;
 888     brush_bits[32] = brush_bits[34] = 0x7c;
 889
 890     dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 891
 892     SelectObject(hdc, dib_brush);
 893     SetBrushOrgEx(hdc, 1, 1, NULL);
 894
 895     for(i = 0, y = 10; i < 256; i++)
 896     {
 897         BOOL ret;
 898
 899         if(!rop_uses_src(rop3[i]))
 900         {
 901             ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
 902             ok(ret, "got FALSE for %x\n", rop3[i]);
 903             y += 25;
 904         }
 905     }
 906     compare_hash_broken_todo(bmi, bits, sha1, "top-down 555 dib brush patblt", dib_is_1bpp ? 1 : 0, dib_is_1bpp);
 907     memset(bits, 0xcc, dib_size);
 908
 909     SelectObject(hdc, orig_brush);
 910     DeleteObject(dib_brush);
 911
 912     SetBrushOrgEx(hdc, 0, 0, NULL);
 913
 914     /* 8 bpp dib pattern brush */
 915
 916     brush_bi->bmiHeader = dib_brush_header_8;
 917     brush_bi->bmiHeader.biClrUsed = 3;
 918     memset(brush_bi->bmiColors, 0, brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD));
 919     brush_bi->bmiColors[0].rgbRed = 0xff;
 920     brush_bi->bmiColors[1].rgbRed = 0xff;
 921     brush_bi->bmiColors[1].rgbGreen = 0xff;
 922     brush_bi->bmiColors[1].rgbBlue = 0xff;
 923
 924     brush_bits = (BYTE*)brush_bi + sizeof(BITMAPINFOHEADER) + brush_bi->bmiHeader.biClrUsed * sizeof(RGBQUAD);
 925     memset(brush_bits, 0, 16 * 16 * sizeof(BYTE));
 926     brush_bits[0] = brush_bits[1] = 1;
 927     brush_bits[16] = brush_bits[17] = 2;
 928     brush_bits[32] = brush_bits[33] = 6;
 929
 930     dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 931
 932     SelectObject(hdc, dib_brush);
 933     SetBrushOrgEx(hdc, 1, 1, NULL);
 934
 935     for(i = 0, y = 10; i < 256; i++)
 936     {
 937         BOOL ret;
 938
 939         if(!rop_uses_src(rop3[i]))
 940         {
 941             ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
 942             ok(ret, "got FALSE for %x\n", rop3[i]);
 943             y += 25;
 944         }
 945     }
 946     compare_hash_broken_todo(bmi, bits, sha1, "top-down 8 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
 947     memset(bits, 0xcc, dib_size);
 948
 949     SelectObject(hdc, orig_brush);
 950     DeleteObject(dib_brush);
 951
 952     /* 4 bpp dib pattern brush */
 953
 954     brush_bi->bmiHeader = dib_brush_header_4;
 955     dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 956
 957     SelectObject(hdc, dib_brush);
 958     SetBrushOrgEx(hdc, 1, 1, NULL);
 959
 960     for(i = 0, y = 10; i < 256; i++)
 961     {
 962         BOOL ret;
 963
 964         if(!rop_uses_src(rop3[i]))
 965         {
 966             ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
 967             ok(ret, "got FALSE for %x\n", rop3[i]);
 968             y += 25;
 969         }
 970     }
 971     compare_hash_broken_todo(bmi, bits, sha1, "top-down 4 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
 972     memset(bits, 0xcc, dib_size);
 973
 974     SelectObject(hdc, orig_brush);
 975     DeleteObject(dib_brush);
 976
 977     /* 1 bpp dib pattern brush */
 978
 979     brush_bi->bmiHeader = dib_brush_header_1;
 980     brush_bi->bmiHeader.biClrUsed = 2;
 981     memset(brush_bits, 0, 16 * 4);
 982     brush_bits[0] = 0xf0;
 983     brush_bits[4] = 0xf0;
 984     brush_bits[8] = 0xf0;
 985
 986     dib_brush = CreateDIBPatternBrushPt(brush_bi, DIB_RGB_COLORS);
 987     SelectObject(hdc, dib_brush);
 988     for(i = 0, y = 10; i < 256; i++)
 989     {
 990         BOOL ret;
 991
 992         if(!rop_uses_src(rop3[i]))
 993         {
 994             ret = PatBlt(hdc, 10 + i, y, 100, 20, rop3[i]);
 995             ok(ret, "got FALSE for %x\n", rop3[i]);
 996             y += 25;
 997         }
 998     }
 999
1000     compare_hash_broken_todo(bmi, bits, sha1, "top-down 1 bpp dib brush patblt", dib_is_1bpp ? 2 : 0, dib_is_1bpp);
1001     memset(bits, 0xcc, dib_size);
1002
1003     SelectObject(hdc, orig_brush);
1004     SetBrushOrgEx(hdc, 0, 0, NULL);
1005
1006     /* Rectangle */
1007
1008     SelectObject(hdc, solid_pen);
1009     SelectObject(hdc, solid_brush);
1010
1011     for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
1012     {
1013         Rectangle(hdc, rectangles[i].left, rectangles[i].top, rectangles[i].right, rectangles[i].bottom);
1014     }
1015
1016     SelectObject(hdc, dashed_pen);
1017     for(i = 0; i < sizeof(rectangles)/sizeof(rectangles[0]); i++)
1018     {
1019         Rectangle(hdc, rectangles[i].left, rectangles[i].top + 150, rectangles[i].right, rectangles[i].bottom + 150);
1020     }
1021
1022     compare_hash(bmi, bits, sha1, "rectangles");
1023     memset(bits, 0xcc, dib_size);
1024     SelectObject(hdc, solid_pen);
1025
1026     /* PaintRgn */
1027
1028     PaintRgn(hdc, hrgn);
1029     compare_hash(bmi, bits, sha1, "PaintRgn");
1030     memset(bits, 0xcc, dib_size);
1031
1032     /* RTL rectangles */
1033
1034     if( !pSetLayout )
1035     {
1036         win_skip("Don't have SetLayout\n");
1037         (*sha1)++;
1038     }
1039     else
1040     {
1041         pSetLayout(hdc, LAYOUT_RTL);
1042         PaintRgn(hdc, hrgn);
1043         PatBlt(hdc, 10, 250, 10, 10, PATCOPY);
1044         Rectangle(hdc, 100, 250, 110, 260);
1045         compare_hash(bmi, bits, sha1, "rtl");
1046         memset(bits, 0xcc, dib_size);
1047
1048         pSetLayout(hdc, LAYOUT_LTR);
1049     }
1050
1051     for(i = 0, y = 10; i < 256; i++)
1052     {
1053         BOOL ret;
1054
1055         if(!rop_uses_src(rop3[i]))
1056         {
1057             for(hatch_style = HS_HORIZONTAL; hatch_style <= HS_DIAGCROSS; hatch_style++)
1058             {
1059                 hatch_brush = CreateHatchBrush(hatch_style, RGB(0xff, 0, 0));
1060                 SelectObject(hdc, hatch_brush);
1061                 ret = PatBlt(hdc, 10 + i + 30 * hatch_style, y, 20, 20, rop3[i]);
1062                 ok(ret, "got FALSE for %x\n", rop3[i]);
1063                 SelectObject(hdc, orig_brush);
1064                 DeleteObject(hatch_brush);
1065             }
1066             y += 25;
1067         }
1068     }
1069
1070     compare_hash_broken_todo(bmi, bits, sha1, "hatch brushes", 1, FALSE); /* nt4 is different */
1071     memset(bits, 0xcc, dib_size);
1072
1073     /* overlapping blits */
1074
1075     orig_brush = SelectObject(hdc, solid_brush);
1076
1077     Rectangle(hdc, 10, 10, 100, 100);
1078     Rectangle(hdc, 20, 15, 30, 40);
1079     Rectangle(hdc, 15, 15, 20, 20);
1080     Rectangle(hdc, 15, 20, 50, 45);
1081     BitBlt( hdc, 20, 20, 100, 100, hdc, 10, 10, SRCCOPY );
1082     compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY +x, +y");
1083     memset(bits, 0xcc, dib_size);
1084
1085     Rectangle(hdc, 10, 10, 100, 100);
1086     Rectangle(hdc, 20, 15, 30, 40);
1087     Rectangle(hdc, 15, 15, 20, 20);
1088     Rectangle(hdc, 15, 20, 50, 45);
1089     BitBlt( hdc, 10, 10, 100, 100, hdc, 20, 20, SRCCOPY );
1090     if (bmi->bmiHeader.biBitCount == 1)  /* Windows gets this one wrong */
1091         compare_hash_broken_todo(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, -y",1, FALSE);
1092     else
1093         compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, -y");
1094     memset(bits, 0xcc, dib_size);
1095
1096     Rectangle(hdc, 10, 10, 100, 100);
1097     Rectangle(hdc, 20, 15, 30, 40);
1098     Rectangle(hdc, 15, 15, 20, 20);
1099     Rectangle(hdc, 15, 20, 50, 45);
1100     BitBlt( hdc, 20, 10, 100, 100, hdc, 10, 20, SRCCOPY );
1101     compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY +x, -y");
1102     memset(bits, 0xcc, dib_size);
1103
1104     Rectangle(hdc, 10, 10, 100, 100);
1105     Rectangle(hdc, 20, 15, 30, 40);
1106     Rectangle(hdc, 15, 15, 20, 20);
1107     Rectangle(hdc, 15, 20, 50, 45);
1108     BitBlt( hdc, 10, 20, 100, 100, hdc, 20, 10, SRCCOPY );
1109     if (bmi->bmiHeader.biBitCount == 1)  /* Windows gets this one wrong */
1110         compare_hash_broken_todo(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, +y", 1, FALSE );
1111     else
1112         compare_hash(bmi, bits, sha1, "overlapping BitBlt SRCCOPY -x, +y" );
1113     memset(bits, 0xcc, dib_size);
1114
1115     Rectangle(hdc, 10, 10, 100, 100);
1116     Rectangle(hdc, 20, 15, 30, 40);
1117     Rectangle(hdc, 15, 15, 20, 20);
1118     Rectangle(hdc, 15, 20, 50, 45);
1119     BitBlt( hdc, 20, 20, 100, 100, hdc, 10, 10, PATPAINT );
1120     compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT +x, +y");
1121     memset(bits, 0xcc, dib_size);
1122
1123     Rectangle(hdc, 10, 10, 100, 100);
1124     Rectangle(hdc, 20, 15, 30, 40);
1125     Rectangle(hdc, 15, 15, 20, 20);
1126     Rectangle(hdc, 15, 20, 50, 45);
1127     BitBlt( hdc, 10, 10, 100, 100, hdc, 20, 20, PATPAINT );
1128     compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT -x, -y");
1129     memset(bits, 0xcc, dib_size);
1130
1131     Rectangle(hdc, 10, 10, 100, 100);
1132     Rectangle(hdc, 20, 15, 30, 40);
1133     Rectangle(hdc, 15, 15, 20, 20);
1134     Rectangle(hdc, 15, 20, 50, 45);
1135     BitBlt( hdc, 20, 10, 100, 100, hdc, 10, 20, PATPAINT );
1136     if (bmi->bmiHeader.biBitCount >= 24)  /* Windows gets this one wrong */
1137         compare_hash_broken_todo(bmi, bits, sha1, "overlapping BitBlt PATPAINT +x, -y", 1, FALSE);
1138     else
1139         compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT +x, -y");
1140     memset(bits, 0xcc, dib_size);
1141
1142     Rectangle(hdc, 10, 10, 100, 100);
1143     Rectangle(hdc, 20, 15, 30, 40);
1144     Rectangle(hdc, 15, 15, 20, 20);
1145     Rectangle(hdc, 15, 20, 50, 45);
1146     BitBlt( hdc, 10, 20, 100, 100, hdc, 20, 10, PATPAINT );
1147     compare_hash(bmi, bits, sha1, "overlapping BitBlt PATPAINT -x, +y" );
1148     memset(bits, 0xcc, dib_size);
1149
1150     SelectObject(hdc, orig_brush);
1151     SelectObject(hdc, orig_pen);
1152     DeleteObject(hrgn);
1153     DeleteObject(dib_brush);
1154     DeleteObject(dashed_pen);
1155     DeleteObject(solid_brush);
1156     DeleteObject(solid_pen);
1157 }
1158
1159 static void test_simple_graphics(void)
1160 {
1161     char bmibuf[sizeof(BITMAPINFO) + 256 * sizeof(RGBQUAD)];
1162     BITMAPINFO *bmi = (BITMAPINFO *)bmibuf;
1163     DWORD *bit_fields = (DWORD*)(bmibuf + sizeof(BITMAPINFOHEADER));
1164     HDC mem_dc;
1165     BYTE *bits;
1166     HBITMAP dib, orig_bm;
1167     const char **sha1;
1168     DIBSECTION ds;
1169
1170     mem_dc = CreateCompatibleDC(NULL);
1171
1172     /* a8r8g8b8 */
1173     trace("8888\n");
1174     memset(bmi, 0, sizeof(bmibuf));
1175     bmi->bmiHeader.biSize = sizeof(bmi->bmiHeader);
1176     bmi->bmiHeader.biHeight = 512;
1177     bmi->bmiHeader.biWidth = 512;
1178     bmi->bmiHeader.biBitCount = 32;
1179     bmi->bmiHeader.biPlanes = 1;
1180     bmi->bmiHeader.biCompression = BI_RGB;
1181
1182     dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1183     ok(dib != NULL, "ret NULL\n");
1184     ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1185     ok(ds.dsBitfields[0] == 0, "got %08x\n", ds.dsBitfields[0]);
1186     ok(ds.dsBitfields[1] == 0, "got %08x\n", ds.dsBitfields[1]);
1187     ok(ds.dsBitfields[2] == 0, "got %08x\n", ds.dsBitfields[2]);
1188     ok(ds.dsBmih.biCompression == BI_RGB ||
1189        broken(ds.dsBmih.biCompression == BI_BITFIELDS), /* nt4 sp1 and 2 */
1190        "got %x\n", ds.dsBmih.biCompression);
1191
1192     orig_bm = SelectObject(mem_dc, dib);
1193
1194     sha1 = sha1_graphics_a8r8g8b8;
1195     draw_graphics(mem_dc, bmi, bits, &sha1);
1196
1197     SelectObject(mem_dc, orig_bm);
1198     DeleteObject(dib);
1199
1200     /* a8r8g8b8 - bitfields.  Should be the same as the regular 32 bit case.*/
1201     trace("8888 - bitfields\n");
1202     bmi->bmiHeader.biBitCount = 32;
1203     bmi->bmiHeader.biCompression = BI_BITFIELDS;
1204     bit_fields[0] = 0xff0000;
1205     bit_fields[1] = 0x00ff00;
1206     bit_fields[2] = 0x0000ff;
1207
1208     dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1209     ok(dib != NULL, "ret NULL\n");
1210     ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1211     ok(ds.dsBitfields[0] == 0xff0000, "got %08x\n", ds.dsBitfields[0]);
1212     ok(ds.dsBitfields[1] == 0x00ff00, "got %08x\n", ds.dsBitfields[1]);
1213     ok(ds.dsBitfields[2] == 0x0000ff, "got %08x\n", ds.dsBitfields[2]);
1214     ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1215
1216     orig_bm = SelectObject(mem_dc, dib);
1217
1218     sha1 = sha1_graphics_a8r8g8b8;
1219     draw_graphics(mem_dc, bmi, bits, &sha1);
1220
1221     SelectObject(mem_dc, orig_bm);
1222     DeleteObject(dib);
1223
1224     /* a8b8g8r8 - bitfields. */
1225     trace("a8b8g8r8 - bitfields\n");
1226     bmi->bmiHeader.biBitCount = 32;
1227     bmi->bmiHeader.biCompression = BI_BITFIELDS;
1228     bit_fields[0] = 0x0000ff;
1229     bit_fields[1] = 0x00ff00;
1230     bit_fields[2] = 0xff0000;
1231
1232     dib = CreateDIBSection(mem_dc, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1233     ok(dib != NULL, "ret NULL\n");
1234     ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1235     ok(ds.dsBitfields[0] == 0x0000ff, "got %08x\n", ds.dsBitfields[0]);
1236     ok(ds.dsBitfields[1] == 0x00ff00, "got %08x\n", ds.dsBitfields[1]);
1237     ok(ds.dsBitfields[2] == 0xff0000, "got %08x\n", ds.dsBitfields[2]);
1238     ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1239
1240     orig_bm = SelectObject(mem_dc, dib);
1241
1242     sha1 = sha1_graphics_a8b8g8r8;
1243     draw_graphics(mem_dc, bmi, bits, &sha1);
1244
1245     SelectObject(mem_dc, orig_bm);
1246     DeleteObject(dib);
1247
1248     /* 24 */
1249     trace("24\n");
1250     bmi->bmiHeader.biBitCount = 24;
1251     bmi->bmiHeader.biCompression = BI_RGB;
1252
1253     dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1254     ok(dib != NULL, "ret NULL\n");
1255     orig_bm = SelectObject(mem_dc, dib);
1256
1257     sha1 = sha1_graphics_24;
1258     draw_graphics(mem_dc, bmi, bits, &sha1);
1259
1260     SelectObject(mem_dc, orig_bm);
1261     DeleteObject(dib);
1262
1263     /* r5g5b5 */
1264     trace("555\n");
1265     bmi->bmiHeader.biBitCount = 16;
1266     bmi->bmiHeader.biCompression = BI_RGB;
1267
1268     dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1269     ok(dib != NULL, "ret NULL\n");
1270     ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1271     ok(ds.dsBitfields[0] == 0x7c00, "got %08x\n", ds.dsBitfields[0]);
1272     ok(ds.dsBitfields[1] == 0x03e0, "got %08x\n", ds.dsBitfields[1]);
1273     ok(ds.dsBitfields[2] == 0x001f, "got %08x\n", ds.dsBitfields[2]);
1274     ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1275
1276     orig_bm = SelectObject(mem_dc, dib);
1277
1278     sha1 = sha1_graphics_r5g5b5;
1279     draw_graphics(mem_dc, bmi, bits, &sha1);
1280
1281     SelectObject(mem_dc, orig_bm);
1282     DeleteObject(dib);
1283
1284     /* r4g4b4 */
1285     trace("444\n");
1286     bmi->bmiHeader.biBitCount = 16;
1287     bmi->bmiHeader.biCompression = BI_BITFIELDS;
1288     bit_fields[0] = 0x0f00;
1289     bit_fields[1] = 0x00f0;
1290     bit_fields[2] = 0x000f;
1291     dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1292     ok(dib != NULL, "ret NULL\n");
1293     ok(GetObjectW( dib, sizeof(ds), &ds ), "GetObject failed\n");
1294     ok(ds.dsBitfields[0] == 0x0f00, "got %08x\n", ds.dsBitfields[0]);
1295     ok(ds.dsBitfields[1] == 0x00f0, "got %08x\n", ds.dsBitfields[1]);
1296     ok(ds.dsBitfields[2] == 0x000f, "got %08x\n", ds.dsBitfields[2]);
1297     ok(ds.dsBmih.biCompression == BI_BITFIELDS, "got %x\n", ds.dsBmih.biCompression);
1298
1299     orig_bm = SelectObject(mem_dc, dib);
1300
1301     sha1 = sha1_graphics_r4g4b4;
1302     draw_graphics(mem_dc, bmi, bits, &sha1);
1303
1304     SelectObject(mem_dc, orig_bm);
1305     DeleteObject(dib);
1306
1307     /* 8 */
1308     trace("8\n");
1309     bmi->bmiHeader.biBitCount = 8;
1310     bmi->bmiHeader.biCompression = BI_RGB;
1311     bmi->bmiHeader.biClrUsed = 5;
1312     bmi->bmiColors[0].rgbRed = 0xff;
1313     bmi->bmiColors[0].rgbGreen = 0xff;
1314     bmi->bmiColors[0].rgbBlue = 0xff;
1315     bmi->bmiColors[1].rgbRed = 0;
1316     bmi->bmiColors[1].rgbGreen = 0;
1317     bmi->bmiColors[1].rgbBlue = 0;
1318     bmi->bmiColors[2].rgbRed = 0xff;
1319     bmi->bmiColors[2].rgbGreen = 0;
1320     bmi->bmiColors[2].rgbBlue = 0;
1321     bmi->bmiColors[3].rgbRed = 0;
1322     bmi->bmiColors[3].rgbGreen = 0xff;
1323     bmi->bmiColors[3].rgbBlue = 0;
1324     bmi->bmiColors[4].rgbRed = 0;
1325     bmi->bmiColors[4].rgbGreen = 0;
1326     bmi->bmiColors[4].rgbBlue = 0xff;
1327
1328     dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1329     ok(dib != NULL, "ret NULL\n");
1330
1331     orig_bm = SelectObject(mem_dc, dib);
1332
1333     sha1 = sha1_graphics_8;
1334     draw_graphics(mem_dc, bmi, bits, &sha1);
1335
1336     SelectObject(mem_dc, orig_bm);
1337     DeleteObject(dib);
1338
1339     /* 4 */
1340     trace("4\n");
1341     bmi->bmiHeader.biBitCount = 4;
1342
1343     dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1344     ok(dib != NULL, "ret NULL\n");
1345
1346     orig_bm = SelectObject(mem_dc, dib);
1347
1348     sha1 = sha1_graphics_4;
1349     draw_graphics(mem_dc, bmi, bits, &sha1);
1350
1351     SelectObject(mem_dc, orig_bm);
1352     DeleteObject(dib);
1353
1354     /* 1 */
1355     trace("1\n");
1356     bmi->bmiHeader.biBitCount = 1;
1357     bmi->bmiHeader.biClrUsed = 2;
1358
1359     bmi->bmiColors[0].rgbRed = 0x00;
1360     bmi->bmiColors[0].rgbGreen = 0x01;
1361     bmi->bmiColors[0].rgbBlue = 0xff;
1362     bmi->bmiColors[1].rgbRed = 0xff;
1363     bmi->bmiColors[1].rgbGreen = 0x00;
1364     bmi->bmiColors[1].rgbBlue = 0x00;
1365
1366     dib = CreateDIBSection(0, bmi, DIB_RGB_COLORS, (void**)&bits, NULL, 0);
1367     ok(dib != NULL, "ret NULL\n");
1368
1369     orig_bm = SelectObject(mem_dc, dib);
1370
1371     sha1 = sha1_graphics_1;
1372     draw_graphics(mem_dc, bmi, bits, &sha1);
1373
1374     SelectObject(mem_dc, orig_bm);
1375     DeleteObject(dib);
1376
1377     DeleteDC(mem_dc);
1378 }
1379
1380 START_TEST(dib)
1381 {
1382     HMODULE mod = GetModuleHandleA("gdi32.dll");
1383     pSetLayout = (void *)GetProcAddress( mod, "SetLayout" );
1384
1385     CryptAcquireContextW(&crypt_prov, NULL, NULL, PROV_RSA_FULL, CRYPT_VERIFYCONTEXT);
1386
1387     test_simple_graphics();
1388
1389     CryptReleaseContext(crypt_prov, 0);
1390 }