git.oblomov.eu Git - wine/blob - dlls/oleaut32/tests/olepicture.c

   1 /*
   2  * OLEPICTURE test program
   3  *
   4  * Copyright 2005 Marcus Meissner
   5  *
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Lesser General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2.1 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Lesser General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Lesser General Public
  18  * License along with this library; if not, write to the Free Software
  19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  20  */
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24 #include <math.h>
  25 #include <float.h>
  26
  27 #define COBJMACROS
  28 #define CONST_VTABLE
  29 #define NONAMELESSUNION
  30
  31 #include "wine/test.h"
  32 #include <windef.h>
  33 #include <winbase.h>
  34 #include <winuser.h>
  35 #include <wingdi.h>
  36 #include <winnls.h>
  37 #include <winerror.h>
  38 #include <winnt.h>
  39
  40 #include <urlmon.h>
  41 #include <wtypes.h>
  42 #include <olectl.h>
  43 #include <objidl.h>
  44
  45 #define expect_eq(expr, value, type, format) { type ret = (expr); ok((value) == ret, #expr " expected " format " got " format "\n", value, ret); }
  46
  47 #define ole_expect(expr, expect) { \
  48     HRESULT r = expr; \
  49     ok(r == (expect), #expr " returned %x, expected %s (%x)\n", r, #expect, expect); \
  50 }
  51
  52 #define ole_check(expr) ole_expect(expr, S_OK);
  53
  54 static HMODULE hOleaut32;
  55
  56 static HRESULT (WINAPI *pOleLoadPicture)(LPSTREAM,LONG,BOOL,REFIID,LPVOID*);
  57 static HRESULT (WINAPI *pOleCreatePictureIndirect)(PICTDESC*,REFIID,BOOL,LPVOID*);
  58
  59 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
  60
  61 /* 1x1 pixel gif */
  62 static const unsigned char gifimage[35] = {
  63 0x47,0x49,0x46,0x38,0x37,0x61,0x01,0x00,0x01,0x00,0x80,0x00,0x00,0xff,0xff,0xff,
  64 0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x02,0x02,0x44,
  65 0x01,0x00,0x3b
  66 };
  67
  68 /* 1x1 pixel jpg */
  69 static const unsigned char jpgimage[285] = {
  70 0xff,0xd8,0xff,0xe0,0x00,0x10,0x4a,0x46,0x49,0x46,0x00,0x01,0x01,0x01,0x01,0x2c,
  71 0x01,0x2c,0x00,0x00,0xff,0xdb,0x00,0x43,0x00,0x05,0x03,0x04,0x04,0x04,0x03,0x05,
  72 0x04,0x04,0x04,0x05,0x05,0x05,0x06,0x07,0x0c,0x08,0x07,0x07,0x07,0x07,0x0f,0x0b,
  73 0x0b,0x09,0x0c,0x11,0x0f,0x12,0x12,0x11,0x0f,0x11,0x11,0x13,0x16,0x1c,0x17,0x13,
  74 0x14,0x1a,0x15,0x11,0x11,0x18,0x21,0x18,0x1a,0x1d,0x1d,0x1f,0x1f,0x1f,0x13,0x17,
  75 0x22,0x24,0x22,0x1e,0x24,0x1c,0x1e,0x1f,0x1e,0xff,0xdb,0x00,0x43,0x01,0x05,0x05,
  76 0x05,0x07,0x06,0x07,0x0e,0x08,0x08,0x0e,0x1e,0x14,0x11,0x14,0x1e,0x1e,0x1e,0x1e,
  77 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
  78 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,
  79 0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0x1e,0xff,0xc0,
  80 0x00,0x11,0x08,0x00,0x01,0x00,0x01,0x03,0x01,0x22,0x00,0x02,0x11,0x01,0x03,0x11,
  81 0x01,0xff,0xc4,0x00,0x15,0x00,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  82 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x08,0xff,0xc4,0x00,0x14,0x10,0x01,0x00,0x00,
  83 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xc4,
  84 0x00,0x14,0x01,0x01,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,
  85 0x00,0x00,0x00,0x00,0xff,0xc4,0x00,0x14,0x11,0x01,0x00,0x00,0x00,0x00,0x00,0x00,
  86 0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0xff,0xda,0x00,0x0c,0x03,0x01,
  87 0x00,0x02,0x11,0x03,0x11,0x00,0x3f,0x00,0xb2,0xc0,0x07,0xff,0xd9
  88 };
  89
  90 /* 1x1 pixel png */
  91 static const unsigned char pngimage[285] = {
  92 0x89,0x50,0x4e,0x47,0x0d,0x0a,0x1a,0x0a,0x00,0x00,0x00,0x0d,0x49,0x48,0x44,0x52,
  93 0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x08,0x02,0x00,0x00,0x00,0x90,0x77,0x53,
  94 0xde,0x00,0x00,0x00,0x09,0x70,0x48,0x59,0x73,0x00,0x00,0x0b,0x13,0x00,0x00,0x0b,
  95 0x13,0x01,0x00,0x9a,0x9c,0x18,0x00,0x00,0x00,0x07,0x74,0x49,0x4d,0x45,0x07,0xd5,
  96 0x06,0x03,0x0f,0x07,0x2d,0x12,0x10,0xf0,0xfd,0x00,0x00,0x00,0x0c,0x49,0x44,0x41,
  97 0x54,0x08,0xd7,0x63,0xf8,0xff,0xff,0x3f,0x00,0x05,0xfe,0x02,0xfe,0xdc,0xcc,0x59,
  98 0xe7,0x00,0x00,0x00,0x00,0x49,0x45,0x4e,0x44,0xae,0x42,0x60,0x82
  99 };
 100
 101 /* 1x1 pixel bmp */
 102 static const unsigned char bmpimage[66] = {
 103 0x42,0x4d,0x42,0x00,0x00,0x00,0x00,0x00,0x00,0x00,0x3e,0x00,0x00,0x00,0x28,0x00,
 104 0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x00,0x00,0x01,0x00,0x01,0x00,0x00,0x00,
 105 0x00,0x00,0x04,0x00,0x00,0x00,0x12,0x0b,0x00,0x00,0x12,0x0b,0x00,0x00,0x02,0x00,
 106 0x00,0x00,0x02,0x00,0x00,0x00,0xff,0xff,0xff,0x00,0xff,0xff,0xff,0x00,0x00,0x00,
 107 0x00,0x00
 108 };
 109
 110 /* 2x2 pixel gif */
 111 static const unsigned char gif4pixel[42] = {
 112 0x47,0x49,0x46,0x38,0x37,0x61,0x02,0x00,0x02,0x00,0xa1,0x00,0x00,0x00,0x00,0x00,
 113 0x39,0x62,0xfc,0xff,0x1a,0xe5,0xff,0xff,0xff,0x2c,0x00,0x00,0x00,0x00,0x02,0x00,
 114 0x02,0x00,0x00,0x02,0x03,0x14,0x16,0x05,0x00,0x3b
 115 };
 116
 117 /* APM with an empty metafile with some padding zeros - looks like under Window the
 118  * metafile data should be at least 20 bytes */
 119 static const unsigned char apmdata[] = {
 120 0xd7,0xcd,0xc6,0x9a, 0x00,0x00,0x00,0x00, 0x00,0x00,0xee,0x02, 0xb1,0x03,0xa0,0x05,
 121 0x00,0x00,0x00,0x00, 0xee,0x53,0x01,0x00, 0x09,0x00,0x00,0x03, 0x13,0x00,0x00,0x00,
 122 0x01,0x00,0x05,0x00, 0x00,0x00,0x00,0x00, 0x03,0x00,0x00,0x00, 0x00,0x00,0x00,0x00,
 123 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00, 0x00,0x00,0x00,0x00
 124 };
 125
 126 /* MF_TEXTOUT_ON_PATH_BITS from gdi32/tests/metafile.c */
 127 static const unsigned char metafile[] = {
 128     0x01, 0x00, 0x09, 0x00, 0x00, 0x03, 0x19, 0x00,
 129     0x00, 0x00, 0x00, 0x00, 0x0d, 0x00, 0x00, 0x00,
 130     0x00, 0x00, 0x0d, 0x00, 0x00, 0x00, 0x32, 0x0a,
 131     0x16, 0x00, 0x0b, 0x00, 0x04, 0x00, 0x00, 0x00,
 132     0x54, 0x65, 0x73, 0x74, 0x03, 0x00, 0x05, 0x00,
 133     0x08, 0x00, 0x0c, 0x00, 0x03, 0x00, 0x00, 0x00,
 134     0x00, 0x00
 135 };
 136
 137 /* EMF_TEXTOUT_ON_PATH_BITS from gdi32/tests/metafile.c */
 138 static const unsigned char enhmetafile[] = {
 139     0x01, 0x00, 0x00, 0x00, 0x6c, 0x00, 0x00, 0x00,
 140     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 141     0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
 142     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 143     0xe7, 0xff, 0xff, 0xff, 0xe9, 0xff, 0xff, 0xff,
 144     0x20, 0x45, 0x4d, 0x46, 0x00, 0x00, 0x01, 0x00,
 145     0xf4, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 146     0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 147     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 148     0x00, 0x05, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
 149     0x40, 0x01, 0x00, 0x00, 0xf0, 0x00, 0x00, 0x00,
 150     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 151     0x00, 0x00, 0x00, 0x00, 0x00, 0xe2, 0x04, 0x00,
 152     0x80, 0xa9, 0x03, 0x00, 0x3b, 0x00, 0x00, 0x00,
 153     0x08, 0x00, 0x00, 0x00, 0x54, 0x00, 0x00, 0x00,
 154     0x64, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 155     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 156     0xff, 0xff, 0xff, 0xff, 0x01, 0x00, 0x00, 0x00,
 157     0x00, 0x00, 0xc8, 0x41, 0x00, 0x80, 0xbb, 0x41,
 158     0x0b, 0x00, 0x00, 0x00, 0x16, 0x00, 0x00, 0x00,
 159     0x04, 0x00, 0x00, 0x00, 0x4c, 0x00, 0x00, 0x00,
 160     0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 161     0x00, 0x00, 0x00, 0x00, 0xff, 0xff, 0xff, 0xff,
 162     0xff, 0xff, 0xff, 0xff, 0x54, 0x00, 0x00, 0x00,
 163     0x54, 0x00, 0x65, 0x00, 0x73, 0x00, 0x74, 0x00,
 164     0x03, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
 165     0x08, 0x00, 0x00, 0x00, 0x0c, 0x00, 0x00, 0x00,
 166     0x3c, 0x00, 0x00, 0x00, 0x08, 0x00, 0x00, 0x00,
 167     0x0e, 0x00, 0x00, 0x00, 0x14, 0x00, 0x00, 0x00,
 168     0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00, 0x00,
 169     0x14, 0x00, 0x00, 0x00
 170 };
 171
 172
 173 typedef struct NoStatStreamImpl
 174 {
 175         IStream                 IStream_iface;
 176         LONG                    ref;
 177
 178         HGLOBAL                 supportHandle;
 179         ULARGE_INTEGER          streamSize;
 180         ULARGE_INTEGER          currentPosition;
 181 } NoStatStreamImpl;
 182
 183 static IStream* NoStatStream_Construct(HGLOBAL hGlobal);
 184
 185 static void
 186 test_pic_with_stream(LPSTREAM stream, unsigned int imgsize)
 187 {
 188         IPicture*       pic = NULL;
 189         HRESULT         hres;
 190         LPVOID          pvObj = NULL;
 191         OLE_HANDLE      handle, hPal;
 192         OLE_XSIZE_HIMETRIC      width;
 193         OLE_YSIZE_HIMETRIC      height;
 194         short           type;
 195         DWORD           attr;
 196         ULONG           res;
 197
 198         pvObj = NULL;
 199         hres = pOleLoadPicture(stream, imgsize, TRUE, &IID_IPicture, &pvObj);
 200         pic = pvObj;
 201
 202         ok(hres == S_OK,"OLP (NULL,..) does not return 0, but 0x%08x\n",hres);
 203         ok(pic != NULL,"OLP (NULL,..) returns NULL, instead of !NULL\n");
 204         if (pic == NULL)
 205                 return;
 206
 207         pvObj = NULL;
 208         hres = IPicture_QueryInterface (pic, &IID_IPicture, &pvObj);
 209
 210         ok(hres == S_OK,"IPicture_QI does not return S_OK, but 0x%08x\n", hres);
 211         ok(pvObj != NULL,"IPicture_QI does return NULL, instead of a ptr\n");
 212
 213         IPicture_Release ((IPicture*)pvObj);
 214
 215         handle = 0;
 216         hres = IPicture_get_Handle (pic, &handle);
 217         ok(hres == S_OK,"IPicture_get_Handle does not return S_OK, but 0x%08x\n", hres);
 218         ok(handle != 0, "IPicture_get_Handle returns a NULL handle, but it should be non NULL\n");
 219
 220         if (handle)
 221         {
 222             BITMAP bmp;
 223             GetObject(UlongToHandle(handle), sizeof(BITMAP), &bmp);
 224             todo_wine ok(bmp.bmBits != 0, "not a dib\n");
 225         }
 226
 227         width = 0;
 228         hres = IPicture_get_Width (pic, &width);
 229         ok(hres == S_OK,"IPicture_get_Width does not return S_OK, but 0x%08x\n", hres);
 230         ok(width != 0, "IPicture_get_Width returns 0, but it should not be 0.\n");
 231
 232         height = 0;
 233         hres = IPicture_get_Height (pic, &height);
 234         ok(hres == S_OK,"IPicture_get_Height does not return S_OK, but 0x%08x\n", hres);
 235         ok(height != 0, "IPicture_get_Height returns 0, but it should not be 0.\n");
 236
 237         type = 0;
 238         hres = IPicture_get_Type (pic, &type);
 239         ok(hres == S_OK,"IPicture_get_Type does not return S_OK, but 0x%08x\n", hres);
 240         ok(type == PICTYPE_BITMAP, "IPicture_get_Type returns %d, but it should be PICTYPE_BITMAP(%d).\n", type, PICTYPE_BITMAP);
 241
 242         attr = 0;
 243         hres = IPicture_get_Attributes (pic, &attr);
 244         ok(hres == S_OK,"IPicture_get_Attributes does not return S_OK, but 0x%08x\n", hres);
 245         ok(attr == 0, "IPicture_get_Attributes returns %d, but it should be 0.\n", attr);
 246
 247         hPal = 0;
 248         hres = IPicture_get_hPal (pic, &hPal);
 249         ok(hres == S_OK,"IPicture_get_hPal does not return S_OK, but 0x%08x\n", hres);
 250         /* a single pixel b/w image has no palette */
 251         ok(hPal == 0, "IPicture_get_hPal returns %d, but it should be 0.\n", hPal);
 252
 253         res = IPicture_Release (pic);
 254         ok (res == 0, "refcount after release is %d, but should be 0?\n", res);
 255 }
 256
 257 static void
 258 test_pic(const unsigned char *imgdata, unsigned int imgsize)
 259 {
 260         LPSTREAM        stream;
 261         HGLOBAL         hglob;
 262         LPBYTE          data;
 263         HRESULT         hres;
 264         LARGE_INTEGER   seekto;
 265         ULARGE_INTEGER  newpos1;
 266         DWORD *         header;
 267         unsigned int    i,j;
 268
 269         /* Let the fun begin */
 270         hglob = GlobalAlloc (0, imgsize);
 271         data = GlobalLock (hglob);
 272         memcpy(data, imgdata, imgsize);
 273         GlobalUnlock(hglob); data = NULL;
 274
 275         hres = CreateStreamOnHGlobal (hglob, FALSE, &stream);
 276         ok (hres == S_OK, "createstreamonhglobal failed? doubt it... hres 0x%08x\n", hres);
 277
 278         memset(&seekto,0,sizeof(seekto));
 279         hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 280         ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 281         test_pic_with_stream(stream, imgsize);
 282
 283         IStream_Release(stream);
 284
 285         /* again with Non Statable and Non Seekable stream */
 286         stream = NoStatStream_Construct(hglob);
 287         hglob = 0;  /* Non-statable impl always deletes on release */
 288         test_pic_with_stream(stream, 0);
 289
 290         IStream_Release(stream);
 291         for (i = 1; i <= 8; i++) {
 292                 /* more fun!!! */
 293                 hglob = GlobalAlloc (0, imgsize + i * (2 * sizeof(DWORD)));
 294                 data = GlobalLock (hglob);
 295                 header = (DWORD *)data;
 296
 297                 /* multiple copies of header */
 298                 memcpy(data,"lt\0\0",4);
 299                 header[1] = imgsize;
 300                 for (j = 2; j <= i; j++) {
 301                         memcpy(&(header[2 * (j - 1)]), header, 2 * sizeof(DWORD));
 302                 }
 303                 memcpy(data + i * (2 * sizeof(DWORD)), imgdata, imgsize);
 304                 GlobalUnlock(hglob); data = NULL;
 305
 306                 hres = CreateStreamOnHGlobal (hglob, FALSE, &stream);
 307                 ok (hres == S_OK, "createstreamonhglobal failed? doubt it... hres 0x%08x\n", hres);
 308
 309                 memset(&seekto,0,sizeof(seekto));
 310                 hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 311                 ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 312                 test_pic_with_stream(stream, imgsize);
 313
 314                 IStream_Release(stream);
 315
 316                 /* again with Non Statable and Non Seekable stream */
 317                 stream = NoStatStream_Construct(hglob);
 318                 hglob = 0;  /* Non-statable impl always deletes on release */
 319                 test_pic_with_stream(stream, 0);
 320
 321                 IStream_Release(stream);
 322         }
 323 }
 324
 325 static void test_empty_image(void) {
 326         LPBYTE          data;
 327         LPSTREAM        stream;
 328         IPicture*       pic = NULL;
 329         HRESULT         hres;
 330         LPVOID          pvObj = NULL;
 331         HGLOBAL         hglob;
 332         OLE_HANDLE      handle;
 333         ULARGE_INTEGER  newpos1;
 334         LARGE_INTEGER   seekto;
 335         short           type;
 336         DWORD           attr;
 337
 338         /* Empty image. Happens occasionally in VB programs. */
 339         hglob = GlobalAlloc (0, 8);
 340         data = GlobalLock (hglob);
 341         memcpy(data,"lt\0\0",4);
 342         ((DWORD*)data)[1] = 0;
 343         hres = CreateStreamOnHGlobal (hglob, TRUE, &stream);
 344         ok (hres == S_OK, "CreatestreamOnHGlobal failed? doubt it... hres 0x%08x\n", hres);
 345
 346         memset(&seekto,0,sizeof(seekto));
 347         hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 348         ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 349
 350         pvObj = NULL;
 351         hres = pOleLoadPicture(stream, 8, TRUE, &IID_IPicture, &pvObj);
 352         pic = pvObj;
 353         ok(hres == S_OK,"empty picture not loaded, hres 0x%08x\n", hres);
 354         ok(pic != NULL,"empty picture not loaded, pic is NULL\n");
 355
 356         hres = IPicture_get_Type (pic, &type);
 357         ok (hres == S_OK,"empty picture get type failed with hres 0x%08x\n", hres);
 358         ok (type == PICTYPE_NONE,"type is %d, but should be PICTYPE_NONE(0)\n", type);
 359
 360         attr = 0xdeadbeef;
 361         hres = IPicture_get_Attributes (pic, &attr);
 362         ok (hres == S_OK,"empty picture get attributes failed with hres 0x%08x\n", hres);
 363         ok (attr == 0,"attr is %d, but should be 0\n", attr);
 364
 365         hres = IPicture_get_Handle (pic, &handle);
 366         ok (hres == S_OK,"empty picture get handle failed with hres 0x%08x\n", hres);
 367         ok (handle == 0, "empty picture get handle did not return 0, but 0x%08x\n", handle);
 368         IPicture_Release (pic);
 369         IStream_Release (stream);
 370 }
 371
 372 static void test_empty_image_2(void) {
 373         LPBYTE          data;
 374         LPSTREAM        stream;
 375         IPicture*       pic = NULL;
 376         HRESULT         hres;
 377         LPVOID          pvObj = NULL;
 378         HGLOBAL         hglob;
 379         ULARGE_INTEGER  newpos1;
 380         LARGE_INTEGER   seekto;
 381         short           type;
 382
 383         /* Empty image at random stream position. */
 384         hglob = GlobalAlloc (0, 200);
 385         data = GlobalLock (hglob);
 386         data += 42;
 387         memcpy(data,"lt\0\0",4);
 388         ((DWORD*)data)[1] = 0;
 389         hres = CreateStreamOnHGlobal (hglob, TRUE, &stream);
 390         ok (hres == S_OK, "CreatestreamOnHGlobal failed? doubt it... hres 0x%08x\n", hres);
 391
 392         memset(&seekto,0,sizeof(seekto));
 393         seekto.u.LowPart = 42;
 394         hres = IStream_Seek(stream,seekto,SEEK_CUR,&newpos1);
 395         ok (hres == S_OK, "istream seek failed? doubt it... hres 0x%08x\n", hres);
 396
 397         pvObj = NULL;
 398         hres = pOleLoadPicture(stream, 8, TRUE, &IID_IPicture, &pvObj);
 399         pic = pvObj;
 400         ok(hres == S_OK,"empty picture not loaded, hres 0x%08x\n", hres);
 401         ok(pic != NULL,"empty picture not loaded, pic is NULL\n");
 402
 403         hres = IPicture_get_Type (pic, &type);
 404         ok (hres == S_OK,"empty picture get type failed with hres 0x%08x\n", hres);
 405         ok (type == PICTYPE_NONE,"type is %d, but should be PICTYPE_NONE(0)\n", type);
 406
 407         IPicture_Release (pic);
 408         IStream_Release (stream);
 409 }
 410
 411 static void test_Invoke(void)
 412 {
 413     IPictureDisp *picdisp;
 414     HRESULT hr;
 415     VARIANTARG vararg;
 416     DISPPARAMS dispparams;
 417     VARIANT varresult;
 418     IStream *stream;
 419     HGLOBAL hglob;
 420     void *data;
 421
 422     hglob = GlobalAlloc (0, sizeof(gifimage));
 423     data = GlobalLock(hglob);
 424     memcpy(data, gifimage, sizeof(gifimage));
 425     GlobalUnlock(hglob);
 426
 427     hr = CreateStreamOnHGlobal (hglob, FALSE, &stream);
 428     ok_ole_success(hr, "CreateStreamOnHGlobal");
 429
 430     hr = pOleLoadPicture(stream, sizeof(gifimage), TRUE, &IID_IPictureDisp, (void **)&picdisp);
 431     IStream_Release(stream);
 432     GlobalFree(hglob);
 433     ok_ole_success(hr, "OleLoadPicture");
 434
 435     V_VT(&vararg) = VT_BOOL;
 436     V_BOOL(&vararg) = VARIANT_FALSE;
 437     dispparams.cNamedArgs = 0;
 438     dispparams.rgdispidNamedArgs = NULL;
 439     dispparams.cArgs = 1;
 440     dispparams.rgvarg = &vararg;
 441     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_IPictureDisp, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 442     ok(hr == DISP_E_UNKNOWNNAME, "IPictureDisp_Invoke should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n", hr);
 443     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_IUnknown, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 444     ok(hr == DISP_E_UNKNOWNNAME, "IPictureDisp_Invoke should have returned DISP_E_UNKNOWNNAME instead of 0x%08x\n", hr);
 445
 446     dispparams.cArgs = 0;
 447     dispparams.rgvarg = NULL;
 448     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYPUT, &dispparams, NULL, NULL, NULL);
 449     ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
 450
 451     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYPUT, NULL, NULL, NULL, NULL);
 452     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 453
 454     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, NULL, NULL, NULL);
 455     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 456
 457     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, NULL, &varresult, NULL, NULL);
 458     ok(hr == DISP_E_PARAMNOTOPTIONAL, "IPictureDisp_Invoke should have returned DISP_E_PARAMNOTOPTIONAL instead of 0x%08x\n", hr);
 459
 460     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 461     ok_ole_success(hr, "IPictureDisp_Invoke");
 462     ok(V_VT(&varresult) == VT_I4, "V_VT(&varresult) should have been VT_UINT instead of %d\n", V_VT(&varresult));
 463
 464     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_METHOD, &dispparams, &varresult, NULL, NULL);
 465     ok(hr == DISP_E_MEMBERNOTFOUND, "IPictureDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 466
 467     hr = IPictureDisp_Invoke(picdisp, 0xdeadbeef, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 468     ok(hr == DISP_E_MEMBERNOTFOUND, "IPictureDisp_Invoke should have returned DISP_E_MEMBERNOTFOUND instead of 0x%08x\n", hr);
 469
 470     dispparams.cArgs = 1;
 471     dispparams.rgvarg = &vararg;
 472     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 473     ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
 474
 475     dispparams.cArgs = 1;
 476     dispparams.rgvarg = &vararg;
 477     hr = IPictureDisp_Invoke(picdisp, DISPID_PICT_HPAL, &IID_NULL, 0, DISPATCH_PROPERTYGET, &dispparams, &varresult, NULL, NULL);
 478     ok(hr == DISP_E_BADPARAMCOUNT, "IPictureDisp_Invoke should have returned DISP_E_BADPARAMCOUNT instead of 0x%08x\n", hr);
 479
 480     IPictureDisp_Release(picdisp);
 481 }
 482
 483 static void test_OleCreatePictureIndirect(void)
 484 {
 485     OLE_HANDLE handle;
 486     IPicture *pict;
 487     HRESULT hr;
 488     short type;
 489
 490     if(!pOleCreatePictureIndirect)
 491     {
 492         win_skip("Skipping OleCreatePictureIndirect tests\n");
 493         return;
 494     }
 495
 496 if (0)
 497 {
 498     /* crashes on native */
 499     pOleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, NULL);
 500 }
 501
 502     hr = pOleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (void**)&pict);
 503     ok(hr == S_OK, "hr %08x\n", hr);
 504
 505     type = PICTYPE_NONE;
 506     hr = IPicture_get_Type(pict, &type);
 507     ok(hr == S_OK, "hr %08x\n", hr);
 508     ok(type == PICTYPE_UNINITIALIZED, "type %d\n", type);
 509
 510     handle = 0xdeadbeef;
 511     hr = IPicture_get_Handle(pict, &handle);
 512     ok(hr == S_OK, "hr %08x\n", hr);
 513     ok(handle == 0, "handle %08x\n", handle);
 514
 515     IPicture_Release(pict);
 516 }
 517
 518 static void test_apm(void)
 519 {
 520     OLE_HANDLE handle;
 521     LPSTREAM stream;
 522     IPicture *pict;
 523     HGLOBAL hglob;
 524     LPBYTE *data;
 525     LONG cxy;
 526     BOOL keep;
 527     short type;
 528
 529     hglob = GlobalAlloc (0, sizeof(apmdata));
 530     data = GlobalLock(hglob);
 531     memcpy(data, apmdata, sizeof(apmdata));
 532
 533     ole_check(CreateStreamOnHGlobal(hglob, TRUE, &stream));
 534     ole_check(OleLoadPictureEx(stream, sizeof(apmdata), TRUE, &IID_IPicture, 100, 100, 0, (LPVOID *)&pict));
 535
 536     ole_check(IPicture_get_Handle(pict, &handle));
 537     ok(handle != 0, "handle is null\n");
 538
 539     ole_check(IPicture_get_Type(pict, &type));
 540     expect_eq(type, PICTYPE_METAFILE, short, "%d");
 541
 542     ole_check(IPicture_get_Height(pict, &cxy));
 543     expect_eq(cxy,  1667, LONG, "%d");
 544
 545     ole_check(IPicture_get_Width(pict, &cxy));
 546     expect_eq(cxy,  1323, LONG, "%d");
 547
 548     ole_check(IPicture_get_KeepOriginalFormat(pict, &keep));
 549     todo_wine expect_eq(keep, FALSE, LONG, "%d");
 550
 551     ole_expect(IPicture_get_hPal(pict, &handle), E_FAIL);
 552     IPicture_Release(pict);
 553     IStream_Release(stream);
 554 }
 555
 556 static void test_metafile(void)
 557 {
 558     LPSTREAM stream;
 559     IPicture *pict;
 560     HGLOBAL hglob;
 561     LPBYTE *data;
 562
 563     hglob = GlobalAlloc (0, sizeof(metafile));
 564     data = GlobalLock(hglob);
 565     memcpy(data, metafile, sizeof(metafile));
 566
 567     ole_check(CreateStreamOnHGlobal(hglob, TRUE, &stream));
 568     /* Windows does not load simple metafiles */
 569     ole_expect(OleLoadPictureEx(stream, sizeof(metafile), TRUE, &IID_IPicture, 100, 100, 0, (LPVOID *)&pict), E_FAIL);
 570
 571     IStream_Release(stream);
 572 }
 573
 574 static void test_enhmetafile(void)
 575 {
 576     OLE_HANDLE handle;
 577     LPSTREAM stream;
 578     IPicture *pict;
 579     HGLOBAL hglob;
 580     LPBYTE *data;
 581     LONG cxy;
 582     BOOL keep;
 583     short type;
 584
 585     hglob = GlobalAlloc (0, sizeof(enhmetafile));
 586     data = GlobalLock(hglob);
 587     memcpy(data, enhmetafile, sizeof(enhmetafile));
 588
 589     ole_check(CreateStreamOnHGlobal(hglob, TRUE, &stream));
 590     ole_check(OleLoadPictureEx(stream, sizeof(enhmetafile), TRUE, &IID_IPicture, 10, 10, 0, (LPVOID *)&pict));
 591
 592     ole_check(IPicture_get_Handle(pict, &handle));
 593     ok(handle != 0, "handle is null\n");
 594
 595     ole_check(IPicture_get_Type(pict, &type));
 596     expect_eq(type, PICTYPE_ENHMETAFILE, short, "%d");
 597
 598     ole_check(IPicture_get_Height(pict, &cxy));
 599     expect_eq(cxy, -23, LONG, "%d");
 600
 601     ole_check(IPicture_get_Width(pict, &cxy));
 602     expect_eq(cxy, -25, LONG, "%d");
 603
 604     ole_check(IPicture_get_KeepOriginalFormat(pict, &keep));
 605     todo_wine expect_eq(keep, FALSE, LONG, "%d");
 606
 607     IPicture_Release(pict);
 608     IStream_Release(stream);
 609 }
 610
 611 static void test_Render(void)
 612 {
 613     IPicture *pic;
 614     HRESULT hres;
 615     short type;
 616     PICTDESC desc;
 617     OLE_XSIZE_HIMETRIC pWidth;
 618     OLE_YSIZE_HIMETRIC pHeight;
 619     COLORREF result, expected;
 620     HDC hdc = GetDC(0);
 621
 622     /* test IPicture::Render return code on uninitialized picture */
 623     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 624     hres = IPicture_get_Type(pic, &type);
 625     ok(hres == S_OK, "IPicture_get_Type does not return S_OK, but 0x%08x\n", hres);
 626     ok(type == PICTYPE_UNINITIALIZED, "Expected type = PICTYPE_UNINITIALIZED, got = %d\n", type);
 627     /* zero dimensions */
 628     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
 629     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 630     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
 631     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 632     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
 633     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 634     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
 635     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 636     hres = IPicture_Render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
 637     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 638     hres = IPicture_Render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
 639     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 640     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
 641     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 642     /* nonzero dimensions, PICTYPE_UNINITIALIZED */
 643     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 10, NULL);
 644     ole_expect(hres, S_OK);
 645     IPicture_Release(pic);
 646
 647     desc.cbSizeofstruct = sizeof(PICTDESC);
 648     desc.picType = PICTYPE_ICON;
 649     desc.u.icon.hicon = LoadIcon(NULL, IDI_APPLICATION);
 650     if(!desc.u.icon.hicon){
 651         win_skip("LoadIcon failed. Skipping...\n");
 652         ReleaseDC(NULL, hdc);
 653         return;
 654     }
 655
 656     OleCreatePictureIndirect(&desc, &IID_IPicture, TRUE, (VOID**)&pic);
 657     /* zero dimensions, PICTYPE_ICON */
 658     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 0, 0, NULL);
 659     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 660     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 10, 0, NULL);
 661     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 662     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 10, NULL);
 663     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 664     hres = IPicture_Render(pic, hdc, 0, 0, 10, 10, 0, 0, 0, 0, NULL);
 665     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 666     hres = IPicture_Render(pic, hdc, 0, 0, 0, 10, 0, 0, 10, 10, NULL);
 667     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 668     hres = IPicture_Render(pic, hdc, 0, 0, 10, 0, 0, 0, 10, 10, NULL);
 669     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 670     hres = IPicture_Render(pic, hdc, 0, 0, 0, 0, 0, 0, 10, 10, NULL);
 671     ole_expect(hres, CTL_E_INVALIDPROPERTYVALUE);
 672
 673     /* Check if target size and position is respected */
 674     IPicture_get_Width(pic, &pWidth);
 675     IPicture_get_Height(pic, &pHeight);
 676
 677     SetPixelV(hdc, 0, 0, 0x00F0F0F0);
 678     SetPixelV(hdc, 5, 5, 0x00F0F0F0);
 679     SetPixelV(hdc, 10, 10, 0x00F0F0F0);
 680     expected = GetPixel(hdc, 0, 0);
 681
 682     hres = IPicture_Render(pic, hdc, 1, 1, 9, 9, 0, 0, pWidth, -pHeight, NULL);
 683     ole_expect(hres, S_OK);
 684
 685     if(hres != S_OK) {
 686         IPicture_Release(pic);
 687         ReleaseDC(NULL, hdc);
 688         return;
 689     }
 690
 691     /* Evaluate the rendered Icon */
 692     result = GetPixel(hdc, 0, 0);
 693     ok(result == expected,
 694        "Color at 0,0 should be unchanged 0x%06X, but was 0x%06X\n", expected, result);
 695     result = GetPixel(hdc, 5, 5);
 696     ok(result != expected ||
 697         broken(result == expected), /* WinNT 4.0 and older may claim they drew */
 698                                     /* the icon, even if they didn't. */
 699        "Color at 5,5 should have changed, but still was 0x%06X\n", expected);
 700     result = GetPixel(hdc, 10, 10);
 701     ok(result == expected,
 702        "Color at 10,10 should be unchanged 0x%06X, but was 0x%06X\n", expected, result);
 703
 704     IPicture_Release(pic);
 705     ReleaseDC(NULL, hdc);
 706 }
 707
 708 static void test_get_Attributes(void)
 709 {
 710     IPicture *pic;
 711     HRESULT hres;
 712     short type;
 713     DWORD attr;
 714
 715     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 716     hres = IPicture_get_Type(pic, &type);
 717     ok(hres == S_OK, "IPicture_get_Type does not return S_OK, but 0x%08x\n", hres);
 718     ok(type == PICTYPE_UNINITIALIZED, "Expected type = PICTYPE_UNINITIALIZED, got = %d\n", type);
 719
 720     hres = IPicture_get_Attributes(pic, NULL);
 721     ole_expect(hres, E_POINTER);
 722
 723     attr = 0xdeadbeef;
 724     hres = IPicture_get_Attributes(pic, &attr);
 725     ole_expect(hres, S_OK);
 726     ok(attr == 0, "IPicture_get_Attributes does not reset attr to zero, got %d\n", attr);
 727
 728     IPicture_Release(pic);
 729 }
 730
 731 static void test_get_Handle(void)
 732 {
 733     IPicture *pic;
 734     HRESULT hres;
 735
 736     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 737
 738     hres = IPicture_get_Handle(pic, NULL);
 739     ole_expect(hres, E_POINTER);
 740
 741     IPicture_Release(pic);
 742 }
 743
 744 static void test_get_Type(void)
 745 {
 746     IPicture *pic;
 747     HRESULT hres;
 748
 749     OleCreatePictureIndirect(NULL, &IID_IPicture, TRUE, (VOID**)&pic);
 750
 751     hres = IPicture_get_Type(pic, NULL);
 752     ole_expect(hres, E_POINTER);
 753
 754     IPicture_Release(pic);
 755 }
 756
 757 static void test_OleLoadPicturePath(void)
 758 {
 759     static WCHAR emptyW[] = {0};
 760
 761     IPicture *pic;
 762     HRESULT hres;
 763     int i;
 764     char temp_path[MAX_PATH];
 765     char temp_file[MAX_PATH];
 766     WCHAR temp_fileW[MAX_PATH + 5] = {'f','i','l','e',':','/','/','/'};
 767     HANDLE file;
 768     DWORD size;
 769     WCHAR *ptr;
 770
 771     const struct
 772     {
 773         LPOLESTR szURLorPath;
 774         REFIID riid;
 775         IPicture **pic;
 776     } invalid_parameters[] =
 777     {
 778         {NULL,  NULL,          NULL},
 779         {NULL,  NULL,          &pic},
 780         {NULL,  &IID_IPicture, NULL},
 781         {NULL,  &IID_IPicture, &pic},
 782         {emptyW, NULL,          NULL},
 783         {emptyW, &IID_IPicture, NULL},
 784     };
 785
 786     for (i = 0; i < sizeof(invalid_parameters)/sizeof(invalid_parameters[0]); i++)
 787     {
 788         pic = (IPicture *)0xdeadbeef;
 789         hres = OleLoadPicturePath(invalid_parameters[i].szURLorPath, NULL, 0, 0,
 790                                   invalid_parameters[i].riid,
 791                                   (void **)invalid_parameters[i].pic);
 792         ok(hres == E_INVALIDARG,
 793            "[%d] Expected OleLoadPicturePath to return E_INVALIDARG, got 0x%08x\n", i, hres);
 794         ok(pic == (IPicture *)0xdeadbeef,
 795            "[%d] Expected output pointer to be 0xdeadbeef, got %p\n", i, pic);
 796     }
 797
 798     pic = (IPicture *)0xdeadbeef;
 799     hres = OleLoadPicturePath(emptyW, NULL, 0, 0, NULL, (void **)&pic);
 800     todo_wine
 801     ok(hres == INET_E_UNKNOWN_PROTOCOL || /* XP/Vista+ */
 802        broken(hres == E_UNEXPECTED) || /* NT4 */
 803        broken(hres == E_OUTOFMEMORY), /* Win2k/Win2k3 */
 804        "Expected OleLoadPicturePath to return INET_E_UNKNOWN_PROTOCOL, got 0x%08x\n", hres);
 805     ok(pic == NULL,
 806        "Expected the output interface pointer to be NULL, got %p\n", pic);
 807
 808     pic = (IPicture *)0xdeadbeef;
 809     hres = OleLoadPicturePath(emptyW, NULL, 0, 0, &IID_IPicture, (void **)&pic);
 810     todo_wine
 811     ok(hres == INET_E_UNKNOWN_PROTOCOL || /* XP/Vista+ */
 812        broken(hres == E_UNEXPECTED) || /* NT4 */
 813        broken(hres == E_OUTOFMEMORY), /* Win2k/Win2k3 */
 814        "Expected OleLoadPicturePath to return INET_E_UNKNOWN_PROTOCOL, got 0x%08x\n", hres);
 815     ok(pic == NULL,
 816        "Expected the output interface pointer to be NULL, got %p\n", pic);
 817
 818     /* Create a local temporary image file for testing. */
 819     GetTempPathA(sizeof(temp_path), temp_path);
 820     GetTempFileNameA(temp_path, "bmp", 0, temp_file);
 821     file = CreateFileA(temp_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 822                        FILE_ATTRIBUTE_NORMAL, NULL);
 823     WriteFile(file, bmpimage, sizeof(bmpimage), &size, NULL);
 824     CloseHandle(file);
 825
 826     MultiByteToWideChar(CP_ACP, 0, temp_file, -1, temp_fileW + 8, sizeof(temp_fileW)/sizeof(WCHAR) - 8);
 827
 828     /* Try a normal DOS path. */
 829     hres = OleLoadPicturePath(temp_fileW + 8, NULL, 0, 0, &IID_IPicture, (void **)&pic);
 830     ok(hres == S_OK ||
 831        broken(hres == E_UNEXPECTED), /* NT4 */
 832        "Expected OleLoadPicturePath to return S_OK, got 0x%08x\n", hres);
 833     if (pic)
 834         IPicture_Release(pic);
 835
 836     /* Try a DOS path with tacked on "file:". */
 837     hres = OleLoadPicturePath(temp_fileW, NULL, 0, 0, &IID_IPicture, (void **)&pic);
 838     ok(hres == S_OK ||
 839        broken(hres == E_UNEXPECTED), /* NT4 */
 840        "Expected OleLoadPicturePath to return S_OK, got 0x%08x\n", hres);
 841     if (pic)
 842         IPicture_Release(pic);
 843
 844     DeleteFileA(temp_file);
 845
 846     /* Try with a nonexistent file. */
 847     hres = OleLoadPicturePath(temp_fileW + 8, NULL, 0, 0, &IID_IPicture, (void **)&pic);
 848     ok(hres == INET_E_RESOURCE_NOT_FOUND || /* XP+ */
 849        broken(hres == E_UNEXPECTED) || /* NT4 */
 850        broken(hres == E_FAIL), /*Win2k */
 851        "Expected OleLoadPicturePath to return INET_E_RESOURCE_NOT_FOUND, got 0x%08x\n", hres);
 852
 853     hres = OleLoadPicturePath(temp_fileW, NULL, 0, 0, &IID_IPicture, (void **)&pic);
 854     ok(hres == INET_E_RESOURCE_NOT_FOUND || /* XP+ */
 855        broken(hres == E_UNEXPECTED) || /* NT4 */
 856        broken(hres == E_FAIL), /* Win2k */
 857        "Expected OleLoadPicturePath to return INET_E_RESOURCE_NOT_FOUND, got 0x%08x\n", hres);
 858
 859     file = CreateFileA(temp_file, GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 860                        FILE_ATTRIBUTE_NORMAL, NULL);
 861     WriteFile(file, bmpimage, sizeof(bmpimage), &size, NULL);
 862     CloseHandle(file);
 863
 864     /* Try a "file:" URL with slash separators. */
 865     ptr = temp_fileW + 8;
 866     while (*ptr)
 867     {
 868         if (*ptr == '\\')
 869             *ptr = '/';
 870         ptr++;
 871     }
 872
 873     hres = OleLoadPicturePath(temp_fileW, NULL, 0, 0, &IID_IPicture, (void **)&pic);
 874     ok(hres == S_OK ||
 875        broken(hres == E_UNEXPECTED), /* NT4 */
 876        "Expected OleLoadPicturePath to return S_OK, got 0x%08x\n", hres);
 877     if (pic)
 878         IPicture_Release(pic);
 879
 880     DeleteFileA(temp_file);
 881
 882     /* Try with a nonexistent file. */
 883     hres = OleLoadPicturePath(temp_fileW, NULL, 0, 0, &IID_IPicture, (void **)&pic);
 884     ok(hres == INET_E_RESOURCE_NOT_FOUND || /* XP+ */
 885        broken(hres == E_UNEXPECTED) || /* NT4 */
 886        broken(hres == E_FAIL), /* Win2k */
 887        "Expected OleLoadPicturePath to return INET_E_RESOURCE_NOT_FOUND, got 0x%08x\n", hres);
 888 }
 889
 890 static void test_himetric(void)
 891 {
 892     static const BYTE bmp_bits[1024];
 893     OLE_XSIZE_HIMETRIC cx;
 894     OLE_YSIZE_HIMETRIC cy;
 895     IPicture *pic;
 896     PICTDESC desc;
 897     HBITMAP bmp;
 898     HRESULT hr;
 899     HICON icon;
 900     HDC hdc;
 901     INT d;
 902
 903     if (!pOleCreatePictureIndirect)
 904     {
 905         win_skip("OleCreatePictureIndirect not available\n");
 906         return;
 907     }
 908
 909     desc.cbSizeofstruct = sizeof(desc);
 910     desc.picType = PICTYPE_BITMAP;
 911     desc.u.bmp.hpal = NULL;
 912
 913     hdc = CreateCompatibleDC(0);
 914
 915     bmp = CreateBitmap(1.9 * GetDeviceCaps(hdc, LOGPIXELSX),
 916                        1.9 * GetDeviceCaps(hdc, LOGPIXELSY), 1, 1, NULL);
 917
 918     desc.u.bmp.hbitmap = bmp;
 919
 920     /* size in himetric units reported rounded up to next integer value */
 921     hr = pOleCreatePictureIndirect(&desc, &IID_IPicture, FALSE, (void**)&pic);
 922     ok(hr == S_OK, "got 0x%08x\n", hr);
 923
 924     cx = 0;
 925     d = MulDiv((INT)(1.9 * GetDeviceCaps(hdc, LOGPIXELSX)), 2540, GetDeviceCaps(hdc, LOGPIXELSX));
 926     hr = IPicture_get_Width(pic, &cx);
 927     ok(hr == S_OK, "got 0x%08x\n", hr);
 928     ok(cx == d, "got %d, expected %d\n", cx, d);
 929
 930     cy = 0;
 931     d = MulDiv((INT)(1.9 * GetDeviceCaps(hdc, LOGPIXELSY)), 2540, GetDeviceCaps(hdc, LOGPIXELSY));
 932     hr = IPicture_get_Height(pic, &cy);
 933     ok(hr == S_OK, "got 0x%08x\n", hr);
 934     ok(cy == d, "got %d, expected %d\n", cy, d);
 935
 936     DeleteObject(bmp);
 937     IPicture_Release(pic);
 938
 939     /* same thing with icon */
 940     icon = CreateIcon(NULL, GetSystemMetrics(SM_CXICON), GetSystemMetrics(SM_CYICON),
 941                       1, 1, bmp_bits, bmp_bits);
 942     ok(icon != NULL, "failed to create icon\n");
 943
 944     desc.picType = PICTYPE_ICON;
 945     desc.u.icon.hicon = icon;
 946
 947     hr = pOleCreatePictureIndirect(&desc, &IID_IPicture, FALSE, (void**)&pic);
 948     ok(hr == S_OK, "got 0x%08x\n", hr);
 949
 950     cx = 0;
 951     d = MulDiv(GetSystemMetrics(SM_CXICON), 2540, GetDeviceCaps(hdc, LOGPIXELSX));
 952     hr = IPicture_get_Width(pic, &cx);
 953     ok(hr == S_OK, "got 0x%08x\n", hr);
 954     ok(cx == d, "got %d, expected %d\n", cx, d);
 955
 956     cy = 0;
 957     d = MulDiv(GetSystemMetrics(SM_CYICON), 2540, GetDeviceCaps(hdc, LOGPIXELSY));
 958     hr = IPicture_get_Height(pic, &cy);
 959     ok(hr == S_OK, "got 0x%08x\n", hr);
 960     ok(cy == d, "got %d, expected %d\n", cy, d);
 961
 962     IPicture_Release(pic);
 963     DestroyIcon(icon);
 964
 965     DeleteDC(hdc);
 966 }
 967
 968 START_TEST(olepicture)
 969 {
 970         hOleaut32 = GetModuleHandleA("oleaut32.dll");
 971         pOleLoadPicture = (void*)GetProcAddress(hOleaut32, "OleLoadPicture");
 972         pOleCreatePictureIndirect = (void*)GetProcAddress(hOleaut32, "OleCreatePictureIndirect");
 973         if (!pOleLoadPicture)
 974         {
 975             win_skip("OleLoadPicture is not available\n");
 976             return;
 977         }
 978
 979         /* Test regular 1x1 pixel images of gif, jpg, bmp type */
 980         test_pic(gifimage, sizeof(gifimage));
 981         test_pic(jpgimage, sizeof(jpgimage));
 982         test_pic(bmpimage, sizeof(bmpimage));
 983         test_pic(gif4pixel, sizeof(gif4pixel));
 984         /* FIXME: No PNG support in Windows... */
 985         if (0) test_pic(pngimage, sizeof(pngimage));
 986         test_empty_image();
 987         test_empty_image_2();
 988         test_apm();
 989         test_metafile();
 990         test_enhmetafile();
 991
 992     test_Invoke();
 993     test_OleCreatePictureIndirect();
 994     test_Render();
 995     test_get_Attributes();
 996     test_get_Handle();
 997     test_get_Type();
 998     test_OleLoadPicturePath();
 999     test_himetric();
1000 }
1001
1002
1003 /* Helper functions only ... */
1004
1005
1006 static inline NoStatStreamImpl *impl_from_IStream(IStream *iface)
1007 {
1008   return CONTAINING_RECORD(iface, NoStatStreamImpl, IStream_iface);
1009 }
1010
1011 static void NoStatStreamImpl_Destroy(NoStatStreamImpl* This)
1012 {
1013   GlobalFree(This->supportHandle);
1014   This->supportHandle=0;
1015   HeapFree(GetProcessHeap(), 0, This);
1016 }
1017
1018 static ULONG WINAPI NoStatStreamImpl_AddRef(
1019                 IStream* iface)
1020 {
1021   NoStatStreamImpl* const This = impl_from_IStream(iface);
1022   return InterlockedIncrement(&This->ref);
1023 }
1024
1025 static HRESULT WINAPI NoStatStreamImpl_QueryInterface(
1026                   IStream*     iface,
1027                   REFIID         riid,        /* [in] */
1028                   void**         ppvObject)   /* [iid_is][out] */
1029 {
1030   NoStatStreamImpl* const This = impl_from_IStream(iface);
1031   if (ppvObject==0) return E_INVALIDARG;
1032   *ppvObject = 0;
1033   if (IsEqualIID(&IID_IUnknown, riid))
1034   {
1035     *ppvObject = This;
1036   }
1037   else if (IsEqualIID(&IID_IStream, riid))
1038   {
1039     *ppvObject = This;
1040   }
1041
1042   if ((*ppvObject)==0)
1043     return E_NOINTERFACE;
1044   NoStatStreamImpl_AddRef(iface);
1045   return S_OK;
1046 }
1047
1048 static ULONG WINAPI NoStatStreamImpl_Release(
1049                 IStream* iface)
1050 {
1051   NoStatStreamImpl* const This = impl_from_IStream(iface);
1052   ULONG newRef = InterlockedDecrement(&This->ref);
1053   if (newRef==0)
1054     NoStatStreamImpl_Destroy(This);
1055   return newRef;
1056 }
1057
1058 static HRESULT WINAPI NoStatStreamImpl_Read(
1059                   IStream*     iface,
1060                   void*          pv,        /* [length_is][size_is][out] */
1061                   ULONG          cb,        /* [in] */
1062                   ULONG*         pcbRead)   /* [out] */
1063 {
1064   NoStatStreamImpl* const This = impl_from_IStream(iface);
1065   void* supportBuffer;
1066   ULONG bytesReadBuffer;
1067   ULONG bytesToReadFromBuffer;
1068
1069   if (pcbRead==0)
1070     pcbRead = &bytesReadBuffer;
1071   bytesToReadFromBuffer = min( This->streamSize.u.LowPart - This->currentPosition.u.LowPart, cb);
1072   supportBuffer = GlobalLock(This->supportHandle);
1073   memcpy(pv, (char *) supportBuffer+This->currentPosition.u.LowPart, bytesToReadFromBuffer);
1074   This->currentPosition.u.LowPart+=bytesToReadFromBuffer;
1075   *pcbRead = bytesToReadFromBuffer;
1076   GlobalUnlock(This->supportHandle);
1077   if(*pcbRead == cb)
1078     return S_OK;
1079   return S_FALSE;
1080 }
1081
1082 static HRESULT WINAPI NoStatStreamImpl_Write(
1083                   IStream*     iface,
1084                   const void*    pv,          /* [size_is][in] */
1085                   ULONG          cb,          /* [in] */
1086                   ULONG*         pcbWritten)  /* [out] */
1087 {
1088   NoStatStreamImpl* const This = impl_from_IStream(iface);
1089   void*          supportBuffer;
1090   ULARGE_INTEGER newSize;
1091   ULONG          bytesWritten = 0;
1092
1093   if (pcbWritten == 0)
1094     pcbWritten = &bytesWritten;
1095   if (cb == 0)
1096     return S_OK;
1097   newSize.u.HighPart = 0;
1098   newSize.u.LowPart = This->currentPosition.u.LowPart + cb;
1099   if (newSize.u.LowPart > This->streamSize.u.LowPart)
1100    IStream_SetSize(iface, newSize);
1101
1102   supportBuffer = GlobalLock(This->supportHandle);
1103   memcpy((char *) supportBuffer+This->currentPosition.u.LowPart, pv, cb);
1104   This->currentPosition.u.LowPart+=cb;
1105   *pcbWritten = cb;
1106   GlobalUnlock(This->supportHandle);
1107   return S_OK;
1108 }
1109
1110 static HRESULT WINAPI NoStatStreamImpl_Seek(
1111                   IStream*      iface,
1112                   LARGE_INTEGER   dlibMove,         /* [in] */
1113                   DWORD           dwOrigin,         /* [in] */
1114                   ULARGE_INTEGER* plibNewPosition) /* [out] */
1115 {
1116   NoStatStreamImpl* const This = impl_from_IStream(iface);
1117   ULARGE_INTEGER newPosition;
1118   switch (dwOrigin)
1119   {
1120     case STREAM_SEEK_SET:
1121       newPosition.u.HighPart = 0;
1122       newPosition.u.LowPart = 0;
1123       break;
1124     case STREAM_SEEK_CUR:
1125       newPosition = This->currentPosition;
1126       break;
1127     case STREAM_SEEK_END:
1128       newPosition = This->streamSize;
1129       break;
1130     default:
1131       return STG_E_INVALIDFUNCTION;
1132   }
1133   if (dlibMove.QuadPart < 0 && newPosition.QuadPart < -dlibMove.QuadPart)
1134       return STG_E_INVALIDFUNCTION;
1135   newPosition.QuadPart += dlibMove.QuadPart;
1136   if (plibNewPosition) *plibNewPosition = newPosition;
1137   This->currentPosition = newPosition;
1138   return S_OK;
1139 }
1140
1141 static HRESULT WINAPI NoStatStreamImpl_SetSize(
1142                                      IStream*      iface,
1143                                      ULARGE_INTEGER  libNewSize)   /* [in] */
1144 {
1145   NoStatStreamImpl* const This = impl_from_IStream(iface);
1146   HGLOBAL supportHandle;
1147   if (libNewSize.u.HighPart != 0)
1148     return STG_E_INVALIDFUNCTION;
1149   if (This->streamSize.u.LowPart == libNewSize.u.LowPart)
1150     return S_OK;
1151   supportHandle = GlobalReAlloc(This->supportHandle, libNewSize.u.LowPart, 0);
1152   if (supportHandle == 0)
1153     return STG_E_MEDIUMFULL;
1154   This->supportHandle = supportHandle;
1155   This->streamSize.u.LowPart = libNewSize.u.LowPart;
1156   return S_OK;
1157 }
1158
1159 static HRESULT WINAPI NoStatStreamImpl_CopyTo(
1160                                     IStream*      iface,
1161                                     IStream*      pstm,         /* [unique][in] */
1162                                     ULARGE_INTEGER  cb,           /* [in] */
1163                                     ULARGE_INTEGER* pcbRead,      /* [out] */
1164                                     ULARGE_INTEGER* pcbWritten)   /* [out] */
1165 {
1166   HRESULT        hr = S_OK;
1167   BYTE           tmpBuffer[128];
1168   ULONG          bytesRead, bytesWritten, copySize;
1169   ULARGE_INTEGER totalBytesRead;
1170   ULARGE_INTEGER totalBytesWritten;
1171
1172   if ( pstm == 0 )
1173     return STG_E_INVALIDPOINTER;
1174   totalBytesRead.u.LowPart = totalBytesRead.u.HighPart = 0;
1175   totalBytesWritten.u.LowPart = totalBytesWritten.u.HighPart = 0;
1176
1177   while ( cb.u.LowPart > 0 )
1178   {
1179     if ( cb.u.LowPart >= 128 )
1180       copySize = 128;
1181     else
1182       copySize = cb.u.LowPart;
1183     IStream_Read(iface, tmpBuffer, copySize, &bytesRead);
1184     totalBytesRead.u.LowPart += bytesRead;
1185     IStream_Write(pstm, tmpBuffer, bytesRead, &bytesWritten);
1186     totalBytesWritten.u.LowPart += bytesWritten;
1187     if (bytesRead != bytesWritten)
1188     {
1189       hr = STG_E_MEDIUMFULL;
1190       break;
1191     }
1192     if (bytesRead!=copySize)
1193       cb.u.LowPart = 0;
1194     else
1195       cb.u.LowPart -= bytesRead;
1196   }
1197   if (pcbRead)
1198   {
1199     pcbRead->u.LowPart = totalBytesRead.u.LowPart;
1200     pcbRead->u.HighPart = totalBytesRead.u.HighPart;
1201   }
1202
1203   if (pcbWritten)
1204   {
1205     pcbWritten->u.LowPart = totalBytesWritten.u.LowPart;
1206     pcbWritten->u.HighPart = totalBytesWritten.u.HighPart;
1207   }
1208   return hr;
1209 }
1210
1211 static HRESULT WINAPI NoStatStreamImpl_Commit(IStream* iface,DWORD grfCommitFlags)
1212 {
1213   return S_OK;
1214 }
1215 static HRESULT WINAPI NoStatStreamImpl_Revert(IStream* iface) { return S_OK; }
1216
1217 static HRESULT WINAPI NoStatStreamImpl_LockRegion(
1218                   IStream*       iface,
1219                   ULARGE_INTEGER libOffset,   /* [in] */
1220                   ULARGE_INTEGER cb,          /* [in] */
1221                   DWORD          dwLockType)  /* [in] */
1222 {
1223   return S_OK;
1224 }
1225
1226 static HRESULT WINAPI NoStatStreamImpl_UnlockRegion(
1227                   IStream*       iface,
1228                   ULARGE_INTEGER libOffset,   /* [in] */
1229                   ULARGE_INTEGER cb,          /* [in] */
1230                   DWORD          dwLockType)  /* [in] */
1231 {
1232   return S_OK;
1233 }
1234
1235 static HRESULT WINAPI NoStatStreamImpl_Stat(
1236                   IStream*     iface,
1237                   STATSTG*     pstatstg,     /* [out] */
1238                   DWORD        grfStatFlag)  /* [in] */
1239 {
1240   return E_NOTIMPL;
1241 }
1242
1243 static HRESULT WINAPI NoStatStreamImpl_Clone(
1244                   IStream*     iface,
1245                   IStream**    ppstm) /* [out] */
1246 {
1247   return E_NOTIMPL;
1248 }
1249 static const IStreamVtbl NoStatStreamImpl_Vtbl;
1250
1251 /*
1252     Build an object that implements IStream, without IStream_Stat capabilities.
1253     Receives a memory handle with data buffer. If memory handle is non-null,
1254     it is assumed to be unlocked, otherwise an internal memory handle is allocated.
1255     In any case the object takes ownership of memory handle and will free it on
1256     object release.
1257  */
1258 static IStream* NoStatStream_Construct(HGLOBAL hGlobal)
1259 {
1260   NoStatStreamImpl* newStream;
1261
1262   newStream = HeapAlloc(GetProcessHeap(), 0, sizeof(NoStatStreamImpl));
1263   if (newStream!=0)
1264   {
1265     newStream->IStream_iface.lpVtbl = &NoStatStreamImpl_Vtbl;
1266     newStream->ref    = 1;
1267     newStream->supportHandle = hGlobal;
1268
1269     if (!newStream->supportHandle)
1270       newStream->supportHandle = GlobalAlloc(GMEM_MOVEABLE | GMEM_NODISCARD |
1271                                              GMEM_SHARE, 0);
1272     newStream->currentPosition.u.HighPart = 0;
1273     newStream->currentPosition.u.LowPart = 0;
1274     newStream->streamSize.u.HighPart = 0;
1275     newStream->streamSize.u.LowPart  = GlobalSize(newStream->supportHandle);
1276   }
1277   return &newStream->IStream_iface;
1278 }
1279
1280
1281 static const IStreamVtbl NoStatStreamImpl_Vtbl =
1282 {
1283     NoStatStreamImpl_QueryInterface,
1284     NoStatStreamImpl_AddRef,
1285     NoStatStreamImpl_Release,
1286     NoStatStreamImpl_Read,
1287     NoStatStreamImpl_Write,
1288     NoStatStreamImpl_Seek,
1289     NoStatStreamImpl_SetSize,
1290     NoStatStreamImpl_CopyTo,
1291     NoStatStreamImpl_Commit,
1292     NoStatStreamImpl_Revert,
1293     NoStatStreamImpl_LockRegion,
1294     NoStatStreamImpl_UnlockRegion,
1295     NoStatStreamImpl_Stat,
1296     NoStatStreamImpl_Clone
1297 };