dlls/ole32/tests/storage32.c

   1 /*
   2  * Unit tests for OLE storage
   3  *
   4  * Copyright (c) 2004 Mike McCormack
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #include <stdio.h>
  22
  23 #define COBJMACROS
  24 #define NONAMELESSUNION
  25 #define NONAMELESSSTRUCT
  26
  27 #include <windows.h>
  28 #include "wine/test.h"
  29
  30 #include "ole2.h"
  31 #include "objidl.h"
  32 #include "initguid.h"
  33
  34 DEFINE_GUID( test_stg_cls, 0x88888888, 0x0425, 0x0000, 0,0,0,0,0,0,0,0);
  35
  36 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
  37
  38 static CHAR filenameA[MAX_PATH];
  39 static WCHAR filename[MAX_PATH];
  40
  41 static const char file1_nameA[] = {'c','o','p','y','t','e','s','t','A',0};
  42 static const WCHAR file1_name[] = {'c','o','p','y','t','e','s','t','A',0};
  43 static const char file2_nameA[] = {'c','o','p','y','t','e','s','t','B',0};
  44 static const WCHAR file2_name[] = {'c','o','p','y','t','e','s','t','B',0};
  45 static const WCHAR stgA_name[] = {'S','t','o','r','a','g','e','A',0};
  46 static const WCHAR stgB_name[] = {'S','t','o','r','a','g','e','B',0};
  47 static const WCHAR strmA_name[] = {'S','t','r','e','a','m','A',0};
  48 static const WCHAR strmB_name[] = {'S','t','r','e','a','m','B',0};
  49 static const WCHAR strmC_name[] = {'S','t','r','e','a','m','C',0};
  50
  51 /* Win9x and WinMe don't have lstrcmpW */
  52 static int strcmp_ww(LPCWSTR strw1, LPCWSTR strw2)
  53 {
  54     CHAR stra1[512], stra2[512];
  55     WideCharToMultiByte(CP_ACP, 0, strw1, -1, stra1, sizeof(stra1), NULL, NULL);
  56     WideCharToMultiByte(CP_ACP, 0, strw2, -1, stra2, sizeof(stra2), NULL, NULL);
  57     return lstrcmpA(stra1, stra2);
  58 }
  59
  60 typedef struct TestLockBytes {
  61     ILockBytes ILockBytes_iface;
  62     LONG ref;
  63     BYTE* contents;
  64     ULONG size;
  65     ULONG buffer_size;
  66     HRESULT lock_hr;
  67     ULONG locks_supported;
  68     ULONG lock_called;
  69 } TestLockBytes;
  70
  71 static inline TestLockBytes *impl_from_ILockBytes(ILockBytes *iface)
  72 {
  73     return CONTAINING_RECORD(iface, TestLockBytes, ILockBytes_iface);
  74 }
  75
  76 static HRESULT WINAPI TestLockBytes_QueryInterface(ILockBytes *iface, REFIID iid,
  77     void **ppv)
  78 {
  79     TestLockBytes *This = impl_from_ILockBytes(iface);
  80
  81     if (!ppv) return E_INVALIDARG;
  82
  83     if (IsEqualIID(&IID_IUnknown, iid) ||
  84         IsEqualIID(&IID_ILockBytes, iid))
  85         *ppv = &This->ILockBytes_iface;
  86     else
  87         return E_NOINTERFACE;
  88
  89     IUnknown_AddRef((IUnknown*)*ppv);
  90     return S_OK;
  91 }
  92
  93 static ULONG WINAPI TestLockBytes_AddRef(ILockBytes *iface)
  94 {
  95     TestLockBytes *This = impl_from_ILockBytes(iface);
  96     ULONG ref = InterlockedIncrement(&This->ref);
  97     return ref;
  98 }
  99
 100 static ULONG WINAPI TestLockBytes_Release(ILockBytes *iface)
 101 {
 102     TestLockBytes *This = impl_from_ILockBytes(iface);
 103     ULONG ref = InterlockedDecrement(&This->ref);
 104     return ref;
 105 }
 106
 107 static HRESULT WINAPI TestLockBytes_ReadAt(ILockBytes *iface,
 108     ULARGE_INTEGER ulOffset, void *pv, ULONG cb, ULONG *pcbRead)
 109 {
 110     TestLockBytes *This = impl_from_ILockBytes(iface);
 111     ULONG dummy;
 112
 113     if (!pv) return E_INVALIDARG;
 114
 115     if (!pcbRead) pcbRead = &dummy;
 116
 117     if (ulOffset.QuadPart >= This->size)
 118     {
 119         *pcbRead = 0;
 120         return S_OK;
 121     }
 122
 123     cb = min(cb, This->size - ulOffset.QuadPart);
 124
 125     *pcbRead = cb;
 126     memcpy(pv, &This->contents[ulOffset.QuadPart], cb);
 127
 128     return S_OK;
 129 }
 130
 131 static HRESULT WINAPI TestLockBytes_WriteAt(ILockBytes *iface,
 132     ULARGE_INTEGER ulOffset, const void *pv, ULONG cb, ULONG *pcbWritten)
 133 {
 134     TestLockBytes *This = impl_from_ILockBytes(iface);
 135     HRESULT hr;
 136     ULONG dummy;
 137
 138     if (!pv) return E_INVALIDARG;
 139
 140     if (!pcbWritten) pcbWritten = &dummy;
 141
 142     if (ulOffset.QuadPart + cb > This->size)
 143     {
 144         ULARGE_INTEGER new_size;
 145         new_size.QuadPart = ulOffset.QuadPart + cb;
 146         hr = ILockBytes_SetSize(iface, new_size);
 147         if (FAILED(hr)) return hr;
 148     }
 149
 150     *pcbWritten = cb;
 151     memcpy(&This->contents[ulOffset.QuadPart], pv, cb);
 152
 153     return S_OK;
 154 }
 155
 156 static HRESULT WINAPI TestLockBytes_Flush(ILockBytes *iface)
 157 {
 158     return S_OK;
 159 }
 160
 161 static HRESULT WINAPI TestLockBytes_SetSize(ILockBytes *iface,
 162     ULARGE_INTEGER cb)
 163 {
 164     TestLockBytes *This = impl_from_ILockBytes(iface);
 165
 166     if (This->buffer_size < cb.QuadPart)
 167     {
 168         ULONG new_buffer_size = max(This->buffer_size * 2, cb.QuadPart);
 169         BYTE* new_buffer = HeapAlloc(GetProcessHeap(), 0, new_buffer_size);
 170         if (!new_buffer) return E_OUTOFMEMORY;
 171         memcpy(new_buffer, This->contents, This->size);
 172         HeapFree(GetProcessHeap(), 0, This->contents);
 173         This->contents = new_buffer;
 174     }
 175
 176     if (cb.QuadPart > This->size)
 177         memset(&This->contents[This->size], 0, cb.QuadPart - This->size);
 178
 179     This->size = cb.QuadPart;
 180
 181     return S_OK;
 182 }
 183
 184 static HRESULT WINAPI TestLockBytes_LockRegion(ILockBytes *iface,
 185     ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
 186 {
 187     TestLockBytes *This = impl_from_ILockBytes(iface);
 188     This->lock_called++;
 189     return This->lock_hr;
 190 }
 191
 192 static HRESULT WINAPI TestLockBytes_UnlockRegion(ILockBytes *iface,
 193     ULARGE_INTEGER libOffset, ULARGE_INTEGER cb, DWORD dwLockType)
 194 {
 195     TestLockBytes *This = impl_from_ILockBytes(iface);
 196     return This->lock_hr;
 197 }
 198
 199 static HRESULT WINAPI TestLockBytes_Stat(ILockBytes *iface,
 200     STATSTG *pstatstg, DWORD grfStatFlag)
 201 {
 202     TestLockBytes *This = impl_from_ILockBytes(iface);
 203     static const WCHAR dummy_name[] = {'d','u','m','m','y',0};
 204
 205     if (!pstatstg) return E_INVALIDARG;
 206
 207     memset(pstatstg, 0, sizeof(STATSTG));
 208
 209     if (!(grfStatFlag & STATFLAG_NONAME))
 210     {
 211         pstatstg->pwcsName = CoTaskMemAlloc(sizeof(dummy_name));
 212         if (!pstatstg->pwcsName) return E_OUTOFMEMORY;
 213         memcpy(pstatstg->pwcsName, dummy_name, sizeof(dummy_name));
 214     }
 215
 216     pstatstg->type = STGTY_LOCKBYTES;
 217     pstatstg->cbSize.QuadPart = This->size;
 218     pstatstg->grfLocksSupported = This->locks_supported;
 219
 220     return S_OK;
 221 }
 222
 223 static const ILockBytesVtbl TestLockBytes_Vtbl = {
 224     TestLockBytes_QueryInterface,
 225     TestLockBytes_AddRef,
 226     TestLockBytes_Release,
 227     TestLockBytes_ReadAt,
 228     TestLockBytes_WriteAt,
 229     TestLockBytes_Flush,
 230     TestLockBytes_SetSize,
 231     TestLockBytes_LockRegion,
 232     TestLockBytes_UnlockRegion,
 233     TestLockBytes_Stat
 234 };
 235
 236 static void CreateTestLockBytes(TestLockBytes **This)
 237 {
 238     *This = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(**This));
 239
 240     if (*This)
 241     {
 242         (*This)->ILockBytes_iface.lpVtbl = &TestLockBytes_Vtbl;
 243         (*This)->ref = 1;
 244     }
 245 }
 246
 247 static void DeleteTestLockBytes(TestLockBytes *This)
 248 {
 249     ok(This->ILockBytes_iface.lpVtbl == &TestLockBytes_Vtbl, "test lock bytes %p deleted with incorrect vtable\n", This);
 250     ok(This->ref == 1, "test lock bytes %p deleted with %i references instead of 1\n", This, This->ref);
 251     HeapFree(GetProcessHeap(), 0, This->contents);
 252     HeapFree(GetProcessHeap(), 0, This);
 253 }
 254
 255 static void test_hglobal_storage_stat(void)
 256 {
 257     ILockBytes *ilb = NULL;
 258     IStorage *stg = NULL;
 259     HRESULT r;
 260     STATSTG stat;
 261     DWORD mode, refcount;
 262
 263     r = CreateILockBytesOnHGlobal( NULL, TRUE, &ilb );
 264     ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
 265
 266     r = StgIsStorageILockBytes( ilb );
 267     ok( r == S_FALSE, "StgIsStorageILockBytes should have failed\n");
 268
 269     mode = STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE;/*0x1012*/
 270     r = StgCreateDocfileOnILockBytes( ilb, mode, 0,  &stg );
 271     ok( r == S_OK, "StgCreateDocfileOnILockBytes failed\n");
 272
 273     r = WriteClassStg( stg, &test_stg_cls );
 274     ok( r == S_OK, "WriteClassStg failed\n");
 275
 276     r = StgIsStorageILockBytes( ilb );
 277     ok( r == S_OK, "StgIsStorageILockBytes failed\n");
 278
 279     memset( &stat, 0, sizeof stat );
 280     r = IStorage_Stat( stg, &stat, 0 );
 281
 282     ok( stat.pwcsName == NULL, "storage name not null\n");
 283     ok( stat.type == 1, "type is wrong\n");
 284     ok( stat.grfMode == 0x12, "grf mode is incorrect\n");
 285     ok( !memcmp(&stat.clsid, &test_stg_cls, sizeof test_stg_cls), "CLSID is wrong\n");
 286
 287     refcount = IStorage_Release( stg );
 288     ok( refcount == 0, "IStorage refcount is wrong\n");
 289     refcount = ILockBytes_Release( ilb );
 290     ok( refcount == 0, "ILockBytes refcount is wrong\n");
 291 }
 292
 293 static void test_create_storage_modes(void)
 294 {
 295    IStorage *stg = NULL;
 296    HRESULT r;
 297
 298    DeleteFileA(filenameA);
 299
 300    /* test with some invalid parameters */
 301    r = StgCreateDocfile( NULL, 0, 0, &stg);
 302    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 303    r = StgCreateDocfile( filename, 0, 0, &stg);
 304    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 305    r = StgCreateDocfile( filename, STGM_CREATE, 0, &stg);
 306    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 307    r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE, 0, &stg);
 308    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 309    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &stg);
 310    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 311    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, NULL);
 312    ok(r==STG_E_INVALIDPOINTER, "StgCreateDocfile succeeded\n");
 313    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, &stg);
 314    ok(r==STG_E_INVALIDPARAMETER, "StgCreateDocfile succeeded\n");
 315    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
 316    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 317    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READ, 0, &stg);
 318    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 319    r = StgCreateDocfile( filename, STGM_PRIORITY, 0, &stg);
 320    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 321
 322    /* StgCreateDocfile seems to be very particular about the flags it accepts */
 323    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | STGM_WRITE, 0, &stg);
 324    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 325    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 8, 0, &stg);
 326    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 327    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80, 0, &stg);
 328    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 329    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800, 0, &stg);
 330    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 331    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x8000, 0, &stg);
 332    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 333    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80000, 0, &stg);
 334    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 335    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800000, 0, &stg);
 336    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 337    ok(stg == NULL, "stg was set\n");
 338
 339    /* check what happens if the file already exists (which is how it's meant to be used) */
 340    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 341    ok(r==S_OK, "StgCreateDocfile failed\n");
 342    r = IStorage_Release(stg);
 343    ok(r == 0, "storage not released\n");
 344    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 345    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n"); /* FAILIFTHERE is default */
 346    r = StgCreateDocfile( filename, STGM_READ, 0, &stg);
 347    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n"); /* need at least readmode and sharemode */
 348    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE, 0, &stg);
 349    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 350    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE, 0, &stg);
 351    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 352    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE, 0, &stg);
 353    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 354    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
 355    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 356    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, &stg);
 357    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 358    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_WRITE, 0, &stg);
 359    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 360    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_WRITE, 0, &stg);
 361    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 362    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
 363    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
 364    r = StgCreateDocfile( filename, STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
 365    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
 366    ok(DeleteFileA(filenameA), "failed to delete file\n");
 367
 368    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 369    ok(r==S_OK, "StgCreateDocfile failed\n");
 370    r = IStorage_Release(stg);
 371    ok(r == 0, "storage not released\n");
 372    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED |STGM_FAILIFTHERE, 0, &stg);
 373    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 374    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_WRITE, 0, &stg);
 375    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 376
 377    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
 378    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 379    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 380    ok(r==S_OK, "StgCreateDocfile failed\n");
 381    r = IStorage_Release(stg);
 382    ok(r == 0, "storage not released\n");
 383    ok(DeleteFileA(filenameA), "failed to delete file\n");
 384
 385    r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 386    ok(r==S_OK, "StgCreateDocfile failed\n");
 387    r = IStorage_Release(stg);
 388    ok(r == 0, "storage not released\n");
 389    ok(DeleteFileA(filenameA), "failed to delete file\n");
 390
 391    /* test the way excel uses StgCreateDocFile */
 392    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 393    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 394    if(r == S_OK)
 395    {
 396       r = IStorage_Release(stg);
 397       ok(r == 0, "storage not released\n");
 398       ok(DeleteFileA(filenameA), "failed to delete file\n");
 399    }
 400
 401    /* and the way windows media uses it ... */
 402    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_NONE | STGM_READWRITE | STGM_TRANSACTED, 0, &stg);
 403    ok(r==S_OK, "StgCreateDocfile the windows media way failed\n");
 404    if (r == S_OK)
 405    {
 406       r = IStorage_Release(stg);
 407       ok(r == 0, "storage not released\n");
 408       ok(DeleteFileA(filenameA), "failed to delete file\n");
 409    }
 410
 411    /* looks like we need STGM_TRANSACTED or STGM_CREATE */
 412    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 413    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 414    if(r == S_OK)
 415    {
 416       r = IStorage_Release(stg);
 417       ok(r == 0, "storage not released\n");
 418       ok(DeleteFileA(filenameA), "failed to delete file\n");
 419    }
 420
 421    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_WRITE, 0, &stg);
 422    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 423    if(r == S_OK)
 424    {
 425       r = IStorage_Release(stg);
 426       ok(r == 0, "storage not released\n");
 427       ok(DeleteFileA(filenameA), "failed to delete file\n");
 428    }
 429
 430    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 431    ok(r==S_OK, "StgCreateDocfile the powerpoint way failed\n");
 432    if(r == S_OK)
 433    {
 434       r = IStorage_Release(stg);
 435       ok(r == 0, "storage not released\n");
 436       ok(DeleteFileA(filenameA), "failed to delete file\n");
 437    }
 438
 439    /* test the way msi uses StgCreateDocfile */
 440    r = StgCreateDocfile( filename, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg);
 441    ok(r==S_OK, "StgCreateDocFile failed\n");
 442    r = IStorage_Release(stg);
 443    ok(r == 0, "storage not released\n");
 444    ok(DeleteFileA(filenameA), "failed to delete file\n");
 445 }
 446
 447 static void test_stgcreatestorageex(void)
 448 {
 449    HRESULT (WINAPI *pStgCreateStorageEx)(const WCHAR* pwcsName, DWORD grfMode, DWORD stgfmt, DWORD grfAttrs, STGOPTIONS* pStgOptions, void* reserved, REFIID riid, void** ppObjectOpen);
 450    HMODULE hOle32 = GetModuleHandleA("ole32");
 451    IStorage *stg = NULL;
 452    STGOPTIONS stgoptions = {1, 0, 4096};
 453    HRESULT r;
 454
 455    pStgCreateStorageEx = (void *) GetProcAddress(hOle32, "StgCreateStorageEx");
 456    if (!pStgCreateStorageEx)
 457    {
 458       win_skip("skipping test on NT4\n");
 459       return;
 460    }
 461
 462    DeleteFileA(filenameA);
 463
 464    /* Verify that StgCreateStorageEx can accept an options param */
 465    r = pStgCreateStorageEx( filename,
 466                            STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
 467                            STGFMT_DOCFILE,
 468                            0,
 469                            &stgoptions,
 470                            NULL,
 471                            &IID_IStorage,
 472                            (void **) &stg);
 473    ok(r==S_OK || r==STG_E_UNIMPLEMENTEDFUNCTION, "StgCreateStorageEx with options failed\n");
 474    if (r==STG_E_UNIMPLEMENTEDFUNCTION)
 475    {
 476       /* We're on win98 which means all bets are off.  Let's get out of here. */
 477       win_skip("skipping test on win9x\n");
 478       return;
 479    }
 480
 481    r = IStorage_Release(stg);
 482    ok(r == 0, "storage not released\n");
 483    ok(DeleteFileA(filenameA), "failed to delete file\n");
 484
 485    /* Verify that StgCreateStorageEx can accept a NULL pStgOptions */
 486    r = pStgCreateStorageEx( filename,
 487                            STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
 488                            STGFMT_STORAGE,
 489                            0,
 490                            NULL,
 491                            NULL,
 492                            &IID_IStorage,
 493                            (void **) &stg);
 494    ok(r==S_OK, "StgCreateStorageEx with NULL options failed\n");
 495    r = IStorage_Release(stg);
 496    ok(r == 0, "storage not released\n");
 497    ok(DeleteFileA(filenameA), "failed to delete file\n");
 498 }
 499
 500 static void test_storage_stream(void)
 501 {
 502     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 503     static const WCHAR longname[] = {
 504         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
 505         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
 506     };
 507     IStorage *stg = NULL;
 508     HRESULT r;
 509     IStream *stm = NULL;
 510     IStream *stm2 = NULL;
 511     ULONG count = 0;
 512     LARGE_INTEGER pos;
 513     ULARGE_INTEGER p;
 514     unsigned char buffer[0x100];
 515     IUnknown *unk;
 516     BOOL ret;
 517
 518     DeleteFileA(filenameA);
 519
 520     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 521     ok(r==S_OK, "StgCreateDocfile failed\n");
 522
 523     /* try create some invalid streams */
 524     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, 0, &stm );
 525     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 526     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 1, &stm );
 527     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 528     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, NULL );
 529     ok(r==STG_E_INVALIDPOINTER, "IStorage->CreateStream wrong error\n");
 530     r = IStorage_CreateStream(stg, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 531     ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error\n");
 532     r = IStorage_CreateStream(stg, longname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 533     ok(r==STG_E_INVALIDNAME || broken(r==S_OK) /* nt4 */,
 534        "IStorage->CreateStream wrong error, got %d GetLastError()=%d\n", r, GetLastError());
 535     r = IStorage_CreateStream(stg, stmname, STGM_READWRITE, 0, 0, &stm );
 536     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 537     r = IStorage_CreateStream(stg, stmname, STGM_READ, 0, 0, &stm );
 538     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 539     r = IStorage_CreateStream(stg, stmname, STGM_WRITE, 0, 0, &stm );
 540     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 541     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, 0, &stm );
 542     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 543     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READ, 0, 0, &stm );
 544     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 545
 546     /* now really create a stream and delete it */
 547     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 548     ok(r==S_OK, "IStorage->CreateStream failed\n");
 549
 550     /* test for support interfaces */
 551     r = IStream_QueryInterface(stm, &IID_IPersist, (void**)&unk);
 552     ok(r==E_NOINTERFACE, "got 0x%08x\n", r);
 553     r = IStream_QueryInterface(stm, &IID_IPersistStream, (void**)&unk);
 554     ok(r==E_NOINTERFACE, "got 0x%08x\n", r);
 555
 556     r = IStream_Release(stm);
 557     ok(r == 0, "wrong ref count\n");
 558     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 559     ok(r==STG_E_FILEALREADYEXISTS, "IStorage->CreateStream failed\n");
 560     r = IStorage_DestroyElement(stg,stmname);
 561     ok(r==S_OK, "IStorage->DestroyElement failed\n");
 562
 563     /* create a stream and write to it */
 564     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 565     ok(r==S_OK, "IStorage->CreateStream failed\n");
 566
 567     r = IStream_Clone(stm, &stm2);
 568     ok(r==S_OK, "failed to clone stream\n");
 569
 570     r = IStream_Write(stm, NULL, 0, NULL );
 571     ok(r==STG_E_INVALIDPOINTER, "IStream->Write wrong error\n");
 572     r = IStream_Write(stm, "Hello\n", 0, NULL );
 573     ok(r==S_OK, "failed to write stream\n");
 574     r = IStream_Write(stm, "Hello\n", 0, &count );
 575     ok(r==S_OK, "failed to write stream\n");
 576     r = IStream_Write(stm, "Hello\n", 6, &count );
 577     ok(r==S_OK, "failed to write stream\n");
 578     r = IStream_Commit(stm, STGC_DEFAULT );
 579     ok(r==S_OK, "failed to commit stream\n");
 580     r = IStream_Commit(stm, STGC_DEFAULT );
 581     ok(r==S_OK, "failed to commit stream\n");
 582
 583     /* Read past the end of the stream. */
 584     pos.QuadPart = 3;
 585     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 586     ok(r==S_OK, "failed to seek stream\n");
 587     ok(p.QuadPart == 3, "at wrong place\n");
 588     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 589     ok(r==S_OK, "failed to read\n");
 590     ok(count == 3, "read bytes past end of stream\n");
 591     pos.QuadPart = 10;
 592     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 593     ok(r==S_OK, "failed to seek stream\n");
 594     ok(p.QuadPart == 10, "at wrong place\n");
 595     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 596     ok(r==S_OK, "failed to read\n");
 597     ok(count == 0, "read bytes past end of stream\n");
 598     pos.QuadPart = 10000;
 599     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 600     ok(r==S_OK, "failed to seek stream\n");
 601     ok(p.QuadPart == 10000, "at wrong place\n");
 602     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 603     ok(r==S_OK, "failed to read\n");
 604     ok(count == 0, "read bytes past end of stream\n");
 605
 606     /* Convert to a big block stream, and read past the end. */
 607     p.QuadPart = 5000;
 608     r = IStream_SetSize(stm,p);
 609     ok(r==S_OK, "failed to set pos\n");
 610     pos.QuadPart = 4997;
 611     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 612     ok(r==S_OK, "failed to seek stream\n");
 613     ok(p.QuadPart == 4997, "at wrong place\n");
 614     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 615     ok(r==S_OK, "failed to read\n");
 616     ok(count == 3, "read bytes past end of stream\n");
 617     pos.QuadPart = 5001;
 618     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 619     ok(r==S_OK, "failed to seek stream\n");
 620     ok(p.QuadPart == 5001, "at wrong place\n");
 621     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 622     ok(r==S_OK, "failed to read\n");
 623     ok(count == 0, "read bytes past end of stream\n");
 624     pos.QuadPart = 10000;
 625     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 626     ok(r==S_OK, "failed to seek stream\n");
 627     ok(p.QuadPart == 10000, "at wrong place\n");
 628     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 629     ok(r==S_OK, "failed to read\n");
 630     ok(count == 0, "read bytes past end of stream\n");
 631
 632     /* seek round a bit, reset the stream size */
 633     pos.QuadPart = 0;
 634     r = IStream_Seek(stm, pos, 3, &p );
 635     ok(r==STG_E_INVALIDFUNCTION, "IStream->Seek returned wrong error\n");
 636     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
 637     ok(r==S_OK, "failed to seek stream\n");
 638     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 639     ok(r==S_OK, "failed to seek stream\n");
 640     r = IStream_SetSize(stm,p);
 641     ok(r==S_OK, "failed to set pos\n");
 642     pos.QuadPart = 10;
 643     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 644     ok(r==S_OK, "failed to seek stream\n");
 645     ok(p.QuadPart == 10, "at wrong place\n");
 646     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 647     ok(r==S_OK, "failed to set pos\n");
 648     ok(count == 0, "read bytes from empty stream\n");
 649     pos.QuadPart = 10000;
 650     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 651     ok(r==S_OK, "failed to seek stream\n");
 652     ok(p.QuadPart == 10000, "at wrong place\n");
 653     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 654     ok(r==S_OK, "failed to set pos\n");
 655     ok(count == 0, "read bytes from empty stream\n");
 656     pos.QuadPart = 0;
 657     r = IStream_Seek(stm, pos, STREAM_SEEK_END, &p );
 658     ok(r==S_OK, "failed to seek stream\n");
 659     ok(p.QuadPart == 0, "at wrong place\n");
 660     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 661     ok(r==S_OK, "failed to set pos\n");
 662     ok(count == 0, "read bytes from empty stream\n");
 663
 664     /* wrap up */
 665     r = IStream_Release(stm2);
 666     ok(r == 0, "wrong ref count\n");
 667
 668     /* create a stream and write to it */
 669     r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
 670     ok(r==S_OK, "IStorage->CreateStream failed\n");
 671
 672     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p);
 673     ok(r==STG_E_REVERTED, "overwritten stream should return STG_E_REVERTED instead of 0x%08x\n", r);
 674
 675     r = IStream_Release(stm2);
 676     ok(r == 0, "wrong ref count\n");
 677     r = IStream_Release(stm);
 678     ok(r == 0, "wrong ref count\n");
 679
 680     r = IStorage_Release(stg);
 681     ok(r == 0, "wrong ref count\n");
 682
 683     /* try create some invalid streams */
 684     stg = NULL;
 685     stm = NULL;
 686     r = StgOpenStorage(filename, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 687     ok(r == S_OK, "should succeed\n");
 688     if (stg)
 689     {
 690         r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
 691         ok(r == STG_E_INVALIDFLAG, "IStorage->OpenStream should return STG_E_INVALIDFLAG instead of 0x%08x\n", r);
 692         IStorage_Release(stg);
 693     }
 694
 695     ret = DeleteFileA(filenameA);
 696     ok(ret, "file should exist\n");
 697 }
 698
 699 static BOOL touch_file(LPCSTR filename)
 700 {
 701     HANDLE file;
 702
 703     file = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
 704                 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 705     if (file==INVALID_HANDLE_VALUE)
 706         return FALSE;
 707     CloseHandle(file);
 708     return TRUE;
 709 }
 710
 711 static BOOL is_zero_length(LPCSTR filename)
 712 {
 713     HANDLE file;
 714     DWORD len;
 715
 716     file = CreateFileA(filename, GENERIC_READ, 0, NULL,
 717                 OPEN_EXISTING, 0, NULL);
 718     if (file==INVALID_HANDLE_VALUE)
 719         return FALSE;
 720     len = GetFileSize(file, NULL);
 721     CloseHandle(file);
 722     return len == 0;
 723 }
 724
 725 static BOOL is_existing_file(LPCSTR filename)
 726 {
 727     HANDLE file;
 728
 729     file = CreateFileA(filename, GENERIC_READ, 0, NULL,
 730                        OPEN_EXISTING, 0, NULL);
 731     if (file==INVALID_HANDLE_VALUE)
 732         return FALSE;
 733     CloseHandle(file);
 734     return TRUE;
 735 }
 736
 737 static void test_open_storage(void)
 738 {
 739     static const WCHAR szNonExist[] = { 'n','o','n','e','x','i','s','t',0 };
 740     IStorage *stg = NULL, *stg2 = NULL;
 741     HRESULT r;
 742     DWORD stgm;
 743     BOOL ret;
 744
 745     /* try opening a zero length file - it should stay zero length */
 746     DeleteFileA(filenameA);
 747     touch_file(filenameA);
 748     stgm = STGM_NOSCRATCH | STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READWRITE;
 749     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 750     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 751
 752     stgm = STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
 753     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 754     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 755     ok(is_zero_length(filenameA), "file length changed\n");
 756
 757     DeleteFileA(filenameA);
 758
 759     /* try opening a nonexistent file - it should not create it */
 760     stgm = STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
 761     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 762     ok(r!=S_OK, "StgOpenStorage failed: 0x%08x\n", r);
 763     if (r==S_OK) IStorage_Release(stg);
 764     ok(!is_existing_file(filenameA), "StgOpenStorage should not create a file\n");
 765     DeleteFileA(filenameA);
 766
 767     /* create the file */
 768     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 769     ok(r==S_OK, "StgCreateDocfile failed\n");
 770     IStorage_Release(stg);
 771
 772     r = StgOpenStorage( filename, NULL, 0, NULL, 0, &stg);
 773     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage wrong error\n");
 774     r = StgOpenStorage( NULL, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 775     ok(r==STG_E_INVALIDNAME, "StgOpenStorage wrong error\n");
 776     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, NULL);
 777     ok(r==STG_E_INVALIDPOINTER, "StgOpenStorage wrong error\n");
 778     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 1, &stg);
 779     ok(r==STG_E_INVALIDPARAMETER, "StgOpenStorage wrong error\n");
 780     r = StgOpenStorage( szNonExist, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 781     ok(r==STG_E_FILENOTFOUND, "StgOpenStorage failed\n");
 782     r = StgOpenStorage( filename, NULL, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 783     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 784     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
 785     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 786     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_READ | STGM_READ, NULL, 0, &stg);
 787     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 788     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 789     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 790
 791     /* open it for real */
 792     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg); /* XLViewer 97/2000 */
 793     ok(r==S_OK, "StgOpenStorage failed\n");
 794     if(stg)
 795     {
 796         r = IStorage_Release(stg);
 797         ok(r == 0, "wrong ref count\n");
 798     }
 799
 800     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READ, NULL, 0, &stg);
 801     ok(r==S_OK, "StgOpenStorage failed\n");
 802     if(stg)
 803     {
 804         r = IStorage_Release(stg);
 805         ok(r == 0, "wrong ref count\n");
 806     }
 807
 808     /* test the way word opens its custom dictionary */
 809     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_TRANSACTED |
 810                         STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 811     ok(r==S_OK, "StgOpenStorage failed\n");
 812     if(stg)
 813     {
 814         r = IStorage_Release(stg);
 815         ok(r == 0, "wrong ref count\n");
 816     }
 817
 818     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 819     ok(r==S_OK, "StgOpenStorage failed\n");
 820     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2);
 821     ok(r==STG_E_SHAREVIOLATION, "StgOpenStorage failed\n");
 822     if(stg)
 823     {
 824         r = IStorage_Release(stg);
 825         ok(r == 0, "wrong ref count\n");
 826     }
 827
 828     /* now try write to a storage file we opened read-only */
 829     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 830     ok(r==S_OK, "StgOpenStorage failed\n");
 831     if(stg)
 832     {
 833         static const WCHAR stmname[] =  { 'w','i','n','e','t','e','s','t',0};
 834         IStream *stm = NULL;
 835         IStorage *stg2 = NULL;
 836
 837         r = IStorage_CreateStream( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
 838                                    0, 0, &stm );
 839         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 840         r = IStorage_CreateStorage( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
 841         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 842
 843         r = IStorage_Release(stg);
 844         ok(r == 0, "wrong ref count\n");
 845     }
 846
 847     /* open like visio 2003 */
 848     stg = NULL;
 849     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
 850     ok(r == S_OK, "should succeed\n");
 851     if (stg)
 852         IStorage_Release(stg);
 853
 854     /* test other sharing modes with STGM_PRIORITY */
 855     stg = NULL;
 856     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 857     ok(r == S_OK, "should succeed\n");
 858     if (stg)
 859         IStorage_Release(stg);
 860
 861     stg = NULL;
 862     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 863     ok(r == S_OK, "should succeed\n");
 864     if (stg)
 865         IStorage_Release(stg);
 866
 867     stg = NULL;
 868     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_READ, NULL, 0, &stg);
 869     ok(r == S_OK, "should succeed\n");
 870     if (stg)
 871         IStorage_Release(stg);
 872
 873     /* open like Project 2003 */
 874     stg = NULL;
 875     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg);
 876     ok(r == S_OK, "should succeed\n");
 877     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg2);
 878     ok(r == S_OK, "should succeed\n");
 879     if (stg2)
 880         IStorage_Release(stg2);
 881     if (stg)
 882         IStorage_Release(stg);
 883
 884     stg = NULL;
 885     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_READWRITE, NULL, 0, &stg);
 886     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 887
 888     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_PRIORITY, NULL, 0, &stg);
 889     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 890
 891     r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_PRIORITY, NULL, 0, &stg);
 892     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 893
 894     r = StgOpenStorage( filename, NULL, STGM_DELETEONRELEASE | STGM_PRIORITY, NULL, 0, &stg);
 895     ok(r == STG_E_INVALIDFUNCTION, "should fail\n");
 896
 897     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_PRIORITY, NULL, 0, &stg);
 898     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 899
 900     r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg);
 901     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 902
 903     ret = DeleteFileA(filenameA);
 904     ok(ret, "file didn't exist\n");
 905 }
 906
 907 static void test_storage_suminfo(void)
 908 {
 909     IStorage *stg = NULL;
 910     IPropertySetStorage *propset = NULL;
 911     IPropertyStorage *ps = NULL;
 912     HRESULT r;
 913
 914     DeleteFileA(filenameA);
 915
 916     /* create the file */
 917     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 918                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 919     ok(r==S_OK, "StgCreateDocfile failed\n");
 920
 921     r = IStorage_QueryInterface( stg, &IID_IPropertySetStorage, (LPVOID) &propset );
 922     ok(r == S_OK, "query interface failed\n");
 923
 924     /* delete it */
 925     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 926     ok(r == STG_E_FILENOTFOUND, "deleted property set storage\n");
 927
 928     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 929                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 930     ok(r == STG_E_FILENOTFOUND, "opened property set storage\n");
 931
 932     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 933                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 934     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 935
 936     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 937                                 STGM_READ, &ps );
 938     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 939
 940     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0, 0, &ps );
 941     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 942
 943     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 944                                 STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 945     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 946
 947     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 948                                 STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 949     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 950
 951     /* now try really creating a property set */
 952     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 953                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 954     ok(r == S_OK, "failed to create property set storage\n");
 955
 956     if( ps )
 957         IPropertyStorage_Release(ps);
 958
 959     /* now try creating the same thing again */
 960     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 961                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 962     ok(r == S_OK, "failed to create property set storage\n");
 963     if( ps )
 964         IPropertyStorage_Release(ps);
 965
 966     /* should be able to open it */
 967     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 968             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 969     ok(r == S_OK, "open failed\n");
 970     if(r == S_OK)
 971         IPropertyStorage_Release(ps);
 972
 973     /* delete it */
 974     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 975     ok(r == S_OK, "failed to delete property set storage\n");
 976
 977     /* try opening with an invalid FMTID */
 978     r = IPropertySetStorage_Open( propset, NULL,
 979             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 980     ok(r == E_INVALIDARG, "open succeeded\n");
 981     if(r == S_OK)
 982         IPropertyStorage_Release(ps);
 983
 984     /* try a bad guid */
 985     r = IPropertySetStorage_Open( propset, &IID_IStorage,
 986             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 987     ok(r == STG_E_FILENOTFOUND, "open succeeded\n");
 988     if(r == S_OK)
 989         IPropertyStorage_Release(ps);
 990
 991
 992     /* try some invalid flags */
 993     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 994             STGM_CREATE | STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 995     ok(r == STG_E_INVALIDFLAG, "open succeeded\n");
 996     if(r == S_OK)
 997         IPropertyStorage_Release(ps);
 998
 999     /* after deleting it, it should be gone */
1000     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
1001             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
1002     ok(r == STG_E_FILENOTFOUND, "open failed\n");
1003     if(r == S_OK)
1004         IPropertyStorage_Release(ps);
1005
1006     r = IPropertySetStorage_Release( propset );
1007     ok(r == 1, "ref count wrong\n");
1008
1009     r = IStorage_Release(stg);
1010     ok(r == 0, "ref count wrong\n");
1011
1012     DeleteFileA(filenameA);
1013 }
1014
1015 static void test_storage_refcount(void)
1016 {
1017     IStorage *stg = NULL;
1018     IStorage *stgprio = NULL;
1019     HRESULT r;
1020     IStream *stm = NULL;
1021     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1022     LARGE_INTEGER pos;
1023     ULARGE_INTEGER upos;
1024     STATSTG stat;
1025     char buffer[10];
1026
1027     DeleteFileA(filenameA);
1028
1029     /* create the file */
1030     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1031                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1032     ok(r==S_OK, "StgCreateDocfile failed\n");
1033
1034     r = WriteClassStg( stg, &test_stg_cls );
1035     ok( r == S_OK, "WriteClassStg failed\n");
1036
1037     r = IStorage_Commit( stg, STGC_DEFAULT );
1038     ok( r == S_OK, "IStorage_Commit failed\n");
1039
1040     /* now create a stream */
1041     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1042     ok(r==S_OK, "IStorage->CreateStream failed\n");
1043
1044     r = IStorage_Release( stg );
1045     ok (r == 0, "storage not released\n");
1046
1047     pos.QuadPart = 0;
1048     r = IStream_Seek( stm, pos, 0, &upos );
1049     ok (r == STG_E_REVERTED, "seek should fail\n");
1050
1051     r = IStream_Stat( stm, &stat, STATFLAG_DEFAULT );
1052     ok (r == STG_E_REVERTED, "stat should fail\n");
1053
1054     r = IStream_Write( stm, "Test string", strlen("Test string"), NULL);
1055     ok (r == STG_E_REVERTED, "IStream_Write should return STG_E_REVERTED instead of 0x%08x\n", r);
1056
1057     r = IStream_Read( stm, buffer, sizeof(buffer), NULL);
1058     ok (r == STG_E_REVERTED, "IStream_Read should return STG_E_REVERTED instead of 0x%08x\n", r);
1059
1060     r = IStream_Release(stm);
1061     ok (r == 0, "stream not released\n");
1062
1063     /* tests that STGM_PRIORITY doesn't prevent readwrite access from other
1064      * StgOpenStorage calls in transacted mode */
1065     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stgprio);
1066     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
1067
1068     /* non-transacted mode read/write fails */
1069     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
1070     ok(r==STG_E_LOCKVIOLATION, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08x\n", r);
1071
1072     /* non-transacted mode read-only succeeds */
1073     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE|STGM_READ, NULL, 0, &stg);
1074     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
1075     IStorage_Release(stg);
1076
1077     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, NULL, 0, &stg);
1078     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
1079     if(stg)
1080     {
1081         static const WCHAR stgname[] = { ' ',' ',' ','2','9',0 };
1082         static const WCHAR stgname2[] = { 'C','V','_','i','e','w',0 };
1083         static const WCHAR stmname2[] = { 'V','a','r','2','D','a','t','a',0 };
1084         IStorage *stg2;
1085         IStorage *stg3;
1086         STATSTG statstg;
1087
1088         r = IStorage_Stat( stg, &statstg, STATFLAG_NONAME );
1089         ok(r == S_OK, "Stat should have succeeded instead of returning 0x%08x\n", r);
1090         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
1091         ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
1092         ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
1093         ok(statstg.grfMode == (STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE),
1094             "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg.grfMode);
1095         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
1096         ok(IsEqualCLSID(&statstg.clsid, &test_stg_cls), "Statstg clsid is not test_stg_cls\n");
1097         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
1098         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
1099
1100         r = IStorage_CreateStorage( stg, stgname, STGM_SHARE_EXCLUSIVE, 0, 0, &stg2 );
1101         ok(r == S_OK, "CreateStorage should have succeeded instead of returning 0x%08x\n", r);
1102
1103         r = IStorage_Stat( stg2, &statstg, STATFLAG_DEFAULT );
1104         ok(r == S_OK, "Stat should have succeeded instead of returning 0x%08x\n", r);
1105         ok(!memcmp(statstg.pwcsName, stgname, sizeof(stgname)),
1106             "Statstg pwcsName should have been the name the storage was created with\n");
1107         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
1108         ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
1109         ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
1110         ok(statstg.grfMode == STGM_SHARE_EXCLUSIVE,
1111             "Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%x\n", statstg.grfMode);
1112         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
1113         ok(IsEqualCLSID(&statstg.clsid, &CLSID_NULL), "Statstg clsid is not CLSID_NULL\n");
1114         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
1115         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
1116         CoTaskMemFree(statstg.pwcsName);
1117
1118         r = IStorage_CreateStorage( stg2, stgname2, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stg3 );
1119         ok(r == STG_E_ACCESSDENIED, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
1120
1121         r = IStorage_CreateStream( stg2, stmname2, STGM_CREATE|STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
1122         ok(r == STG_E_ACCESSDENIED, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
1123
1124         IStorage_Release(stg2);
1125
1126         r = IStorage_Release(stg);
1127         ok(r == 0, "wrong ref count\n");
1128     }
1129
1130     /* Multiple STGM_PRIORITY opens are possible. */
1131     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg);
1132     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
1133     if(stg)
1134     {
1135         r = IStorage_Release(stg);
1136         ok(r == 0, "wrong ref count\n");
1137     }
1138
1139     r = StgOpenStorage( NULL, stgprio, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, NULL, 0, &stg);
1140     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
1141     if(stg)
1142     {
1143         static const WCHAR stgname[] = { ' ',' ',' ','2','9',0 };
1144         IStorage *stg2;
1145         STATSTG statstg;
1146
1147         r = IStorage_Stat( stg, &statstg, STATFLAG_NONAME );
1148         ok(r == S_OK, "Stat should have succeeded instead of returning 0x%08x\n", r);
1149         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
1150         ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
1151         ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
1152         ok(statstg.grfMode == (STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE),
1153             "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg.grfMode);
1154         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
1155         ok(IsEqualCLSID(&statstg.clsid, &test_stg_cls), "Statstg clsid is not test_stg_cls\n");
1156         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
1157         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
1158
1159         r = IStorage_CreateStorage( stg, stgname, STGM_SHARE_EXCLUSIVE, 0, 0, &stg2 );
1160         ok(r == S_OK, "CreateStorage should have succeeded instead of returning 0x%08x\n", r);
1161
1162         IStorage_Release(stg2);
1163
1164         r = IStorage_Commit( stg, 0 );
1165         ok(r == S_OK, "Commit should have succeeded instead of returning 0x%08x\n", r);
1166
1167         r = IStorage_Release(stg);
1168         ok(r == 0, "wrong ref count\n");
1169     }
1170     /* IStorage_Release(stgprio) not necessary because StgOpenStorage released it. */
1171
1172     DeleteFileA(filenameA);
1173 }
1174
1175 static void test_writeclassstg(void)
1176 {
1177     IStorage *stg = NULL;
1178     HRESULT r;
1179     CLSID temp_cls, cls2;
1180
1181     DeleteFileA(filenameA);
1182
1183     /* create the file */
1184     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1185                             STGM_READWRITE, 0, &stg);
1186     ok(r==S_OK, "StgCreateDocfile failed\n");
1187
1188     r = ReadClassStg( NULL, NULL );
1189     ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
1190
1191     memset(&temp_cls, 0xcc, sizeof(temp_cls));
1192     memset(&cls2, 0xcc, sizeof(cls2));
1193     r = ReadClassStg( NULL, &temp_cls );
1194     ok(r == E_INVALIDARG, "got 0x%08x\n", r);
1195     ok(IsEqualCLSID(&temp_cls, &cls2), "got wrong clsid\n");
1196
1197     r = ReadClassStg( stg, NULL );
1198     ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
1199
1200     temp_cls.Data1 = 0xdeadbeef;
1201     r = ReadClassStg( stg, &temp_cls );
1202     ok(r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
1203
1204     ok(IsEqualCLSID(&temp_cls, &CLSID_NULL), "ReadClassStg returned wrong clsid\n");
1205
1206     r = WriteClassStg( NULL, NULL );
1207     ok(r == E_INVALIDARG, "WriteClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
1208
1209     r = WriteClassStg( stg, NULL );
1210     ok(r == STG_E_INVALIDPOINTER, "WriteClassStg should return STG_E_INVALIDPOINTER instead of 0x%08X\n", r);
1211
1212     r = WriteClassStg( stg, &test_stg_cls );
1213     ok( r == S_OK, "WriteClassStg failed with 0x%08X\n", r);
1214
1215     r = ReadClassStg( stg, &temp_cls );
1216     ok( r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
1217     ok(IsEqualCLSID(&temp_cls, &test_stg_cls), "ReadClassStg returned wrong clsid\n");
1218
1219     r = IStorage_Release( stg );
1220     ok (r == 0, "storage not released\n");
1221
1222     DeleteFileA(filenameA);
1223 }
1224
1225 static void test_streamenum(void)
1226 {
1227     IStorage *stg = NULL;
1228     HRESULT r;
1229     IStream *stm = NULL;
1230     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1231     static const WCHAR stmname2[] = { 'A','B','C','D','E','F','G','H','I',0 };
1232     static const WCHAR stmname3[] = { 'A','B','C','D','E','F','G','H','I','J',0 };
1233     static const STATSTG stat_null;
1234     STATSTG stat;
1235     IEnumSTATSTG *ee = NULL;
1236     ULONG count;
1237
1238     DeleteFileA(filenameA);
1239
1240     /* create the file */
1241     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1242                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1243     ok(r==S_OK, "StgCreateDocfile failed\n");
1244
1245     r = WriteClassStg( stg, &test_stg_cls );
1246     ok( r == S_OK, "WriteClassStg failed\n");
1247
1248     r = IStorage_Commit( stg, STGC_DEFAULT );
1249     ok( r == S_OK, "IStorage_Commit failed\n");
1250
1251     /* now create a stream */
1252     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1253     ok(r==S_OK, "IStorage->CreateStream failed\n");
1254
1255     IStream_Release(stm);
1256
1257     /* first enum ... should be 1 stream */
1258     r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
1259     ok(r==S_OK, "IStorage->EnumElements failed\n");
1260
1261     count = 0xf00;
1262     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1263     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
1264     ok(count == 1, "count wrong\n");
1265
1266     if (r == S_OK)
1267         CoTaskMemFree(stat.pwcsName);
1268
1269     r = IEnumSTATSTG_Release(ee);
1270     ok(r==S_OK, "EnumSTATSTG_Release failed with error 0x%08x\n", r);
1271
1272     /* second enum... destroy the stream before reading */
1273     r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
1274     ok(r==S_OK, "IStorage->EnumElements failed\n");
1275
1276     r = IStorage_DestroyElement(stg, stmname);
1277     ok(r==S_OK, "IStorage->DestroyElement failed\n");
1278
1279     memset(&stat, 0xad, sizeof(stat));
1280     count = 0xf00;
1281     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1282     ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
1283     ok(count == 0, "count wrong\n");
1284     ok(memcmp(&stat, &stat_null, sizeof(stat)) == 0, "stat is not zeroed\n");
1285
1286     /* reset and try again */
1287     r = IEnumSTATSTG_Reset(ee);
1288     ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
1289
1290     count = 0xf00;
1291     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1292     ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
1293     ok(count == 0, "count wrong\n");
1294
1295     /* add a stream before reading */
1296     r = IEnumSTATSTG_Reset(ee);
1297     ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
1298
1299     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1300     ok(r==S_OK, "IStorage->CreateStream failed\n");
1301
1302     r = IStream_Release(stm);
1303     ok(r==S_OK, "Stream_Release failed with error 0x%08x\n", r);
1304
1305     count = 0xf00;
1306     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1307     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
1308     ok(count == 1, "count wrong\n");
1309
1310     if (r == S_OK)
1311     {
1312         ok(lstrcmpiW(stat.pwcsName, stmname) == 0, "expected CONTENTS, got %s\n", wine_dbgstr_w(stat.pwcsName));
1313         CoTaskMemFree(stat.pwcsName);
1314     }
1315
1316     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1317     ok(r==S_OK, "IStorage->CreateStream failed\n");
1318
1319     r = IStream_Release(stm);
1320     ok(r==S_OK, "Stream_Release failed with error 0x%08x\n", r);
1321
1322     count = 0xf00;
1323     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1324     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
1325     ok(count == 1, "count wrong\n");
1326
1327     if (r == S_OK)
1328     {
1329         ok(lstrcmpiW(stat.pwcsName, stmname2) == 0, "expected ABCDEFGHI, got %s\n", wine_dbgstr_w(stat.pwcsName));
1330         CoTaskMemFree(stat.pwcsName);
1331     }
1332
1333     /* delete previous and next stream after reading */
1334     r = IStorage_CreateStream(stg, stmname3, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1335     ok(r==S_OK, "IStorage->CreateStream failed\n");
1336
1337     r = IStream_Release(stm);
1338     ok(r==S_OK, "Stream_Release failed with error 0x%08x\n", r);
1339
1340     r = IEnumSTATSTG_Reset(ee);
1341     ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
1342
1343     count = 0xf00;
1344     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1345     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
1346     ok(count == 1, "count wrong\n");
1347
1348     if (r == S_OK)
1349     {
1350         ok(lstrcmpiW(stat.pwcsName, stmname) == 0, "expected CONTENTS, got %s\n", wine_dbgstr_w(stat.pwcsName));
1351         CoTaskMemFree(stat.pwcsName);
1352     }
1353
1354     r = IStorage_DestroyElement(stg, stmname);
1355     ok(r==S_OK, "IStorage->DestroyElement failed\n");
1356
1357     r = IStorage_DestroyElement(stg, stmname2);
1358     ok(r==S_OK, "IStorage->DestroyElement failed\n");
1359
1360     count = 0xf00;
1361     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1362     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
1363     ok(count == 1, "count wrong\n");
1364
1365     if (r == S_OK)
1366     {
1367         ok(lstrcmpiW(stat.pwcsName, stmname3) == 0, "expected ABCDEFGHIJ, got %s\n", wine_dbgstr_w(stat.pwcsName));
1368         CoTaskMemFree(stat.pwcsName);
1369     }
1370
1371     r = IStorage_Release( stg );
1372     todo_wine ok (r == 0, "storage not released\n");
1373
1374     /* enumerator is still valid and working after the storage is released */
1375     r = IEnumSTATSTG_Reset(ee);
1376     ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
1377
1378     count = 0xf00;
1379     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
1380     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
1381     ok(count == 1, "count wrong\n");
1382
1383     if (r == S_OK)
1384     {
1385         ok(lstrcmpiW(stat.pwcsName, stmname3) == 0, "expected ABCDEFGHIJ, got %s\n", wine_dbgstr_w(stat.pwcsName));
1386         CoTaskMemFree(stat.pwcsName);
1387     }
1388
1389     /* the storage is left open until the enumerator is freed */
1390     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE |
1391                             STGM_READWRITE |STGM_TRANSACTED, NULL, 0, &stg);
1392     ok(r==STG_E_SHAREVIOLATION ||
1393        r==STG_E_LOCKVIOLATION, /* XP-SP2/W2K3-SP1 and below */
1394        "StgCreateDocfile failed, res=%x\n", r);
1395
1396     r = IEnumSTATSTG_Release(ee);
1397     ok (r == 0, "enum not released\n");
1398
1399     DeleteFileA(filenameA);
1400 }
1401
1402 static void test_transact(void)
1403 {
1404     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1405     HRESULT r;
1406     IStream *stm = NULL;
1407     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1408     static const WCHAR stmname2[] = { 'F','O','O',0 };
1409     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1410     static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
1411     BOOL ret;
1412
1413     DeleteFileA(filenameA);
1414
1415     /* create the file */
1416     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1417                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1418     ok(r==S_OK, "StgCreateDocfile failed\n");
1419
1420     /* commit a new stream and storage */
1421     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1422     ok(r==S_OK, "IStorage->CreateStream failed\n");
1423
1424     r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
1425     ok(r==S_OK, "IStream->Write failed\n");
1426
1427     IStream_Release(stm);
1428
1429     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1430     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1431
1432     if (r == S_OK)
1433     {
1434         /* Create two substorages but only commit one */
1435         r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1436         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1437
1438         if (r == S_OK)
1439             IStorage_Release(stg3);
1440
1441         r = IStorage_Commit(stg, 0);
1442         ok(r==S_OK, "IStorage->Commit failed\n");
1443
1444         r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1445         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1446
1447         if (r == S_OK)
1448             IStorage_Release(stg3);
1449
1450         IStorage_Release(stg2);
1451     }
1452
1453     /* now create a stream and storage, but don't commit them */
1454     stm = NULL;
1455     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1456     ok(r==S_OK, "IStorage->CreateStream failed\n");
1457
1458     r = IStream_Write(stm, "this is stream 2\n", 16, NULL);
1459     ok(r==S_OK, "IStream->Write failed\n");
1460
1461     /* IStream::Commit does nothing for OLE storage streams */
1462     r = IStream_Commit(stm, STGC_ONLYIFCURRENT | STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
1463     ok(r==S_OK, "IStream->Commit failed\n");
1464
1465     r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1466     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1467
1468     if (r == S_OK)
1469         IStorage_Release(stg2);
1470
1471     IStream_Release(stm);
1472
1473     IStorage_Release(stg);
1474
1475     stm = NULL;
1476     stg = NULL;
1477     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg);
1478     ok(r==S_OK, "StgOpenStorage failed\n");
1479
1480     if (!stg)
1481         return;
1482
1483     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
1484     ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
1485
1486     r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1487     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1488
1489     r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1490     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1491
1492     r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1493     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1494
1495     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1496     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1497     if (r == S_OK)
1498         IStream_Release(stm);
1499
1500     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1501     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1502     if (r == S_OK)
1503         IStorage_Release(stg2);
1504
1505     r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1506     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1507
1508     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1509     ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1510     if (r == S_OK)
1511         IStream_Release(stm);
1512
1513     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1514     ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1515     if (r == S_OK)
1516     {
1517         r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1518         ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1519         if (r == S_OK)
1520             IStorage_Release(stg3);
1521
1522         r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1523         ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1524         if (r == S_OK)
1525             IStorage_Release(stg3);
1526
1527         IStorage_Release(stg2);
1528     }
1529
1530     IStorage_Release(stg);
1531
1532     ret = DeleteFileA(filenameA);
1533     ok(ret, "deleted file\n");
1534 }
1535
1536 static void test_substorage_share(void)
1537 {
1538     IStorage *stg, *stg2, *stg3;
1539     IStream *stm, *stm2;
1540     HRESULT r;
1541     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1542     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1543     static const WCHAR othername[] = { 'N','E','W','N','A','M','E',0 };
1544     BOOL ret;
1545
1546     DeleteFileA(filenameA);
1547
1548     /* create the file */
1549     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1550                             STGM_READWRITE, 0, &stg);
1551     ok(r==S_OK, "StgCreateDocfile failed\n");
1552
1553     /* create a read/write storage and try to open it again */
1554     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1555     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1556
1557     if (r == S_OK)
1558     {
1559         r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1560         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage should fail %08x\n", r);
1561
1562         if (r == S_OK)
1563             IStorage_Release(stg3);
1564
1565         r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1566         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage should fail %08x\n", r);
1567
1568         if (r == S_OK)
1569             IStorage_Release(stg3);
1570
1571         /* cannot rename the storage while it's open */
1572         r = IStorage_RenameElement(stg, stgname, othername);
1573         ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1574         if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stgname);
1575
1576         /* destroying an object while it's open invalidates it */
1577         r = IStorage_DestroyElement(stg, stgname);
1578         ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1579
1580         r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1581         ok(r==STG_E_REVERTED, "IStorage->CreateStream failed, hr=%08x\n", r);
1582
1583         if (r == S_OK)
1584             IStream_Release(stm);
1585
1586         IStorage_Release(stg2);
1587     }
1588
1589     /* create a read/write stream and try to open it again */
1590     r = IStorage_CreateStream(stg, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1591     ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
1592
1593     if (r == S_OK)
1594     {
1595         r = IStorage_OpenStream(stg, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1596         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1597
1598         if (r == S_OK)
1599             IStream_Release(stm2);
1600
1601         r = IStorage_OpenStream(stg, stmname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1602         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1603
1604         if (r == S_OK)
1605             IStream_Release(stm2);
1606
1607         /* cannot rename the stream while it's open */
1608         r = IStorage_RenameElement(stg, stmname, othername);
1609         ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1610         if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stmname);
1611
1612         /* destroying an object while it's open invalidates it */
1613         r = IStorage_DestroyElement(stg, stmname);
1614         ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1615
1616         r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1617         ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1618
1619         IStream_Release(stm);
1620     }
1621
1622     IStorage_Release(stg);
1623
1624     ret = DeleteFileA(filenameA);
1625     ok(ret, "deleted file\n");
1626 }
1627
1628 static void test_revert(void)
1629 {
1630     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1631     HRESULT r;
1632     IStream *stm = NULL, *stm2 = NULL;
1633     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1634     static const WCHAR stmname2[] = { 'F','O','O',0 };
1635     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1636     static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
1637     STATSTG statstg;
1638     BOOL ret;
1639
1640     DeleteFileA(filenameA);
1641
1642     /* create the file */
1643     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1644                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1645     ok(r==S_OK, "StgCreateDocfile failed\n");
1646
1647     /* commit a new stream and storage */
1648     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1649     ok(r==S_OK, "IStorage->CreateStream failed\n");
1650
1651     r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
1652     ok(r==S_OK, "IStream->Write failed\n");
1653
1654     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1655     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1656
1657     if (r == S_OK)
1658     {
1659         /* Create two substorages but only commit one */
1660         r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1661         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1662
1663         if (r == S_OK)
1664             IStorage_Release(stg3);
1665
1666         r = IStorage_Commit(stg, 0);
1667         ok(r==S_OK, "IStorage->Commit failed\n");
1668
1669         r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1670         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1671
1672         if (r == S_OK)
1673             IStorage_Release(stg3);
1674     }
1675
1676     /* now create a stream and storage, then revert */
1677     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
1678     ok(r==S_OK, "IStorage->CreateStream failed\n");
1679
1680     r = IStream_Write(stm2, "this is stream 2\n", 16, NULL);
1681     ok(r==S_OK, "IStream->Write failed\n");
1682
1683     r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1684     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1685
1686     r = IStorage_Revert(stg);
1687     ok(r==S_OK, "Storage_Revert failed with error 0x%08x\n", r);
1688
1689     /* all open objects become invalid */
1690     r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1691     ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1692
1693     r = IStream_Write(stm2, "this shouldn't work\n", 20, NULL);
1694     ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1695
1696     r = IStorage_Stat(stg2, &statstg, STATFLAG_NONAME);
1697     ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1698
1699     r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
1700     ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1701
1702     IStream_Release(stm);
1703     IStream_Release(stm2);
1704     IStorage_Release(stg2);
1705     IStorage_Release(stg3);
1706
1707     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
1708     ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
1709
1710     r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1711     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1712
1713     r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1714     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1715
1716     r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1717     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1718
1719     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1720     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1721     if (r == S_OK)
1722         IStream_Release(stm);
1723
1724     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1725     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1726     if (r == S_OK)
1727         IStorage_Release(stg2);
1728
1729     r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1730     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1731
1732     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1733     ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1734     if (r == S_OK)
1735         IStream_Release(stm);
1736
1737     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1738     ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1739     if (r == S_OK)
1740     {
1741         r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1742         ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1743         if (r == S_OK)
1744             IStorage_Release(stg3);
1745
1746         r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1747         ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1748         if (r == S_OK)
1749             IStorage_Release(stg3);
1750
1751         IStorage_Release(stg2);
1752     }
1753
1754     IStorage_Release(stg);
1755
1756     ret = DeleteFileA(filenameA);
1757     ok(ret, "deleted file\n");
1758
1759     /* Revert only invalidates objects in transacted mode */
1760     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1761                             STGM_READWRITE, 0, &stg);
1762     ok(r==S_OK, "StgCreateDocfile failed\n");
1763
1764     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1765     ok(r==S_OK, "IStorage->CreateStream failed\n");
1766
1767     r = IStorage_Revert(stg);
1768     ok(r==S_OK, "IStorage->Revert failed %08x\n", r);
1769
1770     r = IStream_Write(stm, "this works\n", 11, NULL);
1771     ok(r==S_OK, "IStream_Write should succeed %08x\n", r);
1772
1773     IStream_Release(stm);
1774     IStorage_Release(stg);
1775
1776     ret = DeleteFileA(filenameA);
1777     ok(ret, "deleted file\n");
1778 }
1779
1780 static void test_parent_free(void)
1781 {
1782     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1783     HRESULT r;
1784     IStream *stm = NULL;
1785     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1786     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1787     ULONG ref;
1788     STATSTG statstg;
1789     BOOL ret;
1790
1791     DeleteFileA(filenameA);
1792
1793     /* create the file */
1794     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1795                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1796     ok(r==S_OK, "StgCreateDocfile failed\n");
1797
1798     /* create a new storage */
1799     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1800     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1801
1802     if (r == S_OK)
1803     {
1804         /* now create a stream inside the new storage */
1805         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1806         ok(r==S_OK, "IStorage->CreateStream failed\n");
1807
1808         if (r == S_OK)
1809         {
1810             /* create a storage inside the new storage */
1811             r = IStorage_CreateStorage(stg2, stgname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg3 );
1812             ok(r==S_OK, "IStorage->CreateStorage failed\n");
1813         }
1814
1815         /* free the parent */
1816         ref = IStorage_Release(stg2);
1817         ok(ref == 0, "IStorage still has %u references\n", ref);
1818
1819         /* child objects are invalid */
1820         if (r == S_OK)
1821         {
1822             r = IStream_Write(stm, "this should fail\n", 17, NULL);
1823             ok(r==STG_E_REVERTED, "IStream->Write should fail, hr=%x\n", r);
1824
1825             IStream_Release(stm);
1826
1827             r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
1828             ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1829
1830             r = IStorage_SetStateBits(stg3, 1, 1);
1831             ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1832
1833             IStorage_Release(stg3);
1834         }
1835     }
1836
1837     IStorage_Release(stg);
1838
1839     ret = DeleteFileA(filenameA);
1840     ok(ret, "deleted file\n");
1841 }
1842
1843 static void test_nonroot_transacted(void)
1844 {
1845     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1846     HRESULT r;
1847     IStream *stm = NULL;
1848     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1849     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1850     static const WCHAR stmname2[] = { 'F','O','O',0 };
1851     BOOL ret;
1852
1853     DeleteFileA(filenameA);
1854
1855     /* create a transacted file */
1856     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1857                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1858     ok(r==S_OK, "StgCreateDocfile failed\n");
1859
1860     /* create a transacted substorage */
1861     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1862     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1863
1864     if (r == S_OK)
1865     {
1866         /* create and commit stmname */
1867         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1868         ok(r==S_OK, "IStorage->CreateStream failed\n");
1869         if (r == S_OK)
1870             IStream_Release(stm);
1871
1872         IStorage_Commit(stg2, 0);
1873
1874         /* create and revert stmname2 */
1875         r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1876         ok(r==S_OK, "IStorage->CreateStream failed\n");
1877         if (r == S_OK)
1878             IStream_Release(stm);
1879
1880         IStorage_Revert(stg2);
1881
1882         /* check that Commit and Revert really worked */
1883         r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1884         ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1885         if (r == S_OK)
1886             IStream_Release(stm);
1887
1888         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1889         ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1890         if (r == S_OK)
1891             IStream_Release(stm);
1892
1893         IStorage_Release(stg2);
1894     }
1895
1896     /* create a read-only transacted substorage */
1897     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, NULL, 0, &stg2);
1898     ok(r==S_OK, "IStorage->OpenStorage failed, hr=%08x\n", r);
1899
1900     if (r == S_OK)
1901     {
1902         /* The storage can be modified. */
1903         r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1904         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1905         if (r == S_OK)
1906             IStorage_Release(stg3);
1907
1908         /* But changes cannot be committed. */
1909         r = IStorage_Commit(stg2, 0);
1910         ok(r==STG_E_ACCESSDENIED, "IStorage->Commit should fail, hr=%08x\n", r);
1911
1912         IStorage_Release(stg2);
1913     }
1914
1915     IStorage_Release(stg);
1916
1917     /* create a non-transacted file */
1918     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1919                             STGM_READWRITE, 0, &stg);
1920     ok(r==S_OK, "StgCreateDocfile failed\n");
1921
1922     /* create a transacted substorage */
1923     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1924     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1925
1926     if (r == S_OK)
1927     {
1928         /* create and commit stmname */
1929         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1930         ok(r==S_OK, "IStorage->CreateStream failed\n");
1931         if (r == S_OK)
1932             IStream_Release(stm);
1933
1934         IStorage_Commit(stg2, 0);
1935
1936         /* create and revert stmname2 */
1937         r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1938         ok(r==S_OK, "IStorage->CreateStream failed\n");
1939         if (r == S_OK)
1940             IStream_Release(stm);
1941
1942         IStorage_Revert(stg2);
1943
1944         /* check that Commit and Revert really worked */
1945         r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1946         ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1947         if (r == S_OK)
1948             IStream_Release(stm);
1949
1950         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1951         ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1952         if (r == S_OK)
1953             IStream_Release(stm);
1954
1955         IStorage_Release(stg2);
1956     }
1957
1958     IStorage_Release(stg);
1959
1960     ret = DeleteFileA(filenameA);
1961     ok(ret, "deleted file\n");
1962 }
1963
1964 static void test_ReadClassStm(void)
1965 {
1966     CLSID clsid, clsid2;
1967     HRESULT hr;
1968     IStream *pStream;
1969     static const LARGE_INTEGER llZero;
1970
1971     hr = ReadClassStm(NULL, &clsid);
1972     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1973
1974     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1975     ok_ole_success(hr, "CreateStreamOnHGlobal");
1976     hr = WriteClassStm(pStream, &test_stg_cls);
1977     ok_ole_success(hr, "WriteClassStm");
1978
1979     hr = ReadClassStm(pStream, NULL);
1980     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1981
1982     memset(&clsid, 0xcc, sizeof(clsid));
1983     memset(&clsid2, 0xcc, sizeof(clsid2));
1984     hr = ReadClassStm(NULL, &clsid);
1985     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
1986     ok(IsEqualCLSID(&clsid, &clsid2), "got wrong clsid\n");
1987
1988     /* test not rewound stream */
1989     hr = ReadClassStm(pStream, &clsid);
1990     ok(hr == STG_E_READFAULT, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
1991     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid should have been zeroed\n");
1992
1993     hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
1994     ok_ole_success(hr, "IStream_Seek");
1995     hr = ReadClassStm(pStream, &clsid);
1996     ok_ole_success(hr, "ReadClassStm");
1997     ok(IsEqualCLSID(&clsid, &test_stg_cls), "clsid should have been set to CLSID_WineTest\n");
1998
1999     IStream_Release(pStream);
2000 }
2001
2002 struct access_res
2003 {
2004     BOOL gothandle;
2005     DWORD lasterr;
2006     BOOL ignore;
2007 };
2008
2009 static const struct access_res create[16] =
2010 {
2011     { TRUE, ERROR_SUCCESS, TRUE },
2012     { TRUE, ERROR_SUCCESS, TRUE },
2013     { TRUE, ERROR_SUCCESS, FALSE },
2014     { TRUE, ERROR_SUCCESS, FALSE },
2015     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2016     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2017     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2018     { TRUE, ERROR_SUCCESS, FALSE },
2019     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2020     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2021     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2022     { TRUE, ERROR_SUCCESS, TRUE },
2023     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2024     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2025     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2026     { TRUE, ERROR_SUCCESS, TRUE }
2027 };
2028
2029 static const struct access_res create_commit[16] =
2030 {
2031     { TRUE, ERROR_SUCCESS, TRUE },
2032     { TRUE, ERROR_SUCCESS, TRUE },
2033     { TRUE, ERROR_SUCCESS, FALSE },
2034     { TRUE, ERROR_SUCCESS, FALSE },
2035     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2036     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2037     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2038     { TRUE, ERROR_SUCCESS, FALSE },
2039     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2040     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2041     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2042     { TRUE, ERROR_SUCCESS, TRUE },
2043     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2044     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2045     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
2046     { TRUE, ERROR_SUCCESS, TRUE }
2047 };
2048
2049 static const struct access_res create_close[16] =
2050 {
2051     { TRUE, ERROR_SUCCESS, FALSE },
2052     { TRUE, ERROR_SUCCESS, FALSE },
2053     { TRUE, ERROR_SUCCESS, FALSE },
2054     { TRUE, ERROR_SUCCESS, FALSE },
2055     { TRUE, ERROR_SUCCESS, FALSE },
2056     { TRUE, ERROR_SUCCESS, FALSE },
2057     { TRUE, ERROR_SUCCESS, FALSE },
2058     { TRUE, ERROR_SUCCESS, FALSE },
2059     { TRUE, ERROR_SUCCESS, FALSE },
2060     { TRUE, ERROR_SUCCESS, FALSE },
2061     { TRUE, ERROR_SUCCESS, FALSE },
2062     { TRUE, ERROR_SUCCESS, FALSE },
2063     { TRUE, ERROR_SUCCESS, FALSE },
2064     { TRUE, ERROR_SUCCESS, FALSE },
2065     { TRUE, ERROR_SUCCESS, FALSE },
2066     { TRUE, ERROR_SUCCESS }
2067 };
2068
2069 static const DWORD access_modes[4] = {
2070     0,
2071     GENERIC_READ,
2072     GENERIC_WRITE,
2073     GENERIC_READ | GENERIC_WRITE
2074 };
2075
2076 static const DWORD share_modes[4] = {
2077     0,
2078     FILE_SHARE_READ,
2079     FILE_SHARE_WRITE,
2080     FILE_SHARE_READ | FILE_SHARE_WRITE
2081 };
2082
2083 static void _test_file_access(LPCSTR file, const struct access_res *ares, DWORD line)
2084 {
2085     int i, j, idx = 0;
2086
2087     for (i = 0; i < ARRAY_SIZE(access_modes); i++)
2088     {
2089         for (j = 0; j < ARRAY_SIZE(share_modes); j++)
2090         {
2091             DWORD lasterr;
2092             HANDLE hfile;
2093
2094             if (ares[idx].ignore)
2095                 continue;
2096
2097             SetLastError(0xdeadbeef);
2098             hfile = CreateFileA(file, access_modes[i], share_modes[j], NULL, OPEN_EXISTING,
2099                                 FILE_ATTRIBUTE_NORMAL, 0);
2100             lasterr = GetLastError();
2101
2102             ok((hfile != INVALID_HANDLE_VALUE) == ares[idx].gothandle,
2103                "(%d, handle, %d): Expected %d, got %d\n",
2104                line, idx, ares[idx].gothandle,
2105                (hfile != INVALID_HANDLE_VALUE));
2106
2107             ok(lasterr == ares[idx].lasterr ||
2108                broken(lasterr == 0xdeadbeef) /* win9x */,
2109                "(%d, lasterr, %d): Expected %d, got %d\n",
2110                line, idx, ares[idx].lasterr, lasterr);
2111
2112             CloseHandle(hfile);
2113             idx++;
2114         }
2115     }
2116 }
2117
2118 #define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
2119
2120 static void test_access(void)
2121 {
2122     static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
2123     static const char fileA[] = "winetest";
2124     IStorage *stg;
2125     HRESULT hr;
2126
2127     /* STGM_TRANSACTED */
2128     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
2129                           STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, &stg);
2130     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2131
2132     test_file_access(fileA, create);
2133
2134     hr = IStorage_Commit(stg, STGC_DEFAULT);
2135     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2136
2137     test_file_access(fileA, create_commit);
2138
2139     IStorage_Release(stg);
2140
2141     test_file_access(fileA, create_close);
2142
2143     DeleteFileA(fileA);
2144
2145     /* STGM_DIRECT */
2146     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
2147                           STGM_SHARE_EXCLUSIVE | STGM_DIRECT, 0, &stg);
2148     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2149
2150     test_file_access(fileA, create);
2151
2152     hr = IStorage_Commit(stg, STGC_DEFAULT);
2153     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2154
2155     test_file_access(fileA, create_commit);
2156
2157     IStorage_Release(stg);
2158
2159     test_file_access(fileA, create_close);
2160
2161     DeleteFileA(fileA);
2162
2163     /* STGM_SHARE_DENY_NONE */
2164     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
2165                           STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
2166     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2167
2168     test_file_access(fileA, create);
2169
2170     hr = IStorage_Commit(stg, STGC_DEFAULT);
2171     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2172
2173     test_file_access(fileA, create_commit);
2174
2175     IStorage_Release(stg);
2176
2177     test_file_access(fileA, create_close);
2178
2179     DeleteFileA(fileA);
2180
2181     /* STGM_SHARE_DENY_READ */
2182     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
2183                           STGM_SHARE_DENY_READ | STGM_TRANSACTED, 0, &stg);
2184     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2185
2186     test_file_access(fileA, create);
2187
2188     hr = IStorage_Commit(stg, STGC_DEFAULT);
2189     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2190
2191     test_file_access(fileA, create_commit);
2192
2193     IStorage_Release(stg);
2194
2195     test_file_access(fileA, create_close);
2196
2197     DeleteFileA(fileA);
2198
2199     /* STGM_SHARE_DENY_WRITE */
2200     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
2201                           STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
2202     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2203
2204     test_file_access(fileA, create);
2205
2206     hr = IStorage_Commit(stg, STGC_DEFAULT);
2207     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
2208
2209     test_file_access(fileA, create_commit);
2210
2211     IStorage_Release(stg);
2212
2213     test_file_access(fileA, create_close);
2214
2215     DeleteFileA(fileA);
2216
2217     /* STGM_DIRECT_SWMR | STGM_READ | STGM_SHARE_DENY_NONE - reader mode for direct SWMR mode */
2218     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE | STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
2219     ok(hr == S_OK, "got %08x\n", hr);
2220     IStorage_Release(stg);
2221
2222     hr = StgOpenStorage(fileW, NULL, STGM_DIRECT_SWMR | STGM_READ | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
2223     ok(hr == S_OK || broken(hr == STG_E_INVALIDFLAG), "got %08x\n", hr);
2224     if(hr != S_OK)
2225        return;
2226
2227     test_file_access(fileA, create);
2228
2229     IStorage_Release(stg);
2230     test_file_access(fileA, create_close);
2231
2232     DeleteFileA(fileA);
2233 }
2234
2235 static void test_readonly(void)
2236 {
2237     IStorage *stg, *stg2, *stg3;
2238     IStream *stream;
2239     HRESULT hr;
2240     static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
2241     static const WCHAR storageW[] = {'s','t','o','r','a','g','e',0};
2242     static const WCHAR streamW[] = {'s','t','r','e','a','m',0};
2243
2244     hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
2245     ok(hr == S_OK, "should succeed, res=%x\n", hr);
2246     if (SUCCEEDED(hr))
2247     {
2248         hr = IStorage_CreateStorage( stg, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2 );
2249         ok(hr == S_OK, "should succeed, res=%x\n", hr);
2250         if (SUCCEEDED(hr))
2251         {
2252             hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stream );
2253             ok(hr == S_OK, "should succeed, res=%x\n", hr);
2254             if (SUCCEEDED(hr))
2255                 IStream_Release(stream);
2256             IStorage_Release(stg2);
2257         }
2258         IStorage_Release(stg);
2259     }
2260
2261     /* re-open read only */
2262     hr = StgOpenStorage( fileW, NULL, STGM_TRANSACTED | STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
2263     ok(hr == S_OK, "should succeed, res=%x\n", hr);
2264     if (SUCCEEDED(hr))
2265     {
2266         hr = IStorage_OpenStorage( stg, storageW, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2 );
2267         ok(hr == S_OK, "should succeed, res=%x\n", hr);
2268         if (SUCCEEDED(hr))
2269         {
2270             /* CreateStream on read-only storage, name exists */
2271             hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
2272             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
2273             if (SUCCEEDED(hr))
2274                 IStream_Release(stream);
2275
2276             /* CreateStream on read-only storage, name does not exist */
2277             hr = IStorage_CreateStream( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
2278             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
2279             if (SUCCEEDED(hr))
2280                 IStream_Release(stream);
2281
2282             /* CreateStorage on read-only storage, name exists */
2283             hr = IStorage_CreateStorage( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
2284             ok(hr == STG_E_FILEALREADYEXISTS, "should fail, res=%x\n", hr);
2285             if (SUCCEEDED(hr))
2286                 IStorage_Release(stg3);
2287
2288             /* CreateStorage on read-only storage, name does not exist */
2289             hr = IStorage_CreateStorage( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
2290             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
2291             if (SUCCEEDED(hr))
2292                 IStorage_Release(stg3);
2293
2294             /* DestroyElement on read-only storage, name exists */
2295             hr = IStorage_DestroyElement( stg2, streamW );
2296             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
2297
2298             /* DestroyElement on read-only storage, name does not exist */
2299             hr = IStorage_DestroyElement( stg2, storageW );
2300             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
2301
2302             IStorage_Release(stg2);
2303         }
2304
2305         IStorage_Release(stg);
2306     }
2307
2308     DeleteFileA("winetest");
2309 }
2310
2311 static void test_simple(void)
2312 {
2313     /* Tests for STGM_SIMPLE mode */
2314
2315     IStorage *stg, *stg2;
2316     HRESULT r;
2317     IStream *stm;
2318     static const WCHAR stgname[] = { 'S','t','g',0 };
2319     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
2320     static const WCHAR stmname2[] = { 'S','m','a','l','l',0 };
2321     LARGE_INTEGER pos;
2322     ULARGE_INTEGER upos;
2323     DWORD count;
2324     STATSTG stat;
2325
2326     DeleteFileA(filenameA);
2327
2328     r = StgCreateDocfile( filename, STGM_SIMPLE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
2329     ok(r == S_OK, "got %08x\n", r);
2330
2331     r = IStorage_CreateStorage(stg, stgname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2);
2332     ok(r == STG_E_INVALIDFUNCTION, "got %08x\n", r);
2333     if (SUCCEEDED(r)) IStorage_Release(stg2);
2334
2335     r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
2336     ok(r == STG_E_INVALIDFLAG, "got %08x\n", r);
2337     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
2338     ok(r == S_OK, "got %08x\n", r);
2339
2340     upos.QuadPart = 6000;
2341     r = IStream_SetSize(stm, upos);
2342     ok(r == S_OK, "got %08x\n", r);
2343
2344     r = IStream_Write(stm, "foo", 3, &count);
2345     ok(r == S_OK, "got %08x\n", r);
2346     ok(count == 3, "got %d\n", count);
2347
2348     pos.QuadPart = 0;
2349     r = IStream_Seek(stm, pos, STREAM_SEEK_CUR, &upos);
2350     ok(r == S_OK, "got %08x\n", r);
2351     ok(upos.QuadPart == 3, "got %d\n", upos.u.LowPart);
2352
2353     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
2354     ok(r == S_OK ||
2355        broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
2356        "got %08x\n", r);
2357     if (r == S_OK)
2358         ok(stat.cbSize.QuadPart == 3, "got %d\n", stat.cbSize.u.LowPart);
2359
2360     pos.QuadPart = 1;
2361     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
2362     ok(r == S_OK, "got %08x\n", r);
2363     ok(upos.QuadPart == 1, "got %d\n", upos.u.LowPart);
2364
2365     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
2366     ok(r == S_OK ||
2367        broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
2368        "got %08x\n", r);
2369     if (r == S_OK)
2370         ok(stat.cbSize.QuadPart == 1, "got %d\n", stat.cbSize.u.LowPart);
2371
2372     IStream_Release(stm);
2373
2374     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
2375     ok(r == S_OK, "got %08x\n", r);
2376
2377     upos.QuadPart = 100;
2378     r = IStream_SetSize(stm, upos);
2379     ok(r == S_OK, "got %08x\n", r);
2380
2381     r = IStream_Write(stm, "foo", 3, &count);
2382     ok(r == S_OK, "got %08x\n", r);
2383     ok(count == 3, "got %d\n", count);
2384
2385     IStream_Release(stm);
2386
2387     IStorage_Commit(stg, STGC_DEFAULT);
2388     IStorage_Release(stg);
2389
2390     r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
2391     if (r == STG_E_INVALIDFLAG)
2392     {
2393         win_skip("Flag combination is not supported on NT4 and below\n");
2394         DeleteFileA(filenameA);
2395         return;
2396     }
2397     ok(r == S_OK, "got %08x\n", r);
2398
2399     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg2);
2400     ok(r == STG_E_INVALIDFUNCTION, "got %08x\n", r);
2401     if (SUCCEEDED(r)) IStorage_Release(stg2);
2402
2403     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
2404     ok(r == S_OK, "got %08x\n", r);
2405
2406     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
2407     ok(r == S_OK, "got %08x\n", r);
2408     ok(stat.cbSize.QuadPart == 6000, "got %d\n", stat.cbSize.u.LowPart);
2409
2410     IStream_Release(stm);
2411
2412     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
2413     ok(r == S_OK, "got %08x\n", r);
2414
2415     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
2416     ok(r == S_OK, "got %08x\n", r);
2417     ok(stat.cbSize.QuadPart == 4096, "got %d\n", stat.cbSize.u.LowPart);
2418
2419     IStream_Release(stm);
2420
2421
2422     IStorage_Release(stg);
2423
2424     DeleteFileA(filenameA);
2425 }
2426
2427 static void test_fmtusertypestg(void)
2428 {
2429     IStorage *stg;
2430     IEnumSTATSTG *stat;
2431     HRESULT hr;
2432     static const char fileA[]  = {'f','m','t','t','e','s','t',0};
2433     static const WCHAR fileW[] = {'f','m','t','t','e','s','t',0};
2434     static WCHAR userTypeW[] = {'S','t','g','U','s','r','T','y','p','e',0};
2435     static const WCHAR strmNameW[] = {1,'C','o','m','p','O','b','j',0};
2436     static const STATSTG statstg_null;
2437
2438     hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
2439     ok(hr == S_OK, "should succeed, res=%x\n", hr);
2440
2441     if (SUCCEEDED(hr))
2442     {
2443         /* try to write the stream */
2444         hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
2445         ok(hr == S_OK, "should succeed, res=%x\n", hr);
2446
2447         /* check that the stream was created */
2448         hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
2449         ok(hr == S_OK, "should succeed, res=%x\n", hr);
2450         if (SUCCEEDED(hr))
2451         {
2452             BOOL found = FALSE;
2453             STATSTG statstg;
2454             DWORD got;
2455             memset(&statstg, 0xad, sizeof(statstg));
2456             while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
2457             {
2458                 if (strcmp_ww(statstg.pwcsName, strmNameW) == 0)
2459                     found = TRUE;
2460                 else
2461                     ok(0, "found unexpected stream or storage\n");
2462                 CoTaskMemFree(statstg.pwcsName);
2463             }
2464             ok(memcmp(&statstg, &statstg_null, sizeof(statstg)) == 0, "statstg is not zeroed\n");
2465             ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
2466             IEnumSTATSTG_Release(stat);
2467         }
2468
2469         /* re-write the stream */
2470         hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
2471         ok(hr == S_OK, "should succeed, res=%x\n", hr);
2472
2473         /* check that the stream is still there */
2474         hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
2475         ok(hr == S_OK, "should succeed, res=%x\n", hr);
2476         if (SUCCEEDED(hr))
2477         {
2478             BOOL found = FALSE;
2479             STATSTG statstg;
2480             DWORD got;
2481             memset(&statstg, 0xad, sizeof(statstg));
2482             while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
2483             {
2484                 if (strcmp_ww(statstg.pwcsName, strmNameW) == 0)
2485                     found = TRUE;
2486                 else
2487                     ok(0, "found unexpected stream or storage\n");
2488                 CoTaskMemFree(statstg.pwcsName);
2489             }
2490             ok(memcmp(&statstg, &statstg_null, sizeof(statstg)) == 0, "statstg is not zeroed\n");
2491             ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
2492             IEnumSTATSTG_Release(stat);
2493         }
2494
2495         IStorage_Release(stg);
2496         DeleteFileA( fileA );
2497     }
2498 }
2499
2500 static void test_references(void)
2501 {
2502     IStorage *stg,*stg2;
2503     HRESULT hr;
2504     unsigned c1,c2;
2505     static const WCHAR StorName[] = { 'D','a','t','a','S','p','a','c','e','I','n','f','o',0 };
2506
2507     DeleteFileA(filenameA);
2508
2509     hr = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
2510     ok(hr==S_OK, "StgCreateDocfile failed\n");
2511
2512     if (SUCCEEDED(hr))
2513     {
2514         IStorage_Release(stg);
2515
2516         hr = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
2517         ok(hr==S_OK, "StgOpenStorage failed (result=%x)\n",hr);
2518
2519         if (SUCCEEDED(hr))
2520         {
2521             hr = IStorage_CreateStorage(stg,StorName,STGM_READWRITE | STGM_SHARE_EXCLUSIVE,0,0,&stg2);
2522             ok(hr == S_OK, "IStorage_CreateStorage failed (result=%x)\n",hr);
2523
2524             if (SUCCEEDED(hr))
2525             {
2526                 c1 = IStorage_AddRef(stg);
2527                 ok(c1 == 2, "creating internal storage added references to ancestor\n");
2528                 c1 = IStorage_AddRef(stg);
2529                 IStorage_Release(stg2);
2530                 c2 = IStorage_AddRef(stg) - 1;
2531                 ok(c1 == c2, "releasing internal storage removed references to ancestor\n");
2532             }
2533             c1 = IStorage_Release(stg);
2534             while ( c1 ) c1 = IStorage_Release(stg);
2535         }
2536     }
2537
2538     DeleteFileA(filenameA);
2539 }
2540
2541 /* dest
2542  *  |-StorageA
2543  *  |  `StreamA: "StreamA"
2544  *  |-StorageB
2545  *  |  `StreamB: "StreamB"
2546  *  `StreamC: "StreamC"
2547  */
2548 static HRESULT create_test_file(IStorage *dest)
2549 {
2550     IStorage *stgA = NULL, *stgB = NULL;
2551     IStream *strmA = NULL, *strmB = NULL, *strmC = NULL;
2552     const ULONG strmA_name_size = lstrlenW(strmA_name) * sizeof(WCHAR);
2553     const ULONG strmB_name_size = lstrlenW(strmB_name) * sizeof(WCHAR);
2554     const ULONG strmC_name_size = lstrlenW(strmC_name) * sizeof(WCHAR);
2555     ULONG bytes;
2556     HRESULT hr;
2557
2558     hr = IStorage_CreateStorage(dest, stgA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgA);
2559     ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
2560     if(FAILED(hr))
2561         goto cleanup;
2562
2563     hr = IStorage_CreateStream(stgA, strmA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmA);
2564     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2565     if(FAILED(hr))
2566         goto cleanup;
2567
2568     hr = IStream_Write(strmA, strmA_name, strmA_name_size, &bytes);
2569     ok(hr == S_OK && bytes == strmA_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmA_name_size);
2570
2571     hr = IStorage_CreateStorage(dest, stgB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgB);
2572     ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
2573     if(FAILED(hr))
2574         goto cleanup;
2575
2576     hr = IStorage_CreateStream(stgB, strmB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmB);
2577     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2578     if(FAILED(hr))
2579         goto cleanup;
2580
2581     hr = IStream_Write(strmB, strmB_name, strmB_name_size, &bytes);
2582     ok(hr == S_OK && bytes == strmB_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmB_name_size);
2583
2584     hr = IStorage_CreateStream(dest, strmC_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmC);
2585     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2586     if(FAILED(hr))
2587         goto cleanup;
2588
2589     hr = IStream_Write(strmC, strmC_name, strmC_name_size, &bytes);
2590     ok(hr == S_OK && bytes == strmC_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmC_name_size);
2591
2592 cleanup:
2593     if(strmC)
2594         IStream_Release(strmC);
2595     if(strmB)
2596         IStream_Release(strmB);
2597     if(stgB)
2598         IStorage_Release(stgB);
2599     if(strmA)
2600         IStream_Release(strmA);
2601     if(stgA)
2602         IStorage_Release(stgA);
2603
2604     return hr;
2605 }
2606
2607 static void test_copyto(void)
2608 {
2609     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2610     IStream *strm_tmp;
2611     WCHAR buf[64];
2612     HRESULT hr;
2613
2614     /* create & populate file1 */
2615     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2616     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2617     if(FAILED(hr))
2618         goto cleanup;
2619
2620     hr = create_test_file(file1);
2621     if(FAILED(hr))
2622         goto cleanup;
2623
2624     /* create file2 */
2625     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2626     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2627     if(FAILED(hr))
2628         goto cleanup;
2629
2630     /* copy file1 into file2 */
2631     hr = IStorage_CopyTo(file1, 0, NULL, NULL, NULL);
2632     ok(hr == STG_E_INVALIDPOINTER, "CopyTo should give STG_E_INVALIDPONITER, gave: 0x%08x\n", hr);
2633
2634     hr = IStorage_CopyTo(file1, 0, NULL, NULL, file2);
2635     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2636     if(FAILED(hr))
2637         goto cleanup;
2638
2639     /* verify that all of file1 was copied */
2640     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2641             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2642     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2643
2644     if(SUCCEEDED(hr)){
2645         hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2646                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2647         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2648
2649         if(SUCCEEDED(hr)){
2650             memset(buf, 0, sizeof(buf));
2651             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2652             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2653             if(SUCCEEDED(hr))
2654                 ok(strcmp_ww(buf, strmA_name) == 0,
2655                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmA_name), wine_dbgstr_w(buf));
2656
2657             IStream_Release(strm_tmp);
2658         }
2659
2660         IStorage_Release(stg_tmp);
2661     }
2662
2663     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2664             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2665     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2666
2667     if(SUCCEEDED(hr)){
2668         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2669                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2670         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2671
2672         if(SUCCEEDED(hr)){
2673             memset(buf, 0, sizeof(buf));
2674             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2675             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2676             if(SUCCEEDED(hr))
2677                 ok(strcmp_ww(buf, strmB_name) == 0,
2678                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2679
2680             IStream_Release(strm_tmp);
2681         }
2682
2683         IStorage_Release(stg_tmp);
2684     }
2685
2686     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2687             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2688     ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2689
2690     if(SUCCEEDED(hr)){
2691         memset(buf, 0, sizeof(buf));
2692         hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2693         ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2694         if(SUCCEEDED(hr))
2695             ok(strcmp_ww(buf, strmC_name) == 0,
2696                     "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2697
2698         IStream_Release(strm_tmp);
2699     }
2700
2701 cleanup:
2702     if(file1)
2703         IStorage_Release(file1);
2704     if(file2)
2705         IStorage_Release(file2);
2706
2707     DeleteFileA(file1_nameA);
2708     DeleteFileA(file2_nameA);
2709 }
2710
2711 static void test_copyto_snbexclusions(void)
2712 {
2713     static const WCHAR *snb_exclude[] = {stgA_name, strmB_name, strmC_name, 0};
2714
2715     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2716     IStream *strm_tmp;
2717     WCHAR buf[64];
2718     HRESULT hr;
2719
2720     /* create & populate file1 */
2721     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2722     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2723     if(FAILED(hr))
2724         goto cleanup;
2725
2726     hr = create_test_file(file1);
2727     if(FAILED(hr))
2728         goto cleanup;
2729
2730     /* create file2 */
2731     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2732     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2733     if(FAILED(hr))
2734         goto cleanup;
2735
2736     /* copy file1 to file2 with name exclusions */
2737     hr = IStorage_CopyTo(file1, 0, NULL, (SNB)snb_exclude, file2);
2738     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2739     if(FAILED(hr))
2740         goto cleanup;
2741
2742     /* verify that file1 copied over, respecting exclusions */
2743     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2744             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2745     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2746     if(SUCCEEDED(hr))
2747         IStorage_Release(stg_tmp);
2748
2749     hr = IStorage_OpenStream(file2, strmA_name, NULL,
2750             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2751     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2752     if(SUCCEEDED(hr))
2753         IStream_Release(strm_tmp);
2754
2755     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2756             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2757     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2758
2759     if(SUCCEEDED(hr)){
2760         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2761                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2762         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2763
2764         if(SUCCEEDED(hr)){
2765             memset(buf, 0, sizeof(buf));
2766             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2767             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2768             if(SUCCEEDED(hr))
2769                 ok(strcmp_ww(buf, strmB_name) == 0,
2770                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2771
2772             IStream_Release(strm_tmp);
2773         }
2774
2775         IStorage_Release(stg_tmp);
2776     }
2777
2778     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2779             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2780     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2781     if(SUCCEEDED(hr))
2782         IStream_Release(strm_tmp);
2783
2784 cleanup:
2785     if(file1)
2786         IStorage_Release(file1);
2787     if(file2)
2788         IStorage_Release(file2);
2789
2790     DeleteFileA(file1_nameA);
2791     DeleteFileA(file2_nameA);
2792 }
2793
2794 static void test_copyto_iidexclusions_storage(void)
2795 {
2796     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2797     IStream *strm_tmp;
2798     WCHAR buf[64];
2799     HRESULT hr;
2800
2801     /* create & populate file1 */
2802     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2803     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2804     if(FAILED(hr))
2805         goto cleanup;
2806
2807     hr = create_test_file(file1);
2808     if(FAILED(hr))
2809         goto cleanup;
2810
2811     /* create file2 */
2812     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2813     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2814     if(FAILED(hr))
2815         goto cleanup;
2816
2817     /* copy file1 to file2 with iid exclusions */
2818     hr = IStorage_CopyTo(file1, 1, &IID_IStorage, NULL, file2);
2819     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2820     if(FAILED(hr))
2821         goto cleanup;
2822
2823     /* verify that file1 copied over, respecting exclusions */
2824     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2825             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2826     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2827     if(SUCCEEDED(hr))
2828         IStorage_Release(stg_tmp);
2829
2830     hr = IStorage_OpenStream(file2, strmA_name, NULL,
2831             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2832     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2833     if(SUCCEEDED(hr))
2834         IStream_Release(strm_tmp);
2835
2836     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2837             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2838     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2839     if(SUCCEEDED(hr))
2840         IStorage_Release(stg_tmp);
2841
2842     hr = IStorage_OpenStream(file2, strmB_name, NULL,
2843             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2844     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2845     if(SUCCEEDED(hr))
2846         IStream_Release(strm_tmp);
2847
2848     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2849             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2850     ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2851
2852     if(SUCCEEDED(hr)){
2853         memset(buf, 0, sizeof(buf));
2854         hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2855         ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2856         if(SUCCEEDED(hr))
2857             ok(strcmp_ww(buf, strmC_name) == 0,
2858                     "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2859
2860         IStream_Release(strm_tmp);
2861     }
2862
2863 cleanup:
2864     if(file1)
2865         IStorage_Release(file1);
2866     if(file2)
2867         IStorage_Release(file2);
2868
2869     DeleteFileA(file1_nameA);
2870     DeleteFileA(file2_nameA);
2871 }
2872
2873 static void test_copyto_iidexclusions_stream(void)
2874 {
2875     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2876     IStream *strm_tmp;
2877     HRESULT hr;
2878
2879     /* create & populate file1 */
2880     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2881     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2882     if(FAILED(hr))
2883         goto cleanup;
2884
2885     hr = create_test_file(file1);
2886     if(FAILED(hr))
2887         goto cleanup;
2888
2889     /* create file2 */
2890     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2891     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2892     if(FAILED(hr))
2893         goto cleanup;
2894
2895     /* copy file1 to file2 with iid exclusions */
2896     hr = IStorage_CopyTo(file1, 1, &IID_IStream, NULL, file2);
2897     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2898     if(FAILED(hr))
2899         goto cleanup;
2900
2901     /* verify that file1 copied over, respecting exclusions */
2902     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2903             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2904     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2905
2906     if(SUCCEEDED(hr)){
2907         hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2908                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2909         ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2910         if(SUCCEEDED(hr))
2911             IStream_Release(strm_tmp);
2912
2913         IStorage_Release(stg_tmp);
2914     }
2915
2916     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2917             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2918     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2919
2920     if(SUCCEEDED(hr)){
2921         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2922                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2923         ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2924         if(SUCCEEDED(hr))
2925             IStream_Release(strm_tmp);
2926
2927         IStorage_Release(stg_tmp);
2928     }
2929
2930     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2931             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2932     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2933     if(SUCCEEDED(hr))
2934         IStream_Release(strm_tmp);
2935
2936 cleanup:
2937     if(file1)
2938         IStorage_Release(file1);
2939     if(file2)
2940         IStorage_Release(file2);
2941
2942     DeleteFileA(file1_nameA);
2943     DeleteFileA(file2_nameA);
2944 }
2945
2946 static void test_rename(void)
2947 {
2948     IStorage *stg, *stg2;
2949     IStream *stm;
2950     HRESULT r;
2951     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
2952     static const WCHAR stgname2[] = { 'S','T','G',0 };
2953     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
2954     static const WCHAR stmname2[] = { 'E','N','T','S',0 };
2955     BOOL ret;
2956
2957     DeleteFileA(filenameA);
2958
2959     /* create the file */
2960     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
2961                             STGM_READWRITE, 0, &stg);
2962     ok(r==S_OK, "StgCreateDocfile failed\n");
2963
2964     /* create a substorage */
2965     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
2966     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
2967
2968     /* create a stream in the substorage */
2969     r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
2970     ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
2971     IStream_Release(stm);
2972
2973     /* rename the stream */
2974     r = IStorage_RenameElement(stg2, stmname, stmname2);
2975     ok(r==S_OK, "IStorage->RenameElement failed, hr=%08x\n", r);
2976
2977     /* cannot open stream with old name */
2978     r = IStorage_OpenStream(stg2, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2979     ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2980     if (SUCCEEDED(r)) IStream_Release(stm);
2981
2982     /* can open stream with new name */
2983     r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2984     ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
2985     if (SUCCEEDED(r)) IStream_Release(stm);
2986
2987     IStorage_Release(stg2);
2988
2989     /* rename the storage */
2990     IStorage_RenameElement(stg, stgname, stgname2);
2991
2992     /* cannot open storage with old name */
2993     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2994     ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2995     if (SUCCEEDED(r)) IStorage_Release(stg2);
2996
2997     /* can open storage with new name */
2998     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2999     ok(r==S_OK, "IStorage_OpenStream should fail, hr=%08x\n", r);
3000     if (SUCCEEDED(r))
3001     {
3002         /* opened storage still has the stream */
3003         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
3004         ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
3005         if (SUCCEEDED(r)) IStream_Release(stm);
3006
3007         IStorage_Release(stg2);
3008     }
3009
3010     IStorage_Release(stg);
3011
3012     ret = DeleteFileA(filenameA);
3013     ok(ret, "deleted file\n");
3014 }
3015
3016 static void test_toplevel_stat(void)
3017 {
3018     IStorage *stg = NULL;
3019     HRESULT r;
3020     STATSTG stat;
3021     char prev_dir[MAX_PATH];
3022     char temp[MAX_PATH];
3023     char full_path[MAX_PATH];
3024     LPSTR rel_pathA;
3025     WCHAR rel_path[MAX_PATH];
3026
3027     DeleteFileA(filenameA);
3028
3029     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
3030                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
3031     ok(r==S_OK, "StgCreateDocfile failed\n");
3032
3033     r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
3034     ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
3035     ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
3036         wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
3037     CoTaskMemFree(stat.pwcsName);
3038
3039     IStorage_Release( stg );
3040
3041     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
3042     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
3043
3044     r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
3045     ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
3046     ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
3047         wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
3048     CoTaskMemFree(stat.pwcsName);
3049
3050     IStorage_Release( stg );
3051
3052     DeleteFileA(filenameA);
3053
3054     /* Stat always returns the full path, even for files opened with a relative path. */
3055     GetCurrentDirectoryA(MAX_PATH, prev_dir);
3056
3057     GetTempPathA(MAX_PATH, temp);
3058
3059     SetCurrentDirectoryA(temp);
3060
3061     GetFullPathNameA(filenameA, MAX_PATH, full_path, &rel_pathA);
3062     MultiByteToWideChar(CP_ACP, 0, rel_pathA, -1, rel_path, MAX_PATH);
3063
3064     r = StgCreateDocfile( rel_path, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
3065                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
3066     ok(r==S_OK, "StgCreateDocfile failed\n");
3067
3068     r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
3069     ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
3070     ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
3071         wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
3072     CoTaskMemFree(stat.pwcsName);
3073
3074     IStorage_Release( stg );
3075
3076     r = StgOpenStorage( rel_path, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
3077     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
3078
3079     r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
3080     ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
3081     ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
3082         wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
3083     CoTaskMemFree(stat.pwcsName);
3084
3085     IStorage_Release( stg );
3086
3087     SetCurrentDirectoryA(prev_dir);
3088
3089     DeleteFileA(filenameA);
3090 }
3091
3092 static void test_substorage_enum(void)
3093 {
3094     IStorage *stg, *stg2;
3095     IEnumSTATSTG *ee;
3096     HRESULT r;
3097     ULONG ref;
3098     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
3099     BOOL ret;
3100
3101     DeleteFileA(filenameA);
3102
3103     /* create the file */
3104     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
3105                             STGM_READWRITE, 0, &stg);
3106     ok(r==S_OK, "StgCreateDocfile failed\n");
3107
3108     /* create a substorage */
3109     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
3110     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3111
3112     /* create an enumelements */
3113     r = IStorage_EnumElements(stg2, 0, NULL, 0, &ee);
3114     ok(r==S_OK, "IStorage->EnumElements failed, hr=%08x\n", r);
3115
3116     /* release the substorage */
3117     ref = IStorage_Release(stg2);
3118     todo_wine ok(ref==0, "storage not released\n");
3119
3120     /* reopening fails, because the substorage is really still open */
3121     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
3122     ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage failed, hr=%08x\n", r);
3123
3124     /* destroying the storage invalidates the enumerator */
3125     r = IStorage_DestroyElement(stg, stgname);
3126     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3127
3128     r = IEnumSTATSTG_Reset(ee);
3129     ok(r==STG_E_REVERTED, "IEnumSTATSTG->Reset failed, hr=%08x\n", r);
3130
3131     IEnumSTATSTG_Release(ee);
3132
3133     IStorage_Release(stg);
3134
3135     ret = DeleteFileA(filenameA);
3136     ok(ret, "deleted file\n");
3137 }
3138
3139 static void test_copyto_locking(void)
3140 {
3141     IStorage *stg, *stg2, *stg3, *stg4;
3142     IStream *stm;
3143     HRESULT r;
3144     static const WCHAR stgname[] = { 'S','T','G','1',0 };
3145     static const WCHAR stgname2[] = { 'S','T','G','2',0 };
3146     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
3147     BOOL ret;
3148
3149     DeleteFileA(filenameA);
3150
3151     /* create the file */
3152     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
3153                             STGM_READWRITE, 0, &stg);
3154     ok(r==S_OK, "StgCreateDocfile failed\n");
3155
3156     /* create a substorage */
3157     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
3158     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3159
3160     /* create another substorage */
3161     r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
3162     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3163
3164     /* add a stream, and leave it open */
3165     r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
3166     ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
3167
3168     /* Try to copy the storage while the stream is open */
3169     r = IStorage_CopyTo(stg2, 0, NULL, NULL, stg3);
3170     ok(r==S_OK, "IStorage->CopyTo failed, hr=%08x\n", r);
3171
3172     IStream_Release(stm);
3173
3174     /* create a substorage */
3175     r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg4);
3176     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3177
3178     /* Try to copy the storage while the substorage is open */
3179     r = IStorage_CopyTo(stg2, 0, NULL, NULL, stg3);
3180     ok(r==S_OK, "IStorage->CopyTo failed, hr=%08x\n", r);
3181
3182     IStorage_Release(stg4);
3183     IStorage_Release(stg3);
3184     IStorage_Release(stg2);
3185     IStorage_Release(stg);
3186
3187     ret = DeleteFileA(filenameA);
3188     ok(ret, "deleted file\n");
3189 }
3190
3191 static void test_copyto_recursive(void)
3192 {
3193     IStorage *stg, *stg2, *stg3, *stg4;
3194     HRESULT r;
3195     static const WCHAR stgname[] = { 'S','T','G','1',0 };
3196     static const WCHAR stgname2[] = { 'S','T','G','2',0 };
3197     BOOL ret;
3198
3199     DeleteFileA(filenameA);
3200
3201     /* create the file */
3202     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
3203                             STGM_READWRITE, 0, &stg);
3204     ok(r==S_OK, "StgCreateDocfile failed\n");
3205
3206     /* create a substorage */
3207     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
3208     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3209
3210     /* copy the parent to the child */
3211     r = IStorage_CopyTo(stg, 0, NULL, NULL, stg2);
3212     ok(r==STG_E_ACCESSDENIED, "IStorage->CopyTo failed, hr=%08x\n", r);
3213
3214     /* create a transacted substorage */
3215     r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg3);
3216     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3217
3218     /* copy the parent to the transacted child */
3219     r = IStorage_CopyTo(stg, 0, NULL, NULL, stg2);
3220     ok(r==STG_E_ACCESSDENIED, "IStorage->CopyTo failed, hr=%08x\n", r);
3221
3222     /* create a transacted subsubstorage */
3223     r = IStorage_CreateStorage(stg3, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg4);
3224     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
3225
3226     /* copy the parent to the transacted child of the transacted child */
3227     r = IStorage_CopyTo(stg, 0, NULL, NULL, stg4);
3228     ok(r==STG_E_ACCESSDENIED, "IStorage->CopyTo failed, hr=%08x\n", r);
3229
3230     /* copy the parent but exclude storage objects */
3231     r = IStorage_CopyTo(stg, 1, &IID_IStorage, NULL, stg4);
3232     ok(r==S_OK, "IStorage->CopyTo failed, hr=%08x\n", r);
3233
3234     IStorage_Release(stg4);
3235     IStorage_Release(stg3);
3236     IStorage_Release(stg2);
3237     IStorage_Release(stg);
3238
3239     ret = DeleteFileA(filenameA);
3240     ok(ret, "deleted file\n");
3241 }
3242
3243 static void test_hglobal_storage_creation(void)
3244 {
3245     ILockBytes *ilb = NULL;
3246     IStorage *stg = NULL;
3247     HRESULT r;
3248     STATSTG stat;
3249     char junk[512];
3250     ULARGE_INTEGER offset;
3251
3252     r = CreateILockBytesOnHGlobal(NULL, TRUE, &ilb);
3253     ok(r == S_OK, "CreateILockBytesOnHGlobal failed, hr=%x\n", r);
3254
3255     offset.QuadPart = 0;
3256     memset(junk, 0xaa, 512);
3257     r = ILockBytes_WriteAt(ilb, offset, junk, 512, NULL);
3258     ok(r == S_OK, "ILockBytes_WriteAt failed, hr=%x\n", r);
3259
3260     offset.QuadPart = 2000;
3261     r = ILockBytes_WriteAt(ilb, offset, junk, 512, NULL);
3262     ok(r == S_OK, "ILockBytes_WriteAt failed, hr=%x\n", r);
3263
3264     r = StgCreateDocfileOnILockBytes(ilb, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0,  &stg);
3265     ok(r == S_OK, "StgCreateDocfileOnILockBytes failed, hr=%x\n", r);
3266
3267     IStorage_Release(stg);
3268
3269     r = StgOpenStorageOnILockBytes(ilb, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE,
3270         NULL, 0, &stg);
3271     ok(r == S_OK, "StgOpenStorageOnILockBytes failed, hr=%x\n", r);
3272
3273     if (SUCCEEDED(r))
3274     {
3275         r = IStorage_Stat(stg, &stat, STATFLAG_NONAME);
3276         ok(r == S_OK, "StgOpenStorageOnILockBytes failed, hr=%x\n", r);
3277         ok(IsEqualCLSID(&stat.clsid, &GUID_NULL), "unexpected CLSID value\n");
3278
3279         IStorage_Release(stg);
3280     }
3281
3282     r = ILockBytes_Stat(ilb, &stat, STATFLAG_NONAME);
3283     ok(r == S_OK, "ILockBytes_Stat failed, hr=%x\n", r);
3284     ok(stat.cbSize.u.LowPart < 2512, "expected truncated size, got %d\n", stat.cbSize.u.LowPart);
3285
3286     ILockBytes_Release(ilb);
3287 }
3288
3289 static void test_convert(void)
3290 {
3291     static const WCHAR filename[] = {'s','t','o','r','a','g','e','.','s','t','g',0};
3292     IStorage *stg;
3293     HRESULT hr;
3294
3295     hr = GetConvertStg(NULL);
3296     ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
3297
3298     hr = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
3299     ok(hr == S_OK, "StgCreateDocfile failed\n");
3300     hr = GetConvertStg(stg);
3301     ok(hr == STG_E_FILENOTFOUND, "got 0x%08x\n", hr);
3302     hr = SetConvertStg(stg, TRUE);
3303     ok(hr == S_OK, "got 0x%08x\n", hr);
3304     hr = SetConvertStg(stg, TRUE);
3305     ok(hr == S_OK, "got 0x%08x\n", hr);
3306     hr = GetConvertStg(stg);
3307     ok(hr == S_OK, "got 0x%08x\n", hr);
3308     hr = SetConvertStg(stg, FALSE);
3309     ok(hr == S_OK, "got 0x%08x\n", hr);
3310     hr = GetConvertStg(stg);
3311     ok(hr == S_FALSE, "got 0x%08x\n", hr);
3312
3313     IStorage_Release(stg);
3314
3315     DeleteFileW(filename);
3316 }
3317
3318 static void test_direct_swmr(void)
3319 {
3320     static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
3321     IDirectWriterLock *dwlock;
3322     ULONG ref, ref2;
3323     IStorage *stg;
3324     HRESULT hr;
3325
3326     /* it's possible to create in writer mode */
3327     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE | STGM_SHARE_DENY_WRITE | STGM_DIRECT_SWMR, 0, &stg);
3328 todo_wine
3329     ok(hr == S_OK, "got %08x\n", hr);
3330 if (hr == S_OK) {
3331     IStorage_Release(stg);
3332     DeleteFileW(fileW);
3333 }
3334
3335     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE | STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
3336     ok(hr == S_OK, "got %08x\n", hr);
3337     IStorage_Release(stg);
3338
3339     /* reader mode */
3340     hr = StgOpenStorage(fileW, NULL, STGM_DIRECT_SWMR | STGM_READ | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
3341     ok(hr == S_OK || broken(hr == STG_E_INVALIDFLAG), "got %08x\n", hr);
3342     if(hr == S_OK)
3343     {
3344        hr = IStorage_QueryInterface(stg, &IID_IDirectWriterLock, (void**)&dwlock);
3345        ok(hr == E_NOINTERFACE, "got %08x\n", hr);
3346        IStorage_Release(stg);
3347     }
3348
3349     /* writer mode */
3350     hr = StgOpenStorage(fileW, NULL, STGM_DIRECT_SWMR | STGM_READWRITE | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
3351     ok(hr == S_OK, "got %08x\n", hr);
3352     if(hr == S_OK)
3353     {
3354         ref = IStorage_AddRef(stg);
3355         IStorage_Release(stg);
3356
3357         hr = IStorage_QueryInterface(stg, &IID_IDirectWriterLock, (void**)&dwlock);
3358         ok(hr == S_OK, "got %08x\n", hr);
3359
3360         ref2 = IStorage_AddRef(stg);
3361         IStorage_Release(stg);
3362         ok(ref2 == ref + 1, "got %u\n", ref2);
3363
3364         IDirectWriterLock_Release(dwlock);
3365         IStorage_Release(stg);
3366     }
3367
3368     DeleteFileW(fileW);
3369 }
3370
3371 struct lock_test
3372 {
3373     DWORD stg_mode;
3374     BOOL create;
3375     DWORD access;
3376     DWORD sharing;
3377     const int *locked_bytes;
3378     const int *fail_ranges;
3379     BOOL todo;
3380 };
3381
3382 static const int priority_locked_bytes[] = { 0x158, 0x181, 0x193, -1 };
3383 static const int rwex_locked_bytes[] = { 0x193, 0x1a7, 0x1bb, 0x1cf, -1 };
3384 static const int rw_locked_bytes[] = { 0x193, 0x1a7, -1 };
3385 static const int nosn_locked_bytes[] = { 0x16c, 0x193, 0x1a7, 0x1cf, -1 };
3386 static const int rwdw_locked_bytes[] = { 0x193, 0x1a7, 0x1cf, -1 };
3387 static const int wodw_locked_bytes[] = { 0x1a7, 0x1cf, -1 };
3388 static const int tr_locked_bytes[] = { 0x193, -1 };
3389 static const int no_locked_bytes[] = { -1 };
3390 static const int roex_locked_bytes[] = { 0x193, 0x1bb, 0x1cf, -1 };
3391
3392 static const int rwex_fail_ranges[] = { 0x193,0x1e3, -1 };
3393 static const int rw_fail_ranges[] = { 0x1bb,0x1e3, -1 };
3394 static const int rwdw_fail_ranges[] = { 0x1a7,0x1e3, -1 };
3395 static const int dw_fail_ranges[] = { 0x1a7,0x1cf, -1 };
3396 static const int tr_fail_ranges[] = { 0x1bb,0x1cf, -1 };
3397 static const int pr_fail_ranges[] = { 0x180,0x181, 0x1bb,0x1cf, -1 };
3398 static const int roex_fail_ranges[] = { 0x0,-1 };
3399
3400 static const struct lock_test lock_tests[] = {
3401     { STGM_PRIORITY, FALSE, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, priority_locked_bytes, pr_fail_ranges, FALSE },
3402     { STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, TRUE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, rwex_locked_bytes, 0, FALSE },
3403     { STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE|STGM_TRANSACTED, TRUE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, rwex_locked_bytes, 0, FALSE },
3404     { STGM_CREATE|STGM_READWRITE|STGM_TRANSACTED, TRUE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, rw_locked_bytes, 0, FALSE },
3405     { STGM_CREATE|STGM_READWRITE|STGM_SHARE_DENY_WRITE|STGM_TRANSACTED, TRUE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, rwdw_locked_bytes, 0, FALSE },
3406     { STGM_CREATE|STGM_WRITE|STGM_SHARE_DENY_WRITE|STGM_TRANSACTED, TRUE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, wodw_locked_bytes, 0, FALSE },
3407     { STGM_SHARE_EXCLUSIVE|STGM_READWRITE, FALSE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, rwex_locked_bytes, rwex_fail_ranges, FALSE },
3408     { STGM_SHARE_EXCLUSIVE|STGM_READWRITE|STGM_TRANSACTED, FALSE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, rwex_locked_bytes, rwex_fail_ranges, FALSE },
3409     { STGM_READWRITE|STGM_TRANSACTED, FALSE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, rw_locked_bytes, rw_fail_ranges, FALSE },
3410     { STGM_READWRITE|STGM_TRANSACTED|STGM_NOSNAPSHOT, FALSE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ|FILE_SHARE_WRITE, nosn_locked_bytes, rwdw_fail_ranges, FALSE },
3411     { STGM_READWRITE|STGM_TRANSACTED|STGM_SHARE_DENY_WRITE, FALSE, GENERIC_READ|GENERIC_WRITE, FILE_SHARE_READ, rwdw_locked_bytes, rwdw_fail_ranges, FALSE },
3412     { STGM_READ|STGM_SHARE_DENY_WRITE, FALSE, GENERIC_READ, FILE_SHARE_READ, no_locked_bytes, dw_fail_ranges, TRUE },
3413     { STGM_READ|STGM_TRANSACTED, FALSE, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE, tr_locked_bytes, tr_fail_ranges, FALSE },
3414     { STGM_READ|STGM_SHARE_EXCLUSIVE, FALSE, GENERIC_READ, FILE_SHARE_READ, roex_locked_bytes, roex_fail_ranges, FALSE },
3415     { STGM_READ|STGM_SHARE_EXCLUSIVE|STGM_TRANSACTED, FALSE, GENERIC_READ, FILE_SHARE_READ, roex_locked_bytes, roex_fail_ranges, FALSE },
3416 };
3417
3418 static BOOL can_open(LPCWSTR filename, DWORD access, DWORD sharing)
3419 {
3420     HANDLE hfile;
3421
3422     hfile = CreateFileW(filename, access, sharing, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
3423
3424     if (hfile == INVALID_HANDLE_VALUE)
3425         return FALSE;
3426
3427     CloseHandle(hfile);
3428     return TRUE;
3429 }
3430
3431 static void check_sharing(LPCWSTR filename, const struct lock_test *current,
3432     DWORD access, DWORD sharing, const char *desc, DWORD *open_mode, BOOL *any_failure)
3433 {
3434     if (can_open(filename, access, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE))
3435     {
3436         *open_mode = access;
3437         if (!current->todo || (current->sharing & sharing))
3438             ok(current->sharing & sharing ||
3439                 broken(!(current->sharing & sharing) && access == GENERIC_WRITE && (current->stg_mode & 0xf) != STGM_READ) /* win2k */,
3440                 "file with mode %x should not be openable with %s permission\n", current->stg_mode, desc);
3441         else
3442         {
3443             todo_wine ok(current->sharing & sharing ||
3444                 broken(!(current->sharing & sharing) && access == GENERIC_WRITE && (current->stg_mode & 0xf) != STGM_READ) /* win2k */,
3445                 "file with mode %x should not be openable with %s permission\n", current->stg_mode, desc);
3446             *any_failure = TRUE;
3447         }
3448     }
3449     else
3450     {
3451         if (!current->todo || !(current->sharing & sharing))
3452             ok(!(current->sharing & sharing), "file with mode %x should be openable with %s permission\n", current->stg_mode, desc);
3453         else
3454         {
3455             todo_wine ok(!(current->sharing & sharing), "file with mode %x should be openable with %s permission\n", current->stg_mode, desc);
3456             *any_failure = TRUE;
3457         }
3458     }
3459 }
3460
3461 static void check_access(LPCWSTR filename, const struct lock_test *current,
3462     DWORD access, DWORD sharing, const char *desc, DWORD open_mode, BOOL *any_failure)
3463 {
3464     if (can_open(filename, open_mode, (FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE) & ~sharing))
3465     {
3466         if (!current->todo || !(current->access & access))
3467             ok(!(current->access & access), "file with mode %x should not be openable without %s sharing\n", current->stg_mode, desc);
3468         else
3469         {
3470             todo_wine ok(!(current->access & access), "file with mode %x should not be openable without %s sharing\n", current->stg_mode, desc);
3471             *any_failure = TRUE;
3472         }
3473     }
3474     else
3475     {
3476         if (!current->todo || (current->access & access))
3477             ok(current->access & access, "file with mode %x should be openable without %s sharing\n", current->stg_mode, desc);
3478         else
3479         {
3480             todo_wine ok(current->access & access, "file with mode %x should be openable without %s sharing\n", current->stg_mode, desc);
3481             *any_failure = TRUE;
3482         }
3483     }
3484 }
3485
3486 static void test_locking(void)
3487 {
3488     static const WCHAR filename[] = {'w','i','n','e','t','e','s','t',0};
3489     int i;
3490     IStorage *stg;
3491     HRESULT hr;
3492
3493     for (i = 0; i < ARRAY_SIZE(lock_tests); i++)
3494     {
3495         const struct lock_test *current = &lock_tests[i];
3496         BOOL any_failure = FALSE;
3497         DWORD open_mode = 0;
3498
3499         if (current->create)
3500         {
3501             hr = StgCreateDocfile(filename, current->stg_mode, 0, &stg);
3502             ok(SUCCEEDED(hr), "StgCreateDocfile with mode %x failed with hr %x\n", current->stg_mode, hr);
3503             if (FAILED(hr)) continue;
3504         }
3505         else
3506         {
3507             hr = StgCreateDocfile(filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
3508             ok(SUCCEEDED(hr), "StgCreateDocfile failed with hr %x\n", hr);
3509             if (FAILED(hr)) continue;
3510             IStorage_Release(stg);
3511
3512             hr = StgOpenStorage(filename, NULL, current->stg_mode, NULL, 0, &stg);
3513             ok(SUCCEEDED(hr), "StgOpenStorage with mode %x failed with hr %x\n", current->stg_mode, hr);
3514             if (FAILED(hr))
3515             {
3516                 DeleteFileW(filename);
3517                 continue;
3518             }
3519         }
3520
3521         check_sharing(filename, current, GENERIC_READ, FILE_SHARE_READ, "READ", &open_mode, &any_failure);
3522         check_sharing(filename, current, GENERIC_WRITE, FILE_SHARE_WRITE, "WRITE", &open_mode, &any_failure);
3523         check_sharing(filename, current, DELETE, FILE_SHARE_DELETE, "DELETE", &open_mode, &any_failure);
3524
3525         if (open_mode != 0)
3526         {
3527             HANDLE hfile;
3528             BOOL locked, expect_locked;
3529             OVERLAPPED ol;
3530             const int* next_lock = current->locked_bytes;
3531
3532             check_access(filename, current, GENERIC_READ, FILE_SHARE_READ, "READ", open_mode, &any_failure);
3533             check_access(filename, current, GENERIC_WRITE, FILE_SHARE_WRITE, "WRITE", open_mode, &any_failure);
3534             check_access(filename, current, DELETE, FILE_SHARE_DELETE, "DELETE", open_mode, &any_failure);
3535
3536             hfile = CreateFileW(filename, open_mode, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
3537             ok(hfile != INVALID_HANDLE_VALUE, "couldn't open file with mode %x\n", current->stg_mode);
3538
3539             ol.u.s.OffsetHigh = 0;
3540             ol.hEvent = NULL;
3541
3542             for (ol.u.s.Offset = 0x7ffffe00; ol.u.s.Offset != 0x80000000; ol.u.s.Offset++)
3543             {
3544                 if (LockFileEx(hfile, LOCKFILE_EXCLUSIVE_LOCK|LOCKFILE_FAIL_IMMEDIATELY, 0, 1, 0, &ol))
3545                     locked = FALSE;
3546                 else
3547                 {
3548                     ok(!LockFileEx(hfile, LOCKFILE_FAIL_IMMEDIATELY, 0, 1, 0, &ol), "shared locks should not be used\n");
3549                     locked = TRUE;
3550                 }
3551
3552                 UnlockFileEx(hfile, 0, 1, 0, &ol);
3553
3554                 if ((ol.u.s.Offset&0x1ff) == *next_lock)
3555                 {
3556                     expect_locked = TRUE;
3557                     next_lock++;
3558                 }
3559                 else
3560                     expect_locked = FALSE;
3561
3562                 if (!current->todo || locked == expect_locked)
3563                     ok(locked == expect_locked, "byte %x of file with mode %x is %slocked but should %sbe\n",
3564                        ol.u.s.Offset, current->stg_mode, locked?"":"not ", expect_locked?"":"not ");
3565                 else
3566                 {
3567                     any_failure = TRUE;
3568                     todo_wine ok(locked == expect_locked, "byte %x of file with mode %x is %slocked but should %sbe\n",
3569                               ol.u.s.Offset, current->stg_mode, locked?"":"not ", expect_locked?"":"not ");
3570                 }
3571             }
3572
3573             CloseHandle(hfile);
3574         }
3575
3576         IStorage_Release( stg );
3577
3578         if (!current->create)
3579         {
3580             HANDLE hfile;
3581             BOOL failed, expect_failed=FALSE;
3582             OVERLAPPED ol;
3583             const int* next_range = current->fail_ranges;
3584
3585             hfile = CreateFileW(filename, open_mode, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
3586             ok(hfile != INVALID_HANDLE_VALUE, "couldn't open file with mode %x\n", current->stg_mode);
3587
3588             ol.u.s.OffsetHigh = 0;
3589             ol.hEvent = NULL;
3590
3591             for (ol.u.s.Offset = 0x7ffffe00; ol.u.s.Offset != 0x80000000; ol.u.s.Offset++)
3592             {
3593                 if (ol.u.s.Offset == 0x7fffff92 ||
3594                     (ol.u.s.Offset == 0x7fffff80 && current->stg_mode == (STGM_TRANSACTED|STGM_READWRITE)) ||
3595                     (ol.u.s.Offset == 0x7fffff80 && current->stg_mode == (STGM_TRANSACTED|STGM_READ)))
3596                     continue; /* This makes opens hang */
3597
3598                 if (ol.u.s.Offset < 0x7fffff00)
3599                     LockFileEx(hfile, 0, 0, 1, 0, &ol);
3600                 else
3601                     LockFileEx(hfile, LOCKFILE_EXCLUSIVE_LOCK, 0, 1, 0, &ol);
3602
3603                 hr = StgOpenStorage(filename, NULL, current->stg_mode, NULL, 0, &stg);
3604                 ok(hr == S_OK || hr == STG_E_LOCKVIOLATION || hr == STG_E_SHAREVIOLATION, "failed with unexpected hr %x\n", hr);
3605                 if (SUCCEEDED(hr)) IStorage_Release(stg);
3606
3607                 UnlockFileEx(hfile, 0, 1, 0, &ol);
3608
3609                 failed = FAILED(hr);
3610
3611                 if (!expect_failed && (ol.u.s.Offset&0x1ff) == next_range[0])
3612                 {
3613                     expect_failed = TRUE;
3614                 }
3615                 else if (expect_failed && (ol.u.s.Offset&0x1ff) == next_range[1])
3616                 {
3617                     expect_failed = FALSE;
3618                     next_range += 2;
3619                 }
3620
3621                 if (!current->todo || failed == expect_failed)
3622                     ok(failed == expect_failed, "open with byte %x locked, mode %x %s but should %s\n",
3623                        ol.u.s.Offset, current->stg_mode, failed?"failed":"succeeded", expect_failed?"fail":"succeed");
3624                 else
3625                 {
3626                     any_failure = TRUE;
3627                     todo_wine ok(failed == expect_failed, "open with byte %x locked, mode %x %s but should %s\n",
3628                                  ol.u.s.Offset, current->stg_mode, failed?"failed":"succeeded", expect_failed?"fail":"succeed");
3629                 }
3630             }
3631
3632             CloseHandle(hfile);
3633         }
3634
3635         DeleteFileW(filename);
3636
3637         if (current->todo && !any_failure)
3638             todo_wine ok(1, "tests succeeded for mode %x\n", current->stg_mode);
3639     }
3640 }
3641
3642 static void test_transacted_shared(void)
3643 {
3644     IStorage *stg = NULL;
3645     IStorage *stgrw = NULL;
3646     HRESULT r;
3647     IStream *stm = NULL;
3648     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
3649     LARGE_INTEGER pos;
3650     ULARGE_INTEGER upos;
3651     char buffer[10];
3652     ULONG bytesread;
3653
3654     DeleteFileA(filenameA);
3655
3656     /* create a new transacted storage with a stream */
3657     r = StgCreateDocfile(filename, STGM_CREATE |
3658                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
3659     ok(r==S_OK, "StgCreateDocfile failed %x\n", r);
3660
3661     r = WriteClassStg(stg, &test_stg_cls);
3662     ok(r == S_OK, "WriteClassStg failed %x\n", r);
3663
3664     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
3665     ok(r==S_OK, "IStorage->CreateStream failed %x\n", r);
3666
3667     pos.QuadPart = 0;
3668     r = IStream_Seek(stm, pos, 0, &upos);
3669     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3670
3671     r = IStream_Write(stm, "aaa", 3, NULL);
3672     ok(r==S_OK, "IStream->Write failed %x\n", r);
3673
3674     r = IStorage_Commit(stg, STGC_ONLYIFCURRENT);
3675     ok(r==S_OK, "IStorage->Commit failed %x\n", r);
3676
3677     /* open a second transacted read/write storage */
3678     r = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_TRANSACTED | STGM_SHARE_DENY_NONE, NULL, 0, &stgrw);
3679     ok(r==S_OK, "StgOpenStorage failed %x\n", r);
3680
3681     /* update stream on the first storage and commit */
3682     pos.QuadPart = 0;
3683     r = IStream_Seek(stm, pos, 0, &upos);
3684     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3685
3686     r = IStream_Write(stm, "ccc", 3, NULL);
3687     ok(r==S_OK, "IStream->Write failed %x\n", r);
3688
3689     r = IStorage_Commit(stg, STGC_ONLYIFCURRENT);
3690     ok(r==S_OK, "IStorage->Commit failed %x\n", r);
3691
3692     /* update again without committing */
3693     pos.QuadPart = 0;
3694     r = IStream_Seek(stm, pos, 0, &upos);
3695     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3696
3697     r = IStream_Write(stm, "ddd", 3, NULL);
3698     ok(r==S_OK, "IStream->Write failed %x\n", r);
3699
3700     IStream_Release(stm);
3701
3702     /* we can still read the old content from the second storage */
3703     r = IStorage_OpenStream(stgrw, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
3704     ok(r==S_OK, "IStorage->OpenStream failed %x\n", r);
3705
3706     pos.QuadPart = 0;
3707     r = IStream_Seek(stm, pos, 0, &upos);
3708     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3709
3710     r = IStream_Read(stm, buffer, sizeof(buffer), &bytesread);
3711     ok(r==S_OK, "IStream->Read failed %x\n", r);
3712     ok(bytesread == 3, "read wrong number of bytes %i\n", bytesread);
3713     ok(memcmp(buffer, "aaa", 3) == 0, "wrong data\n");
3714
3715     /* and overwrite the data */
3716     pos.QuadPart = 0;
3717     r = IStream_Seek(stm, pos, 0, &upos);
3718     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3719
3720     r = IStream_Write(stm, "bbb", 3, NULL);
3721     ok(r==S_OK, "IStream->Write failed %x\n", r);
3722
3723     IStream_Release(stm);
3724
3725     /* commit fails because we're out of date */
3726     r = IStorage_Commit(stgrw, STGC_ONLYIFCURRENT);
3727     ok(r==STG_E_NOTCURRENT, "IStorage->Commit failed %x\n", r);
3728
3729     /* unless we force it */
3730     r = IStorage_Commit(stgrw, STGC_DEFAULT);
3731     ok(r==S_OK, "IStorage->Commit failed %x\n", r);
3732
3733     /* reverting gets us back to the last commit from the same storage */
3734     r = IStorage_Revert(stg);
3735     ok(r==S_OK, "IStorage->Revert failed %x\n", r);
3736
3737     r = IStorage_OpenStream(stg, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
3738     ok(r==S_OK, "IStorage->CreateStream failed %x\n", r);
3739
3740     pos.QuadPart = 0;
3741     r = IStream_Seek(stm, pos, 0, &upos);
3742     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3743
3744     r = IStream_Read(stm, buffer, sizeof(buffer), &bytesread);
3745     ok(r==S_OK, "IStream->Read failed %x\n", r);
3746     ok(bytesread == 3, "read wrong number of bytes %i\n", bytesread);
3747     ok(memcmp(buffer, "ccc", 3) == 0, "wrong data\n");
3748
3749     /* and committing fails forever */
3750     r = IStorage_Commit(stg, STGC_ONLYIFCURRENT);
3751     ok(r==STG_E_NOTCURRENT, "IStorage->Commit failed %x\n", r);
3752
3753     IStream_Release(stm);
3754
3755     IStorage_Release(stg);
3756     IStorage_Release(stgrw);
3757
3758     DeleteFileA(filenameA);
3759 }
3760
3761 static void test_overwrite(void)
3762 {
3763     IStorage *stg = NULL;
3764     HRESULT r;
3765     IStream *stm = NULL;
3766     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
3767     static const WCHAR stmname2[] = { 'C','O','N','T','E','N','T','2',0 };
3768     LARGE_INTEGER pos;
3769     ULARGE_INTEGER upos;
3770     char buffer[4096];
3771     DWORD orig_size, new_size;
3772     ULONG bytesread;
3773     HANDLE hfile;
3774     int i;
3775
3776     DeleteFileA(filenameA);
3777
3778     r = StgCreateDocfile(filename, STGM_CREATE | STGM_READWRITE | STGM_TRANSACTED, 0, &stg);
3779     ok(r==S_OK, "StgCreateDocfile failed %x\n", r);
3780
3781     r = WriteClassStg(stg, &test_stg_cls);
3782     ok(r == S_OK, "WriteClassStg failed %x\n", r);
3783
3784     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
3785     ok(r==S_OK, "IStorage->CreateStream failed %x\n", r);
3786
3787     pos.QuadPart = 0;
3788     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
3789     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3790
3791     memset(buffer, 'a', sizeof(buffer));
3792     for (i=0; i<4; i++)
3793     {
3794         /* Write enough bytes to pass the minimum storage file size */
3795         r = IStream_Write(stm, buffer, sizeof(buffer), NULL);
3796         ok(r==S_OK, "IStream->Write failed %x\n", r);
3797     }
3798
3799     r = IStorage_Commit(stg, STGC_DEFAULT);
3800     ok(r==S_OK, "IStorage->Commit failed %x\n", r);
3801
3802     hfile = CreateFileA(filenameA, GENERIC_READ, FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE,
3803         NULL, OPEN_EXISTING, 0, NULL);
3804     ok(hfile != NULL, "couldn't open file %d\n", GetLastError());
3805
3806     orig_size = GetFileSize(hfile, NULL);
3807
3808     pos.QuadPart = 0;
3809     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
3810     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3811
3812     r = IStream_Write(stm, "b", 1, NULL);
3813     ok(r==S_OK, "IStream->Write failed %x\n", r);
3814
3815     r = IStorage_Commit(stg, STGC_OVERWRITE);
3816     ok(r==S_OK, "IStorage->Commit failed %x\n", r);
3817
3818     new_size = GetFileSize(hfile, NULL);
3819
3820     todo_wine ok(new_size == orig_size, "file grew from %d bytes to %d\n", orig_size, new_size);
3821
3822     IStream_Release(stm);
3823
3824     IStorage_RenameElement(stg, stmname, stmname2);
3825
3826     r = IStorage_Commit(stg, STGC_OVERWRITE);
3827     ok(r==S_OK, "IStorage->Commit failed %x\n", r);
3828
3829     new_size = GetFileSize(hfile, NULL);
3830
3831     todo_wine ok(new_size == orig_size, "file grew from %d bytes to %d\n", orig_size, new_size);
3832
3833     IStorage_Release(stg);
3834
3835     r = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
3836     ok(r==S_OK, "StgOpenStorage failed %x\n", r);
3837
3838     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
3839     ok(r==S_OK, "IStorage->CreateStream failed %x\n", r);
3840
3841     r = IStream_Read(stm, buffer, sizeof(buffer), &bytesread);
3842     ok(r==S_OK, "IStream->Write failed %x\n", r);
3843     ok(bytesread == sizeof(buffer), "only read %d bytes\n", bytesread);
3844     ok(buffer[0] == 'b', "unexpected data at byte 0\n");
3845
3846     for (i=1; i<sizeof(buffer); i++)
3847         if (buffer[i] != 'a')
3848             break;
3849     ok(i == sizeof(buffer), "unexpected data at byte %i\n", i);
3850
3851     pos.QuadPart = 0;
3852     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
3853     ok(r==S_OK, "IStream->Seek failed %x\n", r);
3854
3855     r = IStream_Write(stm, "c", 1, NULL);
3856     ok(r==S_OK, "IStream->Write failed %x\n", r);
3857
3858     r = IStorage_Commit(stg, STGC_OVERWRITE);
3859     ok(r==S_OK, "IStorage->Commit failed %x\n", r);
3860
3861     new_size = GetFileSize(hfile, NULL);
3862
3863     todo_wine ok(new_size == orig_size, "file grew from %d bytes to %d\n", orig_size, new_size);
3864
3865     IStream_Release(stm);
3866
3867     IStorage_Release(stg);
3868
3869     CloseHandle(hfile);
3870
3871     DeleteFileA(filenameA);
3872 }
3873
3874 static void test_custom_lockbytes(void)
3875 {
3876     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
3877     TestLockBytes* lockbytes;
3878     HRESULT hr;
3879     IStorage* stg;
3880     IStream* stm;
3881
3882     CreateTestLockBytes(&lockbytes);
3883
3884     hr = StgCreateDocfileOnILockBytes(&lockbytes->ILockBytes_iface, STGM_CREATE|STGM_READWRITE|STGM_TRANSACTED, 0, &stg);
3885     ok(hr==S_OK, "StgCreateDocfileOnILockBytes failed %x\n", hr);
3886
3887     hr = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stm);
3888     ok(hr==S_OK, "IStorage_CreateStream failed %x\n", hr);
3889
3890     IStream_Release(stm);
3891
3892     hr = IStorage_Commit(stg, 0);
3893
3894     IStorage_Release(stg);
3895
3896     ok(!lockbytes->lock_called, "unexpected call to LockRegion\n");
3897
3898     lockbytes->locks_supported = LOCK_WRITE|LOCK_EXCLUSIVE|LOCK_ONLYONCE;
3899
3900     hr = StgCreateDocfileOnILockBytes(&lockbytes->ILockBytes_iface, STGM_CREATE|STGM_READWRITE|STGM_TRANSACTED, 0, &stg);
3901     ok(hr==S_OK, "StgCreateDocfileOnILockBytes failed %x\n", hr);
3902
3903     hr = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stm);
3904     ok(hr==S_OK, "IStorage_CreateStream failed %x\n", hr);
3905
3906     IStream_Release(stm);
3907
3908     hr = IStorage_Commit(stg, 0);
3909
3910     IStorage_Release(stg);
3911
3912     ok(lockbytes->lock_called, "expected LockRegion to be called\n");
3913
3914     lockbytes->lock_hr = STG_E_INVALIDFUNCTION;
3915
3916     hr = StgCreateDocfileOnILockBytes(&lockbytes->ILockBytes_iface, STGM_CREATE|STGM_READWRITE|STGM_TRANSACTED, 0, &stg);
3917     ok(hr==STG_E_INVALIDFUNCTION, "StgCreateDocfileOnILockBytes failed %x\n", hr);
3918
3919     DeleteTestLockBytes(lockbytes);
3920 }
3921
3922 START_TEST(storage32)
3923 {
3924     CHAR temp[MAX_PATH];
3925
3926     GetTempPathA(MAX_PATH, temp);
3927     if(!GetTempFileNameA(temp, "stg", 0, filenameA))
3928     {
3929         win_skip("Could not create temp file, %u\n", GetLastError());
3930         return;
3931     }
3932     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
3933     DeleteFileA(filenameA);
3934
3935     test_hglobal_storage_stat();
3936     test_create_storage_modes();
3937     test_stgcreatestorageex();
3938     test_storage_stream();
3939     test_open_storage();
3940     test_storage_suminfo();
3941     test_storage_refcount();
3942     test_streamenum();
3943     test_transact();
3944     test_substorage_share();
3945     test_revert();
3946     test_parent_free();
3947     test_nonroot_transacted();
3948     test_ReadClassStm();
3949     test_access();
3950     test_writeclassstg();
3951     test_readonly();
3952     test_simple();
3953     test_fmtusertypestg();
3954     test_references();
3955     test_copyto();
3956     test_copyto_snbexclusions();
3957     test_copyto_iidexclusions_storage();
3958     test_copyto_iidexclusions_stream();
3959     test_rename();
3960     test_toplevel_stat();
3961     test_substorage_enum();
3962     test_copyto_locking();
3963     test_copyto_recursive();
3964     test_hglobal_storage_creation();
3965     test_convert();
3966     test_direct_swmr();
3967     test_locking();
3968     test_transacted_shared();
3969     test_overwrite();
3970     test_custom_lockbytes();
3971 }