git.oblomov.eu Git - wine/blob - dlls/shlwapi/tests/istream.c

   1 /* Unit test suite for SHLWAPI ShCreateStreamOnFile functions.
   2  *
   3  * Copyright 2008 Reece H. Dunn
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Lesser General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2.1 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Lesser General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Lesser General Public
  16  * License along with this library; if not, write to the Free Software
  17  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  18  */
  19
  20 #define COBJMACROS
  21
  22 #include <stdarg.h>
  23 #include <stdio.h>
  24
  25 #include "wine/test.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "objbase.h"
  29 #include "shlwapi.h"
  30
  31
  32 /* Function pointers for the SHCreateStreamOnFile functions */
  33 static HMODULE hShlwapi;
  34 static HRESULT (WINAPI *pSHCreateStreamOnFileA)(LPCSTR file, DWORD mode, IStream **stream);
  35 static HRESULT (WINAPI *pSHCreateStreamOnFileW)(LPCWSTR file, DWORD mode, IStream **stream);
  36 static HRESULT (WINAPI *pSHCreateStreamOnFileEx)(LPCWSTR file, DWORD mode, DWORD attributes, BOOL create, IStream *template, IStream **stream);
  37
  38
  39 static void test_IStream_invalid_operations(IStream * stream, DWORD mode)
  40 {
  41     HRESULT ret;
  42     IStream * clone;
  43     ULONG refcount;
  44     ULARGE_INTEGER uzero;
  45     ULARGE_INTEGER uret;
  46     LARGE_INTEGER zero;
  47     ULONG count;
  48     char data[256];
  49
  50     U(uzero).HighPart = 0;
  51     U(uzero).LowPart = 0;
  52     U(uret).HighPart = 0;
  53     U(uret).LowPart = 0;
  54     U(zero).HighPart = 0;
  55     U(zero).LowPart = 0;
  56
  57     /* IStream::Read */
  58
  59     /* IStream_Read from the COBJMACROS is undefined by shlwapi.h, replaced by the IStream_Read helper function. */
  60
  61     ret = stream->lpVtbl->Read(stream, NULL, 0, &count);
  62     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
  63
  64     ret = stream->lpVtbl->Read(stream, data, 5, NULL);
  65     ok(ret == S_FALSE || ret == S_OK, "expected S_FALSE or S_OK, got 0x%08x\n", ret);
  66
  67     ret = stream->lpVtbl->Read(stream, data, 0, NULL);
  68     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
  69
  70     ret = stream->lpVtbl->Read(stream, data, 3, &count);
  71     ok(ret == S_FALSE || ret == S_OK, "expected S_FALSE or S_OK, got 0x%08x\n", ret);
  72
  73     /* IStream::Write */
  74
  75     /* IStream_Write from the COBJMACROS is undefined by shlwapi.h, replaced by the IStream_Write helper function. */
  76
  77     ret = stream->lpVtbl->Write(stream, NULL, 0, &count);
  78     if (mode == STGM_READ)
  79         ok(ret == STG_E_ACCESSDENIED /* XP */ || ret == S_OK /* 2000 */,
  80            "expected STG_E_ACCESSDENIED or S_OK, got 0x%08x\n", ret);
  81     else
  82         ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
  83
  84     strcpy(data, "Hello");
  85     ret = stream->lpVtbl->Write(stream, data, 5, NULL);
  86     if (mode == STGM_READ)
  87         ok(ret == STG_E_ACCESSDENIED /* XP */ || ret == S_OK /* 2000 */,
  88            "expected STG_E_ACCESSDENIED or S_OK, got 0x%08x\n", ret);
  89     else
  90         ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
  91
  92     strcpy(data, "Hello");
  93     ret = stream->lpVtbl->Write(stream, data, 0, NULL);
  94     if (mode == STGM_READ)
  95         ok(ret == STG_E_ACCESSDENIED /* XP */ || ret == S_OK /* 2000 */,
  96            "expected STG_E_ACCESSDENIED or S_OK, got 0x%08x\n", ret);
  97     else
  98         ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
  99
 100     strcpy(data, "Hello");
 101     ret = stream->lpVtbl->Write(stream, data, 0, &count);
 102     if (mode == STGM_READ)
 103         ok(ret == STG_E_ACCESSDENIED /* XP */ || ret == S_OK /* 2000 */,
 104            "expected STG_E_ACCESSDENIED or S_OK, got 0x%08x\n", ret);
 105     else
 106         ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 107
 108     strcpy(data, "Hello");
 109     ret = stream->lpVtbl->Write(stream, data, 3, &count);
 110     if (mode == STGM_READ)
 111         ok(ret == STG_E_ACCESSDENIED /* XP */ || ret == S_OK /* 2000 */,
 112            "expected STG_E_ACCESSDENIED or S_OK, got 0x%08x\n", ret);
 113     else
 114         ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 115
 116     /* IStream::Seek */
 117
 118     ret = IStream_Seek(stream, zero, STREAM_SEEK_SET, NULL);
 119     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 120
 121     ret = IStream_Seek(stream, zero, 20, NULL);
 122     ok(ret == E_INVALIDARG /* XP */ || ret == S_OK /* 2000 */,
 123        "expected E_INVALIDARG or S_OK, got 0x%08x\n", ret);
 124
 125     /* IStream::CopyTo */
 126
 127     ret = IStream_CopyTo(stream, NULL, uzero, &uret, &uret);
 128     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 129
 130     clone = NULL;
 131     ret = IStream_CopyTo(stream, clone, uzero, &uret, &uret);
 132     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 133
 134     ret = IStream_CopyTo(stream, stream, uzero, &uret, &uret);
 135     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 136
 137     ret = IStream_CopyTo(stream, stream, uzero, &uret, NULL);
 138     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 139
 140     ret = IStream_CopyTo(stream, stream, uzero, NULL, &uret);
 141     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 142
 143     /* IStream::Commit */
 144
 145     ret = IStream_Commit(stream, STGC_DEFAULT);
 146     ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 147
 148     /* IStream::Revert */
 149
 150     ret = IStream_Revert(stream);
 151     ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret);
 152
 153     /* IStream::LockRegion */
 154
 155     ret = IStream_LockRegion(stream, uzero, uzero, 0);
 156     ok(ret == E_NOTIMPL /* XP */ || ret == S_OK /* Vista */,
 157       "expected E_NOTIMPL or S_OK, got 0x%08x\n", ret);
 158
 159     /* IStream::UnlockRegion */
 160
 161     if (ret == E_NOTIMPL) /* XP */ {
 162         ret = IStream_UnlockRegion(stream, uzero, uzero, 0);
 163         ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret);
 164     } else /* Vista */ {
 165         ret = IStream_UnlockRegion(stream, uzero, uzero, 0);
 166         ok(ret == S_OK, "expected S_OK, got 0x%08x\n", ret);
 167
 168         ret = IStream_UnlockRegion(stream, uzero, uzero, 0);
 169         ok(ret == STG_E_LOCKVIOLATION, "expected STG_E_LOCKVIOLATION, got 0x%08x\n", ret);
 170     }
 171
 172     /* IStream::Stat */
 173
 174     ret = IStream_Stat(stream, NULL, 0);
 175     ok(ret == STG_E_INVALIDPOINTER /* XP */ || ret == E_NOTIMPL /* 2000 */,
 176        "expected STG_E_INVALIDPOINTER or E_NOTIMPL, got 0x%08x\n", ret);
 177
 178     /* IStream::Clone */
 179
 180     ret = IStream_Clone(stream, NULL);
 181     ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret);
 182
 183     clone = NULL;
 184     ret = IStream_Clone(stream, &clone);
 185     ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret);
 186     ok(clone == NULL, "expected a NULL IStream object, got %p\n", stream);
 187
 188     if (clone) {
 189         refcount = IStream_Release(clone);
 190         ok(refcount == 0, "expected 0, got %d\n", refcount);
 191     }
 192 }
 193
 194
 195 static void test_SHCreateStreamOnFileA(DWORD mode, DWORD stgm)
 196 {
 197     IStream * stream;
 198     HRESULT ret;
 199     ULONG refcount;
 200     char test_file[MAX_PATH];
 201     static const CHAR testA_txt[] = "\\testA.txt";
 202
 203     trace("SHCreateStreamOnFileA: testing mode %d, STGM flags %08x\n", mode, stgm);
 204
 205     /* Don't used a fixed path for the testA.txt file */
 206     GetTempPathA(MAX_PATH, test_file);
 207     lstrcatA(test_file, testA_txt);
 208
 209     /* invalid arguments */
 210
 211     stream = NULL;
 212     ret = (*pSHCreateStreamOnFileA)(NULL, mode | stgm, &stream);
 213     ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), "SHCreateStreamOnFileA: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND), got 0x%08x\n", ret);
 214     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 215
 216 #if 0 /* This test crashes on WinXP SP2 */
 217     ret = (*pSHCreateStreamOnFileA)(test_file, mode | stgm, NULL);
 218     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 219 #endif
 220
 221     stream = NULL;
 222     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_CONVERT | stgm, &stream);
 223     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 224     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 225
 226     stream = NULL;
 227     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_DELETEONRELEASE | stgm, &stream);
 228     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 229     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 230
 231     stream = NULL;
 232     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_TRANSACTED | stgm, &stream);
 233     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 234     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 235
 236     /* file does not exist */
 237
 238     stream = NULL;
 239     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 240     ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileA: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 241     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 242
 243     stream = NULL;
 244     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_CREATE | stgm, &stream);
 245     ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret);
 246     ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
 247
 248     if (stream) {
 249         test_IStream_invalid_operations(stream, mode);
 250
 251         refcount = IStream_Release(stream);
 252         ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount);
 253     }
 254
 255     /* NOTE: don't delete the file, as it will be used for the file exists tests. */
 256
 257     /* file exists */
 258
 259     stream = NULL;
 260     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 261     ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret);
 262     ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
 263
 264     if (stream) {
 265         test_IStream_invalid_operations(stream, mode);
 266
 267         refcount = IStream_Release(stream);
 268         ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount);
 269     }
 270
 271     stream = NULL;
 272     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_CREATE | stgm, &stream);
 273     ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret);
 274     ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
 275
 276     if (stream) {
 277         test_IStream_invalid_operations(stream, mode);
 278
 279         refcount = IStream_Release(stream);
 280         ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount);
 281
 282         ok(DeleteFileA(test_file), "SHCreateStreamOnFileA: could not delete file '%s', got error %d\n", test_file, GetLastError());
 283     }
 284 }
 285
 286
 287 static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm)
 288 {
 289     IStream * stream;
 290     HRESULT ret;
 291     ULONG refcount;
 292     WCHAR test_file[MAX_PATH];
 293     static const WCHAR testW_txt[] = { '\\', 't', 'e', 's', 't', 'W', '.', 't', 'x', 't', '\0' };
 294
 295     trace("SHCreateStreamOnFileW: testing mode %d, STGM flags %08x\n", mode, stgm);
 296
 297     /* Don't used a fixed path for the testW.txt file */
 298     GetTempPathW(MAX_PATH, test_file);
 299     lstrcatW(test_file, testW_txt);
 300
 301     /* invalid arguments */
 302
 303     stream = NULL;
 304     ret = (*pSHCreateStreamOnFileW)(NULL, mode | stgm, &stream);
 305     ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || /* XP */
 306        ret == E_INVALIDARG /* Vista */,
 307       "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08x\n", ret);
 308     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 309
 310 #if 0 /* This test crashes on WinXP SP2 */
 311     ret = (*pSHCreateStreamOnFileW)(test_file, mode | stgm, NULL);
 312     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 313 #endif
 314
 315     stream = NULL;
 316     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_CONVERT | stgm, &stream);
 317     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 318     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 319
 320     stream = NULL;
 321     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_DELETEONRELEASE | stgm, &stream);
 322     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 323     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 324
 325     stream = NULL;
 326     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_TRANSACTED | stgm, &stream);
 327     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 328     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 329
 330     /* file does not exist */
 331
 332     stream = NULL;
 333     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 334     ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 335     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 336
 337     stream = NULL;
 338     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_CREATE | stgm, &stream);
 339     ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
 340     ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
 341
 342     if (stream) {
 343         test_IStream_invalid_operations(stream, mode);
 344
 345         refcount = IStream_Release(stream);
 346         ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
 347     }
 348
 349     /* NOTE: don't delete the file, as it will be used for the file exists tests. */
 350
 351     /* file exists */
 352
 353     stream = NULL;
 354     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 355     ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
 356     ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
 357
 358     if (stream) {
 359         test_IStream_invalid_operations(stream, mode);
 360
 361         refcount = IStream_Release(stream);
 362         ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
 363     }
 364
 365     stream = NULL;
 366     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_CREATE | stgm, &stream);
 367     ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
 368     ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
 369
 370     if (stream) {
 371         test_IStream_invalid_operations(stream, mode);
 372
 373         refcount = IStream_Release(stream);
 374         ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
 375
 376         ok(DeleteFileW(test_file), "SHCreateStreamOnFileW: could not delete the test file, got error %d\n", GetLastError());
 377     }
 378 }
 379
 380
 381 static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm)
 382 {
 383     IStream * stream;
 384     IStream * template = NULL;
 385     HRESULT ret;
 386     ULONG refcount;
 387     WCHAR test_file[MAX_PATH];
 388     static const WCHAR testEx_txt[] = { '\\', 't', 'e', 's', 't', 'E','x', '.', 't', 'x', 't', '\0' };
 389
 390     trace("SHCreateStreamOnFileEx: testing mode %d, STGM flags %08x\n", mode, stgm);
 391
 392     /* Don't used a fixed path for the testEx.txt file */
 393     GetTempPathW(MAX_PATH, test_file);
 394     lstrcatW(test_file, testEx_txt);
 395
 396     /* invalid arguments */
 397
 398     stream = NULL;
 399     ret = (*pSHCreateStreamOnFileEx)(NULL, mode, 0, FALSE, NULL, &stream);
 400     ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || /* XP */
 401        ret == E_INVALIDARG /* Vista */,
 402       "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08x\n", ret);
 403     ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 404
 405     stream = NULL;
 406     ret = (*pSHCreateStreamOnFileEx)(test_file, mode, 0, FALSE, template, &stream);
 407     ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 408     ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 409
 410 #if 0 /* This test crashes on WinXP SP2 */
 411     ret = (*pSHCreateStreamOnFileEx)(test_file, mode, 0, FALSE, NULL, NULL);
 412     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileEx: expected E_INVALIDARG, got 0x%08x\n", ret);
 413 #endif
 414
 415     /* file does not exist */
 416
 417     stream = NULL;
 418     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, FALSE, NULL, &stream);
 419     if ((stgm & STGM_TRANSACTED) == STGM_TRANSACTED && mode == STGM_READ) {
 420         ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* XP */ || ret == E_INVALIDARG /* Vista */,
 421           "SHCreateStreamOnFileEx: expected E_INVALIDARG or HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 422
 423         if (ret == E_INVALIDARG) {
 424             skip("SHCreateStreamOnFileEx: STGM_TRANSACTED not supported in this configuration.\n");
 425             return;
 426         }
 427     } else {
 428         ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 429     }
 430     ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 431
 432     stream = NULL;
 433     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, TRUE, NULL, &stream);
 434     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 435     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 436
 437     if (stream) {
 438         test_IStream_invalid_operations(stream, mode);
 439
 440         refcount = IStream_Release(stream);
 441         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 442
 443         ok(DeleteFileW(test_file), "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n", GetLastError());
 444     }
 445
 446     stream = NULL;
 447     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, FALSE, NULL, &stream);
 448     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 449     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 450
 451     if (stream) {
 452         test_IStream_invalid_operations(stream, mode);
 453
 454         refcount = IStream_Release(stream);
 455         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 456
 457         ok(DeleteFileW(test_file), "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n", GetLastError());
 458     }
 459
 460     stream = NULL;
 461     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, TRUE, NULL, &stream);
 462     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 463     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 464
 465     if (stream) {
 466         test_IStream_invalid_operations(stream, mode);
 467
 468         refcount = IStream_Release(stream);
 469         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 470     }
 471
 472     /* NOTE: don't delete the file, as it will be used for the file exists tests. */
 473
 474     /* file exists */
 475
 476     stream = NULL;
 477     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, FALSE, NULL, &stream);
 478     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 479     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 480
 481     if (stream) {
 482         test_IStream_invalid_operations(stream, mode);
 483
 484         refcount = IStream_Release(stream);
 485         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 486     }
 487
 488     stream = NULL;
 489     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, TRUE, NULL, &stream);
 490     ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), got 0x%08x\n", ret);
 491     ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 492
 493     stream = NULL;
 494     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, FALSE, NULL, &stream);
 495     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 496     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 497
 498     if (stream) {
 499         test_IStream_invalid_operations(stream, mode);
 500
 501         refcount = IStream_Release(stream);
 502         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 503     }
 504
 505     stream = NULL;
 506     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, TRUE, NULL, &stream);
 507     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 508     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 509
 510     if (stream) {
 511         test_IStream_invalid_operations(stream, mode);
 512
 513         refcount = IStream_Release(stream);
 514         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 515     }
 516
 517     ok(DeleteFileW(test_file), "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n", GetLastError());
 518 }
 519
 520
 521 START_TEST(istream)
 522 {
 523     static const DWORD stgm_access[] = {
 524         STGM_READ,
 525         STGM_WRITE,
 526         STGM_READWRITE
 527     };
 528
 529     static const DWORD stgm_sharing[] = {
 530         0,
 531         STGM_SHARE_DENY_NONE,
 532         STGM_SHARE_DENY_READ,
 533         STGM_SHARE_DENY_WRITE,
 534         STGM_SHARE_EXCLUSIVE
 535     };
 536
 537     static const DWORD stgm_flags[] = {
 538         0,
 539         STGM_CONVERT,
 540         STGM_DELETEONRELEASE,
 541         STGM_CONVERT | STGM_DELETEONRELEASE,
 542         STGM_TRANSACTED | STGM_CONVERT,
 543         STGM_TRANSACTED | STGM_DELETEONRELEASE,
 544         STGM_TRANSACTED | STGM_CONVERT | STGM_DELETEONRELEASE
 545     };
 546
 547     int i, j, k;
 548
 549     hShlwapi = GetModuleHandleA("shlwapi.dll");
 550
 551     pSHCreateStreamOnFileA = (void*)GetProcAddress(hShlwapi, "SHCreateStreamOnFileA");
 552     pSHCreateStreamOnFileW = (void*)GetProcAddress(hShlwapi, "SHCreateStreamOnFileW");
 553     pSHCreateStreamOnFileEx = (void*)GetProcAddress(hShlwapi, "SHCreateStreamOnFileEx");
 554
 555     if (!pSHCreateStreamOnFileA)
 556         skip("SHCreateStreamOnFileA not found.\n");
 557
 558     if (!pSHCreateStreamOnFileW)
 559         skip("SHCreateStreamOnFileW not found.\n");
 560
 561     if (!pSHCreateStreamOnFileEx)
 562         skip("SHCreateStreamOnFileEx not found.\n");
 563
 564     for (i = 0; i != sizeof(stgm_access)/sizeof(stgm_access[0]); i++) {
 565         for (j = 0; j != sizeof(stgm_sharing)/sizeof(stgm_sharing[0]); j ++) {
 566             if (pSHCreateStreamOnFileA)
 567                 test_SHCreateStreamOnFileA(stgm_access[i], stgm_sharing[j]);
 568
 569             if (pSHCreateStreamOnFileW)
 570                 test_SHCreateStreamOnFileW(stgm_access[i], stgm_sharing[j]);
 571
 572             if (pSHCreateStreamOnFileEx) {
 573                 for (k = 0; k != sizeof(stgm_flags)/sizeof(stgm_flags[0]); k++)
 574                     test_SHCreateStreamOnFileEx(stgm_access[i], stgm_sharing[j] | stgm_flags[k]);
 575             }
 576         }
 577     }
 578 }