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     /* Passing a NULL pointer for the second IStream::Clone param crashes on Win7 */
 181
 182     clone = NULL;
 183     ret = IStream_Clone(stream, &clone);
 184     ok(ret == E_NOTIMPL, "expected E_NOTIMPL, got 0x%08x\n", ret);
 185     ok(clone == NULL, "expected a NULL IStream object, got %p\n", stream);
 186
 187     if (clone) {
 188         refcount = IStream_Release(clone);
 189         ok(refcount == 0, "expected 0, got %d\n", refcount);
 190     }
 191 }
 192
 193
 194 static void test_SHCreateStreamOnFileA(DWORD mode, DWORD stgm)
 195 {
 196     IStream * stream;
 197     HRESULT ret;
 198     ULONG refcount;
 199     char test_file[MAX_PATH];
 200     static const CHAR testA_txt[] = "\\testA.txt";
 201
 202     trace("SHCreateStreamOnFileA: testing mode %d, STGM flags %08x\n", mode, stgm);
 203
 204     /* Don't used a fixed path for the testA.txt file */
 205     GetTempPathA(MAX_PATH, test_file);
 206     lstrcatA(test_file, testA_txt);
 207
 208     /* invalid arguments */
 209
 210     stream = NULL;
 211     /* NT: ERROR_PATH_NOT_FOUND, 9x: ERROR_BAD_PATHNAME */
 212     ret = (*pSHCreateStreamOnFileA)(NULL, mode | stgm, &stream);
 213     ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) ||
 214         ret == HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME),
 215         "SHCreateStreamOnFileA: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND)"
 216         "or HRESULT_FROM_WIN32(ERROR_BAD_PATHNAME), got 0x%08x\n", ret);
 217     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 218
 219 #if 0 /* This test crashes on WinXP SP2 */
 220     ret = (*pSHCreateStreamOnFileA)(test_file, mode | stgm, NULL);
 221     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 222 #endif
 223
 224     stream = NULL;
 225     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_CONVERT | stgm, &stream);
 226     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 227     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 228
 229     stream = NULL;
 230     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_DELETEONRELEASE | stgm, &stream);
 231     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 232     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 233
 234     stream = NULL;
 235     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_TRANSACTED | stgm, &stream);
 236     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileA: expected E_INVALIDARG, got 0x%08x\n", ret);
 237     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 238
 239     /* file does not exist */
 240
 241     stream = NULL;
 242     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 243     ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileA: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 244     ok(stream == NULL, "SHCreateStreamOnFileA: expected a NULL IStream object, got %p\n", stream);
 245
 246     stream = NULL;
 247     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_CREATE | stgm, &stream);
 248     ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret);
 249     ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
 250
 251     if (stream) {
 252         test_IStream_invalid_operations(stream, mode);
 253
 254         refcount = IStream_Release(stream);
 255         ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount);
 256     }
 257
 258     /* NOTE: don't delete the file, as it will be used for the file exists tests. */
 259
 260     /* file exists */
 261
 262     stream = NULL;
 263     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 264     ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret);
 265     ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
 266
 267     if (stream) {
 268         test_IStream_invalid_operations(stream, mode);
 269
 270         refcount = IStream_Release(stream);
 271         ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount);
 272     }
 273
 274     stream = NULL;
 275     ret = (*pSHCreateStreamOnFileA)(test_file, mode | STGM_CREATE | stgm, &stream);
 276     ok(ret == S_OK, "SHCreateStreamOnFileA: expected S_OK, got 0x%08x\n", ret);
 277     ok(stream != NULL, "SHCreateStreamOnFileA: expected a valid IStream object, got NULL\n");
 278
 279     if (stream) {
 280         test_IStream_invalid_operations(stream, mode);
 281
 282         refcount = IStream_Release(stream);
 283         ok(refcount == 0, "SHCreateStreamOnFileA: expected 0, got %d\n", refcount);
 284
 285         ok(DeleteFileA(test_file), "SHCreateStreamOnFileA: could not delete file '%s', got error %d\n", test_file, GetLastError());
 286     }
 287 }
 288
 289
 290 static void test_SHCreateStreamOnFileW(DWORD mode, DWORD stgm)
 291 {
 292     IStream * stream;
 293     HRESULT ret;
 294     ULONG refcount;
 295     WCHAR test_file[MAX_PATH];
 296     CHAR  test_fileA[MAX_PATH];
 297     static const CHAR testW_txt[] = "\\testW.txt";
 298
 299     trace("SHCreateStreamOnFileW: testing mode %d, STGM flags %08x\n", mode, stgm);
 300
 301     /* Don't used a fixed path for the testW.txt file */
 302     GetTempPathA(MAX_PATH, test_fileA);
 303     lstrcatA(test_fileA, testW_txt);
 304     MultiByteToWideChar(CP_ACP, 0, test_fileA, -1, test_file, MAX_PATH);
 305
 306     /* invalid arguments */
 307
 308     if (0)
 309     {
 310         /* Crashes on NT4 */
 311         stream = NULL;
 312         ret = (*pSHCreateStreamOnFileW)(NULL, mode | stgm, &stream);
 313         ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || /* XP */
 314            ret == E_INVALIDARG /* Vista */,
 315           "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08x\n", ret);
 316         ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 317     }
 318
 319     if (0)
 320     {
 321         /* This test crashes on WinXP SP2 */
 322             ret = (*pSHCreateStreamOnFileW)(test_file, mode | stgm, NULL);
 323             ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 324     }
 325
 326     stream = NULL;
 327     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_CONVERT | stgm, &stream);
 328     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 329     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 330
 331     stream = NULL;
 332     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_DELETEONRELEASE | stgm, &stream);
 333     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 334     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 335
 336     stream = NULL;
 337     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_TRANSACTED | stgm, &stream);
 338     ok(ret == E_INVALIDARG, "SHCreateStreamOnFileW: expected E_INVALIDARG, got 0x%08x\n", ret);
 339     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 340
 341     /* file does not exist */
 342
 343     stream = NULL;
 344     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 345     ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "SHCreateStreamOnFileW: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 346     ok(stream == NULL, "SHCreateStreamOnFileW: expected a NULL IStream object, got %p\n", stream);
 347
 348     stream = NULL;
 349     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_CREATE | stgm, &stream);
 350     ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
 351     ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
 352
 353     if (stream) {
 354         test_IStream_invalid_operations(stream, mode);
 355
 356         refcount = IStream_Release(stream);
 357         ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
 358     }
 359
 360     /* NOTE: don't delete the file, as it will be used for the file exists tests. */
 361
 362     /* file exists */
 363
 364     stream = NULL;
 365     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_FAILIFTHERE | stgm, &stream);
 366     ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
 367     ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
 368
 369     if (stream) {
 370         test_IStream_invalid_operations(stream, mode);
 371
 372         refcount = IStream_Release(stream);
 373         ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
 374     }
 375
 376     stream = NULL;
 377     ret = (*pSHCreateStreamOnFileW)(test_file, mode | STGM_CREATE | stgm, &stream);
 378     ok(ret == S_OK, "SHCreateStreamOnFileW: expected S_OK, got 0x%08x\n", ret);
 379     ok(stream != NULL, "SHCreateStreamOnFileW: expected a valid IStream object, got NULL\n");
 380
 381     if (stream) {
 382         test_IStream_invalid_operations(stream, mode);
 383
 384         refcount = IStream_Release(stream);
 385         ok(refcount == 0, "SHCreateStreamOnFileW: expected 0, got %d\n", refcount);
 386
 387         ok(DeleteFileA(test_fileA),
 388             "SHCreateStreamOnFileW: could not delete the test file, got error %d\n",
 389             GetLastError());
 390     }
 391 }
 392
 393
 394 static void test_SHCreateStreamOnFileEx(DWORD mode, DWORD stgm)
 395 {
 396     IStream * stream;
 397     IStream * template = NULL;
 398     HRESULT ret;
 399     ULONG refcount;
 400     WCHAR test_file[MAX_PATH];
 401     CHAR  test_fileA[MAX_PATH];
 402     static const CHAR testEx_txt[] = "\\testEx.txt";
 403
 404     trace("SHCreateStreamOnFileEx: testing mode %d, STGM flags %08x\n", mode, stgm);
 405
 406     /* Don't used a fixed path for the testEx.txt file */
 407     GetTempPathA(MAX_PATH, test_fileA);
 408     lstrcatA(test_fileA, testEx_txt);
 409     MultiByteToWideChar(CP_ACP, 0, test_fileA, -1, test_file, MAX_PATH);
 410
 411     /* invalid arguments */
 412
 413     if (0)
 414     {
 415         /* Crashes on NT4 */
 416         stream = NULL;
 417         ret = (*pSHCreateStreamOnFileEx)(NULL, mode, 0, FALSE, NULL, &stream);
 418         ok(ret == HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) || /* XP */
 419            ret == E_INVALIDARG /* Vista */,
 420           "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_PATH_NOT_FOUND) or E_INVALIDARG, got 0x%08x\n", ret);
 421         ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 422     }
 423
 424     stream = NULL;
 425     ret = (*pSHCreateStreamOnFileEx)(test_file, mode, 0, FALSE, template, &stream);
 426     ok( ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
 427         ret == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER),
 428         "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) or "
 429         "HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got 0x%08x\n", ret);
 430
 431     ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 432
 433     if (0)
 434     {
 435         /* This test crashes on WinXP SP2 */
 436         ret = (*pSHCreateStreamOnFileEx)(test_file, mode, 0, FALSE, NULL, NULL);
 437         ok(ret == E_INVALIDARG, "SHCreateStreamOnFileEx: expected E_INVALIDARG, got 0x%08x\n", ret);
 438     }
 439
 440     /* file does not exist */
 441
 442     stream = NULL;
 443     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, FALSE, NULL, &stream);
 444     if ((stgm & STGM_TRANSACTED) == STGM_TRANSACTED && mode == STGM_READ) {
 445         ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) /* XP */ || ret == E_INVALIDARG /* Vista */,
 446           "SHCreateStreamOnFileEx: expected E_INVALIDARG or HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), got 0x%08x\n", ret);
 447
 448         if (ret == E_INVALIDARG) {
 449             skip("SHCreateStreamOnFileEx: STGM_TRANSACTED not supported in this configuration.\n");
 450             return;
 451         }
 452     } else {
 453         ok( ret == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) ||
 454             ret == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER),
 455             "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND) or "
 456             "HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER), got 0x%08x\n", ret);
 457     }
 458     ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 459
 460     stream = NULL;
 461     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, TRUE, NULL, &stream);
 462     /* not supported on win9x */
 463     if (broken(ret == HRESULT_FROM_WIN32(ERROR_INVALID_PARAMETER) && stream == NULL)) {
 464         skip("Not supported\n");
 465         DeleteFileA(test_fileA);
 466         return;
 467     }
 468
 469     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 470     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 471
 472     if (stream) {
 473         test_IStream_invalid_operations(stream, mode);
 474
 475         refcount = IStream_Release(stream);
 476         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 477
 478         ok(DeleteFileA(test_fileA),
 479             "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n",
 480             GetLastError());
 481     }
 482
 483     stream = NULL;
 484     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, FALSE, NULL, &stream);
 485     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 486     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 487
 488     if (stream) {
 489         test_IStream_invalid_operations(stream, mode);
 490
 491         refcount = IStream_Release(stream);
 492         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 493
 494         ok(DeleteFileA(test_fileA),
 495             "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n",
 496             GetLastError());
 497     }
 498
 499     stream = NULL;
 500     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, TRUE, NULL, &stream);
 501     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 502     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 503
 504     if (stream) {
 505         test_IStream_invalid_operations(stream, mode);
 506
 507         refcount = IStream_Release(stream);
 508         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 509     }
 510
 511     /* NOTE: don't delete the file, as it will be used for the file exists tests. */
 512
 513     /* file exists */
 514
 515     stream = NULL;
 516     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, FALSE, NULL, &stream);
 517     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 518     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 519
 520     if (stream) {
 521         test_IStream_invalid_operations(stream, mode);
 522
 523         refcount = IStream_Release(stream);
 524         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 525     }
 526
 527     stream = NULL;
 528     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_FAILIFTHERE | stgm, 0, TRUE, NULL, &stream);
 529     ok(ret == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "SHCreateStreamOnFileEx: expected HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), got 0x%08x\n", ret);
 530     ok(stream == NULL, "SHCreateStreamOnFileEx: expected a NULL IStream object, got %p\n", stream);
 531
 532     stream = NULL;
 533     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, FALSE, NULL, &stream);
 534     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 535     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 536
 537     if (stream) {
 538         test_IStream_invalid_operations(stream, mode);
 539
 540         refcount = IStream_Release(stream);
 541         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 542     }
 543
 544     stream = NULL;
 545     ret = (*pSHCreateStreamOnFileEx)(test_file, mode | STGM_CREATE | stgm, 0, TRUE, NULL, &stream);
 546     ok(ret == S_OK, "SHCreateStreamOnFileEx: expected S_OK, got 0x%08x\n", ret);
 547     ok(stream != NULL, "SHCreateStreamOnFileEx: expected a valid IStream object, got NULL\n");
 548
 549     if (stream) {
 550         test_IStream_invalid_operations(stream, mode);
 551
 552         refcount = IStream_Release(stream);
 553         ok(refcount == 0, "SHCreateStreamOnFileEx: expected 0, got %d\n", refcount);
 554     }
 555
 556     ok(DeleteFileA(test_fileA),
 557         "SHCreateStreamOnFileEx: could not delete the test file, got error %d\n",
 558         GetLastError());
 559 }
 560
 561
 562 START_TEST(istream)
 563 {
 564     static const DWORD stgm_access[] = {
 565         STGM_READ,
 566         STGM_WRITE,
 567         STGM_READWRITE
 568     };
 569
 570     static const DWORD stgm_sharing[] = {
 571         0,
 572         STGM_SHARE_DENY_NONE,
 573         STGM_SHARE_DENY_READ,
 574         STGM_SHARE_DENY_WRITE,
 575         STGM_SHARE_EXCLUSIVE
 576     };
 577
 578     static const DWORD stgm_flags[] = {
 579         0,
 580         STGM_CONVERT,
 581         STGM_DELETEONRELEASE,
 582         STGM_CONVERT | STGM_DELETEONRELEASE,
 583         STGM_TRANSACTED | STGM_CONVERT,
 584         STGM_TRANSACTED | STGM_DELETEONRELEASE,
 585         STGM_TRANSACTED | STGM_CONVERT | STGM_DELETEONRELEASE
 586     };
 587
 588     int i, j, k;
 589
 590     hShlwapi = GetModuleHandleA("shlwapi.dll");
 591
 592     pSHCreateStreamOnFileA = (void*)GetProcAddress(hShlwapi, "SHCreateStreamOnFileA");
 593     pSHCreateStreamOnFileW = (void*)GetProcAddress(hShlwapi, "SHCreateStreamOnFileW");
 594     pSHCreateStreamOnFileEx = (void*)GetProcAddress(hShlwapi, "SHCreateStreamOnFileEx");
 595
 596     if (!pSHCreateStreamOnFileA)
 597         skip("SHCreateStreamOnFileA not found.\n");
 598
 599     if (!pSHCreateStreamOnFileW)
 600         skip("SHCreateStreamOnFileW not found.\n");
 601
 602     if (!pSHCreateStreamOnFileEx)
 603         skip("SHCreateStreamOnFileEx not found.\n");
 604
 605     for (i = 0; i != sizeof(stgm_access)/sizeof(stgm_access[0]); i++) {
 606         for (j = 0; j != sizeof(stgm_sharing)/sizeof(stgm_sharing[0]); j ++) {
 607             if (pSHCreateStreamOnFileA)
 608                 test_SHCreateStreamOnFileA(stgm_access[i], stgm_sharing[j]);
 609
 610             if (pSHCreateStreamOnFileW)
 611                 test_SHCreateStreamOnFileW(stgm_access[i], stgm_sharing[j]);
 612
 613             if (pSHCreateStreamOnFileEx) {
 614                 for (k = 0; k != sizeof(stgm_flags)/sizeof(stgm_flags[0]); k++)
 615                     test_SHCreateStreamOnFileEx(stgm_access[i], stgm_sharing[j] | stgm_flags[k]);
 616             }
 617         }
 618     }
 619 }