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
  25 #include <windows.h>
  26 #include "wine/test.h"
  27
  28 #include "ole2.h"
  29 #include "objidl.h"
  30 #include "initguid.h"
  31
  32 DEFINE_GUID( test_stg_cls, 0x88888888, 0x0425, 0x0000, 0,0,0,0,0,0,0,0);
  33
  34 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
  35
  36 static CHAR filenameA[MAX_PATH];
  37 static WCHAR filename[MAX_PATH];
  38
  39 static const WCHAR file1_name[] = {'c','o','p','y','t','e','s','t','A',0};
  40 static const WCHAR file2_name[] = {'c','o','p','y','t','e','s','t','B',0};
  41 static const WCHAR stgA_name[] = {'S','t','o','r','a','g','e','A',0};
  42 static const WCHAR stgB_name[] = {'S','t','o','r','a','g','e','B',0};
  43 static const WCHAR strmA_name[] = {'S','t','r','e','a','m','A',0};
  44 static const WCHAR strmB_name[] = {'S','t','r','e','a','m','B',0};
  45 static const WCHAR strmC_name[] = {'S','t','r','e','a','m','C',0};
  46
  47 static void test_hglobal_storage_stat(void)
  48 {
  49     ILockBytes *ilb = NULL;
  50     IStorage *stg = NULL;
  51     HRESULT r;
  52     STATSTG stat;
  53     DWORD mode, refcount;
  54
  55     r = CreateILockBytesOnHGlobal( NULL, TRUE, &ilb );
  56     ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
  57
  58     mode = STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE;/*0x1012*/
  59     r = StgCreateDocfileOnILockBytes( ilb, mode, 0,  &stg );
  60     ok( r == S_OK, "StgCreateDocfileOnILockBytes failed\n");
  61
  62     r = WriteClassStg( stg, &test_stg_cls );
  63     ok( r == S_OK, "WriteClassStg failed\n");
  64
  65     memset( &stat, 0, sizeof stat );
  66     r = IStorage_Stat( stg, &stat, 0 );
  67
  68     ok( stat.pwcsName == NULL, "storage name not null\n");
  69     ok( stat.type == 1, "type is wrong\n");
  70     ok( stat.grfMode == 0x12, "grf mode is incorrect\n");
  71     ok( !memcmp(&stat.clsid, &test_stg_cls, sizeof test_stg_cls), "CLSID is wrong\n");
  72
  73     refcount = IStorage_Release( stg );
  74     ok( refcount == 0, "IStorage refcount is wrong\n");
  75     refcount = ILockBytes_Release( ilb );
  76     ok( refcount == 0, "ILockBytes refcount is wrong\n");
  77 }
  78
  79 static void test_create_storage_modes(void)
  80 {
  81    IStorage *stg = NULL;
  82    HRESULT r;
  83
  84    DeleteFileA(filenameA);
  85
  86    /* test with some invalid parameters */
  87    r = StgCreateDocfile( NULL, 0, 0, &stg);
  88    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  89    r = StgCreateDocfile( filename, 0, 0, &stg);
  90    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  91    r = StgCreateDocfile( filename, STGM_CREATE, 0, &stg);
  92    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  93    r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE, 0, &stg);
  94    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  95    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &stg);
  96    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  97    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, NULL);
  98    ok(r==STG_E_INVALIDPOINTER, "StgCreateDocfile succeeded\n");
  99    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, &stg);
 100    ok(r==STG_E_INVALIDPARAMETER, "StgCreateDocfile succeeded\n");
 101    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
 102    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 103    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READ, 0, &stg);
 104    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 105    r = StgCreateDocfile( filename, STGM_PRIORITY, 0, &stg);
 106    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 107
 108    /* StgCreateDocfile seems to be very particular about the flags it accepts */
 109    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | STGM_WRITE, 0, &stg);
 110    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 111    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 8, 0, &stg);
 112    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 113    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80, 0, &stg);
 114    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 115    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800, 0, &stg);
 116    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 117    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x8000, 0, &stg);
 118    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 119    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80000, 0, &stg);
 120    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 121    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800000, 0, &stg);
 122    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 123    ok(stg == NULL, "stg was set\n");
 124
 125    /* check what happens if the file already exists (which is how it's meant to be used) */
 126    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 127    ok(r==S_OK, "StgCreateDocfile failed\n");
 128    r = IStorage_Release(stg);
 129    ok(r == 0, "storage not released\n");
 130    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 131    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n"); /* FAILIFTHERE is default */
 132    r = StgCreateDocfile( filename, STGM_READ, 0, &stg);
 133    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n"); /* need at least readmode and sharemode */
 134    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE, 0, &stg);
 135    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 136    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE, 0, &stg);
 137    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 138    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE, 0, &stg);
 139    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 140    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
 141    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 142    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, &stg);
 143    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 144    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_WRITE, 0, &stg);
 145    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 146    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_WRITE, 0, &stg);
 147    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 148    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
 149    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
 150    r = StgCreateDocfile( filename, STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
 151    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
 152    ok(DeleteFileA(filenameA), "failed to delete file\n");
 153
 154    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 155    ok(r==S_OK, "StgCreateDocfile failed\n");
 156    r = IStorage_Release(stg);
 157    ok(r == 0, "storage not released\n");
 158    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED |STGM_FAILIFTHERE, 0, &stg);
 159    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 160    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_WRITE, 0, &stg);
 161    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 162
 163    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
 164    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 165    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 166    ok(r==S_OK, "StgCreateDocfile failed\n");
 167    r = IStorage_Release(stg);
 168    ok(r == 0, "storage not released\n");
 169    ok(DeleteFileA(filenameA), "failed to delete file\n");
 170
 171    r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 172    ok(r==S_OK, "StgCreateDocfile failed\n");
 173    r = IStorage_Release(stg);
 174    ok(r == 0, "storage not released\n");
 175    ok(DeleteFileA(filenameA), "failed to delete file\n");
 176
 177    /* test the way excel uses StgCreateDocFile */
 178    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 179    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 180    if(r == S_OK)
 181    {
 182       r = IStorage_Release(stg);
 183       ok(r == 0, "storage not released\n");
 184       ok(DeleteFileA(filenameA), "failed to delete file\n");
 185    }
 186
 187    /* and the way windows media uses it ... */
 188    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_NONE | STGM_READWRITE | STGM_TRANSACTED, 0, &stg);
 189    ok(r==S_OK, "StgCreateDocfile the windows media way failed\n");
 190    if (r == S_OK)
 191    {
 192       r = IStorage_Release(stg);
 193       ok(r == 0, "storage not released\n");
 194       ok(DeleteFileA(filenameA), "failed to delete file\n");
 195    }
 196
 197    /* looks like we need STGM_TRANSACTED or STGM_CREATE */
 198    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 199    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 200    if(r == S_OK)
 201    {
 202       r = IStorage_Release(stg);
 203       ok(r == 0, "storage not released\n");
 204       ok(DeleteFileA(filenameA), "failed to delete file\n");
 205    }
 206
 207    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_WRITE, 0, &stg);
 208    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 209    if(r == S_OK)
 210    {
 211       r = IStorage_Release(stg);
 212       ok(r == 0, "storage not released\n");
 213       ok(DeleteFileA(filenameA), "failed to delete file\n");
 214    }
 215
 216    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 217    ok(r==S_OK, "StgCreateDocfile the powerpoint way failed\n");
 218    if(r == S_OK)
 219    {
 220       r = IStorage_Release(stg);
 221       ok(r == 0, "storage not released\n");
 222       ok(DeleteFileA(filenameA), "failed to delete file\n");
 223    }
 224
 225    /* test the way msi uses StgCreateDocfile */
 226    r = StgCreateDocfile( filename, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg);
 227    ok(r==S_OK, "StgCreateDocFile failed\n");
 228    r = IStorage_Release(stg);
 229    ok(r == 0, "storage not released\n");
 230    ok(DeleteFileA(filenameA), "failed to delete file\n");
 231 }
 232
 233 static void test_storage_stream(void)
 234 {
 235     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 236     static const WCHAR longname[] = {
 237         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
 238         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
 239     };
 240     IStorage *stg = NULL;
 241     HRESULT r;
 242     IStream *stm = NULL;
 243     IStream *stm2 = NULL;
 244     ULONG count = 0;
 245     LARGE_INTEGER pos;
 246     ULARGE_INTEGER p;
 247     unsigned char buffer[0x100];
 248
 249     DeleteFileA(filenameA);
 250
 251     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 252     ok(r==S_OK, "StgCreateDocfile failed\n");
 253
 254     /* try create some invalid streams */
 255     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, 0, &stm );
 256     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 257     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 1, &stm );
 258     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 259     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, NULL );
 260     ok(r==STG_E_INVALIDPOINTER, "IStorage->CreateStream wrong error\n");
 261     r = IStorage_CreateStream(stg, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 262     ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error\n");
 263     r = IStorage_CreateStream(stg, longname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 264     ok(r==STG_E_INVALIDNAME || broken(r==S_OK) /* nt4 */,
 265        "IStorage->CreateStream wrong error, got %d GetLastError()=%d\n", r, GetLastError());
 266     r = IStorage_CreateStream(stg, stmname, STGM_READWRITE, 0, 0, &stm );
 267     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 268     r = IStorage_CreateStream(stg, stmname, STGM_READ, 0, 0, &stm );
 269     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 270     r = IStorage_CreateStream(stg, stmname, STGM_WRITE, 0, 0, &stm );
 271     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 272     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, 0, &stm );
 273     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 274     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READ, 0, 0, &stm );
 275     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 276
 277     /* now really create a stream and delete it */
 278     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 279     ok(r==S_OK, "IStorage->CreateStream failed\n");
 280     r = IStream_Release(stm);
 281     ok(r == 0, "wrong ref count\n");
 282     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 283     ok(r==STG_E_FILEALREADYEXISTS, "IStorage->CreateStream failed\n");
 284     r = IStorage_DestroyElement(stg,stmname);
 285     ok(r==S_OK, "IStorage->DestroyElement failed\n");
 286
 287     /* create a stream and write to it */
 288     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 289     ok(r==S_OK, "IStorage->CreateStream failed\n");
 290
 291     r = IStream_Clone(stm, &stm2);
 292     ok(r==S_OK, "failed to clone stream\n");
 293
 294     r = IStream_Write(stm, NULL, 0, NULL );
 295     ok(r==STG_E_INVALIDPOINTER, "IStream->Write wrong error\n");
 296     r = IStream_Write(stm, "Hello\n", 0, NULL );
 297     ok(r==S_OK, "failed to write stream\n");
 298     r = IStream_Write(stm, "Hello\n", 0, &count );
 299     ok(r==S_OK, "failed to write stream\n");
 300     r = IStream_Write(stm, "Hello\n", 6, &count );
 301     ok(r==S_OK, "failed to write stream\n");
 302     r = IStream_Commit(stm, STGC_DEFAULT );
 303     ok(r==S_OK, "failed to commit stream\n");
 304     r = IStream_Commit(stm, STGC_DEFAULT );
 305     ok(r==S_OK, "failed to commit stream\n");
 306
 307     /* seek round a bit, reset the stream size */
 308     pos.QuadPart = 0;
 309     r = IStream_Seek(stm, pos, 3, &p );
 310     ok(r==STG_E_INVALIDFUNCTION, "IStream->Seek returned wrong error\n");
 311     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
 312     ok(r==S_OK, "failed to seek stream\n");
 313     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 314     ok(r==S_OK, "failed to seek stream\n");
 315     r = IStream_SetSize(stm,p);
 316     ok(r==S_OK, "failed to set pos\n");
 317     pos.QuadPart = 10;
 318     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 319     ok(r==S_OK, "failed to seek stream\n");
 320     ok(p.QuadPart == 10, "at wrong place\n");
 321     pos.QuadPart = 0;
 322     r = IStream_Seek(stm, pos, STREAM_SEEK_END, &p );
 323     ok(r==S_OK, "failed to seek stream\n");
 324     ok(p.QuadPart == 0, "at wrong place\n");
 325     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 326     ok(r==S_OK, "failed to set pos\n");
 327     ok(count == 0, "read bytes from empty stream\n");
 328
 329     /* wrap up */
 330     r = IStream_Release(stm2);
 331     ok(r == 0, "wrong ref count\n");
 332
 333     /* create a stream and write to it */
 334     r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
 335     ok(r==S_OK, "IStorage->CreateStream failed\n");
 336
 337     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p);
 338     ok(r==STG_E_REVERTED, "overwritten stream should return STG_E_REVERTED instead of 0x%08x\n", r);
 339
 340     r = IStream_Release(stm2);
 341     ok(r == 0, "wrong ref count\n");
 342     r = IStream_Release(stm);
 343     ok(r == 0, "wrong ref count\n");
 344
 345     r = IStorage_Release(stg);
 346     ok(r == 0, "wrong ref count\n");
 347     r = DeleteFileA(filenameA);
 348     ok(r, "file should exist\n");
 349 }
 350
 351 static BOOL touch_file(LPCSTR filename)
 352 {
 353     HANDLE file;
 354
 355     file = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
 356                 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 357     if (file==INVALID_HANDLE_VALUE)
 358         return FALSE;
 359     CloseHandle(file);
 360     return TRUE;
 361 }
 362
 363 static BOOL is_zero_length(LPCSTR filename)
 364 {
 365     HANDLE file;
 366     DWORD len;
 367
 368     file = CreateFileA(filename, GENERIC_READ, 0, NULL,
 369                 OPEN_EXISTING, 0, NULL);
 370     if (file==INVALID_HANDLE_VALUE)
 371         return FALSE;
 372     len = GetFileSize(file, NULL);
 373     CloseHandle(file);
 374     return len == 0;
 375 }
 376
 377 static BOOL is_existing_file(LPCSTR filename)
 378 {
 379     HANDLE file;
 380
 381     file = CreateFileA(filename, GENERIC_READ, 0, NULL,
 382                        OPEN_EXISTING, 0, NULL);
 383     if (file==INVALID_HANDLE_VALUE)
 384         return FALSE;
 385     CloseHandle(file);
 386     return TRUE;
 387 }
 388
 389 static void test_open_storage(void)
 390 {
 391     static const WCHAR szNonExist[] = { 'n','o','n','e','x','i','s','t',0 };
 392     IStorage *stg = NULL, *stg2 = NULL;
 393     HRESULT r;
 394     DWORD stgm;
 395
 396     /* try opening a zero length file - it should stay zero length */
 397     DeleteFileA(filenameA);
 398     touch_file(filenameA);
 399     stgm = STGM_NOSCRATCH | STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READWRITE;
 400     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 401     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 402
 403     stgm = STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
 404     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 405     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 406     ok(is_zero_length(filenameA), "file length changed\n");
 407
 408     DeleteFileA(filenameA);
 409
 410     /* try opening a nonexistent file - it should not create it */
 411     stgm = STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
 412     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 413     ok(r!=S_OK, "StgOpenStorage failed: 0x%08x\n", r);
 414     if (r==S_OK) IStorage_Release(stg);
 415     ok(!is_existing_file(filenameA), "StgOpenStorage should not create a file\n");
 416     DeleteFileA(filenameA);
 417
 418     /* create the file */
 419     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 420     ok(r==S_OK, "StgCreateDocfile failed\n");
 421     IStorage_Release(stg);
 422
 423     r = StgOpenStorage( filename, NULL, 0, NULL, 0, &stg);
 424     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage wrong error\n");
 425     r = StgOpenStorage( NULL, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 426     ok(r==STG_E_INVALIDNAME, "StgOpenStorage wrong error\n");
 427     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, NULL);
 428     ok(r==STG_E_INVALIDPOINTER, "StgOpenStorage wrong error\n");
 429     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 1, &stg);
 430     ok(r==STG_E_INVALIDPARAMETER, "StgOpenStorage wrong error\n");
 431     r = StgOpenStorage( szNonExist, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 432     ok(r==STG_E_FILENOTFOUND, "StgOpenStorage failed\n");
 433     r = StgOpenStorage( filename, NULL, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 434     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 435     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
 436     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 437     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_READ | STGM_READ, NULL, 0, &stg);
 438     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 439     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 440     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 441
 442     /* open it for real */
 443     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg); /* XLViewer 97/2000 */
 444     ok(r==S_OK, "StgOpenStorage failed\n");
 445     if(stg)
 446     {
 447         r = IStorage_Release(stg);
 448         ok(r == 0, "wrong ref count\n");
 449     }
 450
 451     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READ, NULL, 0, &stg);
 452     ok(r==S_OK, "StgOpenStorage failed\n");
 453     if(stg)
 454     {
 455         r = IStorage_Release(stg);
 456         ok(r == 0, "wrong ref count\n");
 457     }
 458
 459     /* test the way word opens its custom dictionary */
 460     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_TRANSACTED |
 461                         STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 462     ok(r==S_OK, "StgOpenStorage failed\n");
 463     if(stg)
 464     {
 465         r = IStorage_Release(stg);
 466         ok(r == 0, "wrong ref count\n");
 467     }
 468
 469     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 470     ok(r==S_OK, "StgOpenStorage failed\n");
 471     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2);
 472     ok(r==STG_E_SHAREVIOLATION, "StgOpenStorage failed\n");
 473     if(stg)
 474     {
 475         r = IStorage_Release(stg);
 476         ok(r == 0, "wrong ref count\n");
 477     }
 478
 479     /* now try write to a storage file we opened read-only */
 480     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 481     ok(r==S_OK, "StgOpenStorage failed\n");
 482     if(stg)
 483     {
 484         static const WCHAR stmname[] =  { 'w','i','n','e','t','e','s','t',0};
 485         IStream *stm = NULL;
 486         IStorage *stg2 = NULL;
 487
 488         r = IStorage_CreateStream( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
 489                                    0, 0, &stm );
 490         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 491         r = IStorage_CreateStorage( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
 492         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 493
 494         r = IStorage_Release(stg);
 495         ok(r == 0, "wrong ref count\n");
 496     }
 497
 498     /* open like visio 2003 */
 499     stg = NULL;
 500     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
 501     ok(r == S_OK, "should succeed\n");
 502     if (stg)
 503         IStorage_Release(stg);
 504
 505     /* test other sharing modes with STGM_PRIORITY */
 506     stg = NULL;
 507     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 508     ok(r == S_OK, "should succeed\n");
 509     if (stg)
 510         IStorage_Release(stg);
 511
 512     stg = NULL;
 513     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 514     ok(r == S_OK, "should succeed\n");
 515     if (stg)
 516         IStorage_Release(stg);
 517
 518     stg = NULL;
 519     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_READ, NULL, 0, &stg);
 520     ok(r == S_OK, "should succeed\n");
 521     if (stg)
 522         IStorage_Release(stg);
 523
 524     /* open like Project 2003 */
 525     stg = NULL;
 526     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg);
 527     ok(r == S_OK, "should succeed\n");
 528     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg2);
 529     ok(r == S_OK, "should succeed\n");
 530     if (stg2)
 531         IStorage_Release(stg2);
 532     if (stg)
 533         IStorage_Release(stg);
 534
 535     stg = NULL;
 536     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_READWRITE, NULL, 0, &stg);
 537     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 538
 539     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_PRIORITY, NULL, 0, &stg);
 540     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 541
 542     r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_PRIORITY, NULL, 0, &stg);
 543     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 544
 545     r = StgOpenStorage( filename, NULL, STGM_DELETEONRELEASE | STGM_PRIORITY, NULL, 0, &stg);
 546     ok(r == STG_E_INVALIDFUNCTION, "should fail\n");
 547
 548     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_PRIORITY, NULL, 0, &stg);
 549     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 550
 551     r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg);
 552     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 553
 554     r = DeleteFileA(filenameA);
 555     ok(r, "file didn't exist\n");
 556 }
 557
 558 static void test_storage_suminfo(void)
 559 {
 560     IStorage *stg = NULL;
 561     IPropertySetStorage *propset = NULL;
 562     IPropertyStorage *ps = NULL;
 563     HRESULT r;
 564
 565     DeleteFileA(filenameA);
 566
 567     /* create the file */
 568     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 569                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 570     ok(r==S_OK, "StgCreateDocfile failed\n");
 571
 572     r = IStorage_QueryInterface( stg, &IID_IPropertySetStorage, (LPVOID) &propset );
 573     ok(r == S_OK, "query interface failed\n");
 574
 575     /* delete it */
 576     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 577     ok(r == STG_E_FILENOTFOUND, "deleted property set storage\n");
 578
 579     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 580                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 581     ok(r == STG_E_FILENOTFOUND, "opened property set storage\n");
 582
 583     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 584                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 585     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 586
 587     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 588                                 STGM_READ, &ps );
 589     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 590
 591     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0, 0, &ps );
 592     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 593
 594     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 595                                 STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 596     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 597
 598     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 599                                 STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 600     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 601
 602     /* now try really creating a property set */
 603     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 604                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 605     ok(r == S_OK, "failed to create property set storage\n");
 606
 607     if( ps )
 608         IPropertyStorage_Release(ps);
 609
 610     /* now try creating the same thing again */
 611     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 612                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 613     ok(r == S_OK, "failed to create property set storage\n");
 614     if( ps )
 615         IPropertyStorage_Release(ps);
 616
 617     /* should be able to open it */
 618     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 619             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 620     ok(r == S_OK, "open failed\n");
 621     if(r == S_OK)
 622         IPropertyStorage_Release(ps);
 623
 624     /* delete it */
 625     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 626     ok(r == S_OK, "failed to delete property set storage\n");
 627
 628     /* try opening with an invalid FMTID */
 629     r = IPropertySetStorage_Open( propset, NULL,
 630             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 631     ok(r == E_INVALIDARG, "open succeeded\n");
 632     if(r == S_OK)
 633         IPropertyStorage_Release(ps);
 634
 635     /* try a bad guid */
 636     r = IPropertySetStorage_Open( propset, &IID_IStorage,
 637             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 638     ok(r == STG_E_FILENOTFOUND, "open succeeded\n");
 639     if(r == S_OK)
 640         IPropertyStorage_Release(ps);
 641
 642
 643     /* try some invalid flags */
 644     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 645             STGM_CREATE | STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 646     ok(r == STG_E_INVALIDFLAG, "open succeeded\n");
 647     if(r == S_OK)
 648         IPropertyStorage_Release(ps);
 649
 650     /* after deleting it, it should be gone */
 651     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 652             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 653     ok(r == STG_E_FILENOTFOUND, "open failed\n");
 654     if(r == S_OK)
 655         IPropertyStorage_Release(ps);
 656
 657     r = IPropertySetStorage_Release( propset );
 658     ok(r == 1, "ref count wrong\n");
 659
 660     r = IStorage_Release(stg);
 661     ok(r == 0, "ref count wrong\n");
 662
 663     DeleteFileA(filenameA);
 664 }
 665
 666 static void test_storage_refcount(void)
 667 {
 668     IStorage *stg = NULL;
 669     IStorage *stgprio = NULL;
 670     HRESULT r;
 671     IStream *stm = NULL;
 672     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 673     LARGE_INTEGER pos;
 674     ULARGE_INTEGER upos;
 675     STATSTG stat;
 676     char buffer[10];
 677
 678     DeleteFileA(filenameA);
 679
 680     /* create the file */
 681     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 682                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 683     ok(r==S_OK, "StgCreateDocfile failed\n");
 684
 685     r = WriteClassStg( stg, &test_stg_cls );
 686     ok( r == S_OK, "WriteClassStg failed\n");
 687
 688     r = IStorage_Commit( stg, STGC_DEFAULT );
 689     ok( r == S_OK, "IStorage_Commit failed\n");
 690
 691     /* now create a stream */
 692     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 693     ok(r==S_OK, "IStorage->CreateStream failed\n");
 694
 695     r = IStorage_Release( stg );
 696     ok (r == 0, "storage not released\n");
 697
 698     pos.QuadPart = 0;
 699     r = IStream_Seek( stm, pos, 0, &upos );
 700     ok (r == STG_E_REVERTED, "seek should fail\n");
 701
 702     r = IStream_Stat( stm, &stat, STATFLAG_DEFAULT );
 703     ok (r == STG_E_REVERTED, "stat should fail\n");
 704
 705     r = IStream_Write( stm, "Test string", strlen("Test string"), NULL);
 706     ok (r == STG_E_REVERTED, "IStream_Write should return STG_E_REVERTED instead of 0x%08x\n", r);
 707
 708     r = IStream_Read( stm, buffer, sizeof(buffer), NULL);
 709     ok (r == STG_E_REVERTED, "IStream_Read should return STG_E_REVERTED instead of 0x%08x\n", r);
 710
 711     r = IStream_Release(stm);
 712     ok (r == 0, "stream not released\n");
 713
 714     /* tests that STGM_PRIORITY doesn't prevent readwrite access from other
 715      * StgOpenStorage calls in transacted mode */
 716     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stgprio);
 717     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
 718
 719     todo_wine {
 720     /* non-transacted mode read/write fails */
 721     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
 722     ok(r==STG_E_LOCKVIOLATION, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08x\n", r);
 723     }
 724
 725     /* non-transacted mode read-only succeeds */
 726     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE|STGM_READ, NULL, 0, &stg);
 727     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
 728     IStorage_Release(stg);
 729
 730     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, NULL, 0, &stg);
 731     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
 732     if(stg)
 733     {
 734         static const WCHAR stgname[] = { ' ',' ',' ','2','9',0 };
 735         static const WCHAR stgname2[] = { 'C','V','_','i','e','w',0 };
 736         static const WCHAR stmname2[] = { 'V','a','r','2','D','a','t','a',0 };
 737         IStorage *stg2;
 738         IStorage *stg3;
 739         STATSTG statstg;
 740
 741         r = IStorage_Stat( stg, &statstg, STATFLAG_NONAME );
 742         ok(r == S_OK, "Stat should have succeded instead of returning 0x%08x\n", r);
 743         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
 744         ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
 745         ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
 746         ok(statstg.grfMode == (STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE),
 747             "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg.grfMode);
 748         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
 749         ok(IsEqualCLSID(&statstg.clsid, &test_stg_cls), "Statstg clsid is not test_stg_cls\n");
 750         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
 751         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
 752
 753         r = IStorage_CreateStorage( stg, stgname, STGM_SHARE_EXCLUSIVE, 0, 0, &stg2 );
 754         ok(r == S_OK, "CreateStorage should have succeeded instead of returning 0x%08x\n", r);
 755
 756         r = IStorage_Stat( stg2, &statstg, STATFLAG_DEFAULT );
 757         ok(r == S_OK, "Stat should have succeded instead of returning 0x%08x\n", r);
 758         ok(!memcmp(statstg.pwcsName, stgname, sizeof(stgname)),
 759             "Statstg pwcsName should have been the name the storage was created with\n");
 760         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
 761         ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
 762         ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
 763         ok(statstg.grfMode == STGM_SHARE_EXCLUSIVE,
 764             "Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%x\n", statstg.grfMode);
 765         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
 766         ok(IsEqualCLSID(&statstg.clsid, &CLSID_NULL), "Statstg clsid is not CLSID_NULL\n");
 767         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
 768         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
 769         CoTaskMemFree(statstg.pwcsName);
 770
 771         r = IStorage_CreateStorage( stg2, stgname2, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stg3 );
 772         ok(r == STG_E_ACCESSDENIED, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
 773
 774         r = IStorage_CreateStream( stg2, stmname2, STGM_CREATE|STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
 775         ok(r == STG_E_ACCESSDENIED, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
 776
 777         IStorage_Release(stg2);
 778
 779         r = IStorage_Release(stg);
 780         ok(r == 0, "wrong ref count\n");
 781     }
 782     IStorage_Release(stgprio);
 783
 784     DeleteFileA(filenameA);
 785 }
 786
 787 static void test_writeclassstg(void)
 788 {
 789     IStorage *stg = NULL;
 790     HRESULT r;
 791     CLSID temp_cls;
 792
 793     DeleteFileA(filenameA);
 794
 795     /* create the file */
 796     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 797                             STGM_READWRITE, 0, &stg);
 798     ok(r==S_OK, "StgCreateDocfile failed\n");
 799
 800     r = ReadClassStg( NULL, NULL );
 801     ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
 802
 803     r = ReadClassStg( stg, NULL );
 804     ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
 805
 806     temp_cls.Data1 = 0xdeadbeef;
 807     r = ReadClassStg( stg, &temp_cls );
 808     ok(r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
 809
 810     ok(IsEqualCLSID(&temp_cls, &CLSID_NULL), "ReadClassStg returned wrong clsid\n");
 811
 812     r = WriteClassStg( NULL, NULL );
 813     ok(r == E_INVALIDARG, "WriteClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
 814
 815     r = WriteClassStg( stg, NULL );
 816     ok(r == STG_E_INVALIDPOINTER, "WriteClassStg should return STG_E_INVALIDPOINTER instead of 0x%08X\n", r);
 817
 818     r = WriteClassStg( stg, &test_stg_cls );
 819     ok( r == S_OK, "WriteClassStg failed with 0x%08X\n", r);
 820
 821     r = ReadClassStg( stg, &temp_cls );
 822     ok( r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
 823     ok(IsEqualCLSID(&temp_cls, &test_stg_cls), "ReadClassStg returned wrong clsid\n");
 824
 825     r = IStorage_Release( stg );
 826     ok (r == 0, "storage not released\n");
 827
 828     DeleteFileA(filenameA);
 829 }
 830
 831 static void test_streamenum(void)
 832 {
 833     IStorage *stg = NULL;
 834     HRESULT r;
 835     IStream *stm = NULL;
 836     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 837     STATSTG stat;
 838     IEnumSTATSTG *ee = NULL;
 839     ULONG count;
 840
 841     DeleteFileA(filenameA);
 842
 843     /* create the file */
 844     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 845                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 846     ok(r==S_OK, "StgCreateDocfile failed\n");
 847
 848     r = WriteClassStg( stg, &test_stg_cls );
 849     ok( r == S_OK, "WriteClassStg failed\n");
 850
 851     r = IStorage_Commit( stg, STGC_DEFAULT );
 852     ok( r == S_OK, "IStorage_Commit failed\n");
 853
 854     /* now create a stream */
 855     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 856     ok(r==S_OK, "IStorage->CreateStream failed\n");
 857
 858     r = IStream_Release(stm);
 859
 860     /* first enum ... should be 1 stream */
 861     r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
 862     ok(r==S_OK, "IStorage->EnumElements failed\n");
 863
 864     count = 0xf00;
 865     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
 866     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
 867     ok(count == 1, "count wrong\n");
 868
 869     r = IEnumSTATSTG_Release(ee);
 870
 871     /* second enum... destroy the stream before reading */
 872     r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
 873     ok(r==S_OK, "IStorage->EnumElements failed\n");
 874
 875     r = IStorage_DestroyElement(stg, stmname);
 876     ok(r==S_OK, "IStorage->EnumElements failed\n");
 877
 878     todo_wine {
 879     count = 0xf00;
 880     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
 881     ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
 882     ok(count == 0, "count wrong\n");
 883     }
 884
 885     /* reset and try again */
 886     r = IEnumSTATSTG_Reset(ee);
 887     ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
 888
 889     count = 0xf00;
 890     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
 891     ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
 892     ok(count == 0, "count wrong\n");
 893
 894     r = IEnumSTATSTG_Release(ee);
 895     ok (r == 0, "enum not released\n");
 896
 897     r = IStorage_Release( stg );
 898     ok (r == 0, "storage not released\n");
 899
 900     DeleteFileA(filenameA);
 901 }
 902
 903 static void test_transact(void)
 904 {
 905     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
 906     HRESULT r;
 907     IStream *stm = NULL;
 908     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 909     static const WCHAR stmname2[] = { 'F','O','O',0 };
 910     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
 911     static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
 912
 913     DeleteFileA(filenameA);
 914
 915     /* create the file */
 916     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 917                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 918     ok(r==S_OK, "StgCreateDocfile failed\n");
 919
 920     /* commit a new stream and storage */
 921     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 922     ok(r==S_OK, "IStorage->CreateStream failed\n");
 923
 924     r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
 925     ok(r==S_OK, "IStream->Write failed\n");
 926
 927     IStream_Release(stm);
 928
 929     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
 930     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
 931
 932     if (r == S_OK)
 933     {
 934         /* Create two substorages but only commit one */
 935         r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
 936         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
 937
 938         if (r == S_OK)
 939             IStorage_Release(stg3);
 940
 941         r = IStorage_Commit(stg, 0);
 942         ok(r==S_OK, "IStorage->Commit failed\n");
 943
 944         r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
 945         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
 946
 947         if (r == S_OK)
 948             IStorage_Release(stg3);
 949
 950         IStorage_Release(stg2);
 951     }
 952
 953     /* now create a stream and storage, but don't commit them */
 954     stm = NULL;
 955     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 956     ok(r==S_OK, "IStorage->CreateStream failed\n");
 957
 958     r = IStream_Write(stm, "this is stream 2\n", 16, NULL);
 959     ok(r==S_OK, "IStream->Write failed\n");
 960
 961     /* IStream::Commit does nothing for OLE storage streams */
 962     r = IStream_Commit(stm, STGC_ONLYIFCURRENT | STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
 963     ok(r==S_OK, "IStream->Commit failed\n");
 964
 965     r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
 966     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
 967
 968     if (r == S_OK)
 969         IStorage_Release(stg2);
 970
 971     IStream_Release(stm);
 972
 973     IStorage_Release(stg);
 974
 975     stm = NULL;
 976     stg = NULL;
 977     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg);
 978     ok(r==S_OK, "StgOpenStorage failed\n");
 979
 980     if (!stg)
 981         return;
 982
 983     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
 984     ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
 985
 986     r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
 987     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
 988
 989     r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
 990     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
 991
 992     r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
 993     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
 994
 995     todo_wine {
 996     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
 997     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
 998     }
 999     if (r == S_OK)
1000         IStream_Release(stm);
1001
1002     todo_wine {
1003     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1004     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1005     }
1006     if (r == S_OK)
1007         IStorage_Release(stg2);
1008
1009     r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1010     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1011
1012     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1013     ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1014     if (r == S_OK)
1015         IStream_Release(stm);
1016
1017     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1018     ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1019     if (r == S_OK)
1020     {
1021         r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1022         ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1023         if (r == S_OK)
1024             IStorage_Release(stg3);
1025
1026         r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1027         todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1028         if (r == S_OK)
1029             IStorage_Release(stg3);
1030
1031         IStorage_Release(stg2);
1032     }
1033
1034     IStorage_Release(stg);
1035
1036     r = DeleteFileA(filenameA);
1037     ok( r == TRUE, "deleted file\n");
1038 }
1039
1040 static void test_substorage_share(void)
1041 {
1042     IStorage *stg, *stg2, *stg3;
1043     IStream *stm, *stm2;
1044     HRESULT r;
1045     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1046     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1047     static const WCHAR othername[] = { 'N','E','W','N','A','M','E',0 };
1048
1049     DeleteFileA(filenameA);
1050
1051     /* create the file */
1052     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1053                             STGM_READWRITE, 0, &stg);
1054     ok(r==S_OK, "StgCreateDocfile failed\n");
1055
1056     /* create a read/write storage and try to open it again */
1057     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1058     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1059
1060     if (r == S_OK)
1061     {
1062         r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1063         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage should fail %08x\n", r);
1064
1065         if (r == S_OK)
1066             IStorage_Release(stg3);
1067
1068         r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1069         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage should fail %08x\n", r);
1070
1071         if (r == S_OK)
1072             IStorage_Release(stg3);
1073
1074         /* cannot rename the storage while it's open */
1075         r = IStorage_RenameElement(stg, stgname, othername);
1076         ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1077         if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stgname);
1078
1079         /* destroying an object while it's open invalidates it */
1080         r = IStorage_DestroyElement(stg, stgname);
1081         ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1082
1083         r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1084         ok(r==STG_E_REVERTED, "IStorage->CreateStream failed, hr=%08x\n", r);
1085
1086         if (r == S_OK)
1087             IStorage_Release(stm);
1088
1089         IStorage_Release(stg2);
1090     }
1091
1092     /* create a read/write stream and try to open it again */
1093     r = IStorage_CreateStream(stg, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1094     ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
1095
1096     if (r == S_OK)
1097     {
1098         r = IStorage_OpenStream(stg, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1099         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1100
1101         if (r == S_OK)
1102             IStorage_Release(stm2);
1103
1104         r = IStorage_OpenStream(stg, stmname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1105         ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1106
1107         if (r == S_OK)
1108             IStorage_Release(stm2);
1109
1110         /* cannot rename the stream while it's open */
1111         r = IStorage_RenameElement(stg, stmname, othername);
1112         ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1113         if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stmname);
1114
1115         /* destroying an object while it's open invalidates it */
1116         r = IStorage_DestroyElement(stg, stmname);
1117         ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1118
1119         r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1120         ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1121
1122         IStorage_Release(stm);
1123     }
1124
1125     IStorage_Release(stg);
1126
1127     r = DeleteFileA(filenameA);
1128     ok( r == TRUE, "deleted file\n");
1129 }
1130
1131 static void test_revert(void)
1132 {
1133     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1134     HRESULT r;
1135     IStream *stm = NULL, *stm2 = NULL;
1136     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1137     static const WCHAR stmname2[] = { 'F','O','O',0 };
1138     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1139     static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
1140     STATSTG statstg;
1141
1142     DeleteFileA(filenameA);
1143
1144     /* create the file */
1145     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1146                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1147     ok(r==S_OK, "StgCreateDocfile failed\n");
1148
1149     /* commit a new stream and storage */
1150     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1151     ok(r==S_OK, "IStorage->CreateStream failed\n");
1152
1153     r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
1154     ok(r==S_OK, "IStream->Write failed\n");
1155
1156     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1157     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1158
1159     if (r == S_OK)
1160     {
1161         /* Create two substorages but only commit one */
1162         r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1163         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1164
1165         if (r == S_OK)
1166             IStorage_Release(stg3);
1167
1168         r = IStorage_Commit(stg, 0);
1169         ok(r==S_OK, "IStorage->Commit failed\n");
1170
1171         r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1172         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1173
1174         if (r == S_OK)
1175             IStorage_Release(stg3);
1176     }
1177
1178     /* now create a stream and storage, then revert */
1179     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
1180     ok(r==S_OK, "IStorage->CreateStream failed\n");
1181
1182     r = IStream_Write(stm2, "this is stream 2\n", 16, NULL);
1183     ok(r==S_OK, "IStream->Write failed\n");
1184
1185     r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1186     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1187
1188     r = IStorage_Revert(stg);
1189
1190     /* all open objects become invalid */
1191     todo_wine {
1192     r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1193     ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1194
1195     r = IStream_Write(stm2, "this shouldn't work\n", 20, NULL);
1196     ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1197
1198     r = IStorage_Stat(stg2, &statstg, STATFLAG_NONAME);
1199     ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1200
1201     r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
1202     ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1203     }
1204
1205     IStream_Release(stm);
1206     IStream_Release(stm2);
1207     IStorage_Release(stg2);
1208     IStorage_Release(stg3);
1209
1210     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
1211     ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
1212
1213     r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1214     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1215
1216     r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1217     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1218
1219     r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1220     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1221
1222     todo_wine {
1223     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1224     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1225     }
1226     if (r == S_OK)
1227         IStream_Release(stm);
1228
1229     todo_wine {
1230     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1231     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1232     }
1233     if (r == S_OK)
1234         IStorage_Release(stg2);
1235
1236     r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1237     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1238
1239     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1240     ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1241     if (r == S_OK)
1242         IStream_Release(stm);
1243
1244     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1245     ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1246     if (r == S_OK)
1247     {
1248         r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1249         ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1250         if (r == S_OK)
1251             IStorage_Release(stg3);
1252
1253         r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1254         todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1255         if (r == S_OK)
1256             IStorage_Release(stg3);
1257
1258         IStorage_Release(stg2);
1259     }
1260
1261     IStorage_Release(stg);
1262
1263     r = DeleteFileA(filenameA);
1264     ok( r == TRUE, "deleted file\n");
1265
1266     /* Revert only invalidates objects in transacted mode */
1267     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1268                             STGM_READWRITE, 0, &stg);
1269     ok(r==S_OK, "StgCreateDocfile failed\n");
1270
1271     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1272     ok(r==S_OK, "IStorage->CreateStream failed\n");
1273
1274     r = IStorage_Revert(stg);
1275     todo_wine ok(r==S_OK, "IStorage->Revert failed %08x\n", r);
1276
1277     r = IStream_Write(stm, "this works\n", 11, NULL);
1278     ok(r==S_OK, "IStream_Write should succeed %08x\n", r);
1279
1280     IStream_Release(stm);
1281     IStream_Release(stg);
1282
1283     r = DeleteFileA(filenameA);
1284     ok( r == TRUE, "deleted file\n");
1285 }
1286
1287 static void test_parent_free(void)
1288 {
1289     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1290     HRESULT r;
1291     IStream *stm = NULL;
1292     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1293     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1294     ULONG ref;
1295     STATSTG statstg;
1296
1297     DeleteFileA(filenameA);
1298
1299     /* create the file */
1300     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1301                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1302     ok(r==S_OK, "StgCreateDocfile failed\n");
1303
1304     /* create a new storage */
1305     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1306     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1307
1308     if (r == S_OK)
1309     {
1310         /* now create a stream inside the new storage */
1311         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1312         ok(r==S_OK, "IStorage->CreateStream failed\n");
1313
1314         if (r == S_OK)
1315         {
1316             /* create a storage inside the new storage */
1317             r = IStorage_CreateStorage(stg2, stgname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg3 );
1318             ok(r==S_OK, "IStorage->CreateStorage failed\n");
1319         }
1320
1321         /* free the parent */
1322         ref = IStorage_Release(stg2);
1323         ok(ref == 0, "IStorage still has %u references\n", ref);
1324
1325         /* child objects are invalid */
1326         if (r == S_OK)
1327         {
1328             r = IStream_Write(stm, "this should fail\n", 17, NULL);
1329             ok(r==STG_E_REVERTED, "IStream->Write sould fail, hr=%x\n", r);
1330
1331             IStream_Release(stm);
1332
1333             r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
1334             ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1335
1336             r = IStorage_SetStateBits(stg3, 1, 1);
1337             ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1338
1339             IStorage_Release(stg3);
1340         }
1341     }
1342
1343     IStorage_Release(stg);
1344
1345     r = DeleteFileA(filenameA);
1346     ok( r == TRUE, "deleted file\n");
1347 }
1348
1349 static void test_nonroot_transacted(void)
1350 {
1351     IStorage *stg = NULL, *stg2 = NULL;
1352     HRESULT r;
1353     IStream *stm = NULL;
1354     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1355     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1356     static const WCHAR stmname2[] = { 'F','O','O',0 };
1357
1358     DeleteFileA(filenameA);
1359
1360     /* create a transacted file */
1361     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1362                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1363     ok(r==S_OK, "StgCreateDocfile failed\n");
1364
1365     /* create a transacted substorage */
1366     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1367     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1368
1369     if (r == S_OK)
1370     {
1371         /* create and commit stmname */
1372         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1373         ok(r==S_OK, "IStorage->CreateStream failed\n");
1374         if (r == S_OK)
1375             IStream_Release(stm);
1376
1377         IStorage_Commit(stg2, 0);
1378
1379         /* create and revert stmname2 */
1380         r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1381         ok(r==S_OK, "IStorage->CreateStream failed\n");
1382         if (r == S_OK)
1383             IStream_Release(stm);
1384
1385         IStorage_Revert(stg2);
1386
1387         /* check that Commit and Revert really worked */
1388         r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1389         ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1390         if (r == S_OK)
1391             IStream_Release(stm);
1392
1393         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1394         todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1395         if (r == S_OK)
1396             IStream_Release(stm);
1397
1398         IStorage_Release(stg2);
1399     }
1400
1401     IStream_Release(stg);
1402
1403     /* create a non-transacted file */
1404     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1405                             STGM_READWRITE, 0, &stg);
1406     ok(r==S_OK, "StgCreateDocfile failed\n");
1407
1408     /* create a transacted substorage */
1409     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1410     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1411
1412     if (r == S_OK)
1413     {
1414         /* create and commit stmname */
1415         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1416         ok(r==S_OK, "IStorage->CreateStream failed\n");
1417         if (r == S_OK)
1418             IStream_Release(stm);
1419
1420         IStorage_Commit(stg2, 0);
1421
1422         /* create and revert stmname2 */
1423         r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1424         ok(r==S_OK, "IStorage->CreateStream failed\n");
1425         if (r == S_OK)
1426             IStream_Release(stm);
1427
1428         IStorage_Revert(stg2);
1429
1430         /* check that Commit and Revert really worked */
1431         r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1432         ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1433         if (r == S_OK)
1434             IStream_Release(stm);
1435
1436         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1437         todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1438         if (r == S_OK)
1439             IStream_Release(stm);
1440
1441         IStorage_Release(stg2);
1442     }
1443
1444     IStream_Release(stg);
1445
1446     r = DeleteFileA(filenameA);
1447     ok( r == TRUE, "deleted file\n");
1448 }
1449
1450 static void test_ReadClassStm(void)
1451 {
1452     CLSID clsid;
1453     HRESULT hr;
1454     IStream *pStream;
1455     static const LARGE_INTEGER llZero;
1456
1457     hr = ReadClassStm(NULL, &clsid);
1458     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1459
1460     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1461     ok_ole_success(hr, "CreateStreamOnHGlobal");
1462     hr = WriteClassStm(pStream, &test_stg_cls);
1463     ok_ole_success(hr, "WriteClassStm");
1464
1465     hr = ReadClassStm(pStream, NULL);
1466     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1467
1468     /* test not rewound stream */
1469     hr = ReadClassStm(pStream, &clsid);
1470     ok(hr == STG_E_READFAULT, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
1471     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid should have been zeroed\n");
1472
1473     hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
1474     ok_ole_success(hr, "IStream_Seek");
1475     hr = ReadClassStm(pStream, &clsid);
1476     ok_ole_success(hr, "ReadClassStm");
1477     ok(IsEqualCLSID(&clsid, &test_stg_cls), "clsid should have been set to CLSID_WineTest\n");
1478 }
1479
1480 struct access_res
1481 {
1482     BOOL gothandle;
1483     DWORD lasterr;
1484     BOOL ignore;
1485 };
1486
1487 static const struct access_res create[16] =
1488 {
1489     { TRUE, ERROR_SUCCESS, TRUE },
1490     { TRUE, ERROR_SUCCESS, TRUE },
1491     { TRUE, ERROR_SUCCESS, FALSE },
1492     { TRUE, ERROR_SUCCESS, FALSE },
1493     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1494     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1495     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1496     { TRUE, ERROR_SUCCESS, FALSE },
1497     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1498     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1499     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1500     { TRUE, ERROR_SUCCESS, TRUE },
1501     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1502     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1503     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1504     { TRUE, ERROR_SUCCESS, TRUE }
1505 };
1506
1507 static const struct access_res create_commit[16] =
1508 {
1509     { TRUE, ERROR_SUCCESS, TRUE },
1510     { TRUE, ERROR_SUCCESS, TRUE },
1511     { TRUE, ERROR_SUCCESS, FALSE },
1512     { TRUE, ERROR_SUCCESS, FALSE },
1513     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1514     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1515     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1516     { TRUE, ERROR_SUCCESS, FALSE },
1517     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1518     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1519     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1520     { TRUE, ERROR_SUCCESS, TRUE },
1521     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1522     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1523     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1524     { TRUE, ERROR_SUCCESS, TRUE }
1525 };
1526
1527 static const struct access_res create_close[16] =
1528 {
1529     { TRUE, ERROR_SUCCESS, FALSE },
1530     { TRUE, ERROR_SUCCESS, FALSE },
1531     { TRUE, ERROR_SUCCESS, FALSE },
1532     { TRUE, ERROR_SUCCESS, FALSE },
1533     { TRUE, ERROR_SUCCESS, FALSE },
1534     { TRUE, ERROR_SUCCESS, FALSE },
1535     { TRUE, ERROR_SUCCESS, FALSE },
1536     { TRUE, ERROR_SUCCESS, FALSE },
1537     { TRUE, ERROR_SUCCESS, FALSE },
1538     { TRUE, ERROR_SUCCESS, FALSE },
1539     { TRUE, ERROR_SUCCESS, FALSE },
1540     { TRUE, ERROR_SUCCESS, FALSE },
1541     { TRUE, ERROR_SUCCESS, FALSE },
1542     { TRUE, ERROR_SUCCESS, FALSE },
1543     { TRUE, ERROR_SUCCESS, FALSE },
1544     { TRUE, ERROR_SUCCESS }
1545 };
1546
1547 static void _test_file_access(LPCSTR file, const struct access_res *ares, DWORD line)
1548 {
1549     DWORD access = 0, share = 0;
1550     DWORD lasterr;
1551     HANDLE hfile;
1552     int i, j, idx = 0;
1553
1554     for (i = 0; i < 4; i++)
1555     {
1556         if (i == 0) access = 0;
1557         if (i == 1) access = GENERIC_READ;
1558         if (i == 2) access = GENERIC_WRITE;
1559         if (i == 3) access = GENERIC_READ | GENERIC_WRITE;
1560
1561         for (j = 0; j < 4; j++)
1562         {
1563             if (ares[idx].ignore)
1564                 continue;
1565
1566             if (j == 0) share = 0;
1567             if (j == 1) share = FILE_SHARE_READ;
1568             if (j == 2) share = FILE_SHARE_WRITE;
1569             if (j == 3) share = FILE_SHARE_READ | FILE_SHARE_WRITE;
1570
1571             SetLastError(0xdeadbeef);
1572             hfile = CreateFileA(file, access, share, NULL, OPEN_EXISTING,
1573                                 FILE_ATTRIBUTE_NORMAL, 0);
1574             lasterr = GetLastError();
1575
1576             ok((hfile != INVALID_HANDLE_VALUE) == ares[idx].gothandle,
1577                "(%d, handle, %d): Expected %d, got %d\n",
1578                line, idx, ares[idx].gothandle,
1579                (hfile != INVALID_HANDLE_VALUE));
1580
1581             ok(lasterr == ares[idx].lasterr ||
1582                broken(lasterr == 0xdeadbeef) /* win9x */,
1583                "(%d, lasterr, %d): Expected %d, got %d\n",
1584                line, idx, ares[idx].lasterr, lasterr);
1585
1586             CloseHandle(hfile);
1587             idx++;
1588         }
1589     }
1590 }
1591
1592 #define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
1593
1594 static void test_access(void)
1595 {
1596     IStorage *stg;
1597     HRESULT hr;
1598
1599     static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1600
1601     /* STGM_TRANSACTED */
1602
1603     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1604                           STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, &stg);
1605     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1606
1607     test_file_access("winetest", create);
1608
1609     hr = IStorage_Commit(stg, STGC_DEFAULT);
1610     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1611
1612     test_file_access("winetest", create_commit);
1613
1614     IStorage_Release(stg);
1615
1616     test_file_access("winetest", create_close);
1617
1618     DeleteFileA("winetest");
1619
1620     /* STGM_DIRECT */
1621
1622     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1623                           STGM_SHARE_EXCLUSIVE | STGM_DIRECT, 0, &stg);
1624     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1625
1626     test_file_access("winetest", create);
1627
1628     hr = IStorage_Commit(stg, STGC_DEFAULT);
1629     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1630
1631     test_file_access("winetest", create_commit);
1632
1633     IStorage_Release(stg);
1634
1635     test_file_access("winetest", create_close);
1636
1637     DeleteFileA("winetest");
1638
1639     /* STGM_SHARE_DENY_NONE */
1640
1641     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1642                           STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
1643     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1644
1645     test_file_access("winetest", create);
1646
1647     hr = IStorage_Commit(stg, STGC_DEFAULT);
1648     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1649
1650     test_file_access("winetest", create_commit);
1651
1652     IStorage_Release(stg);
1653
1654     test_file_access("winetest", create_close);
1655
1656     DeleteFileA("winetest");
1657
1658     /* STGM_SHARE_DENY_READ */
1659
1660     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1661                           STGM_SHARE_DENY_READ | STGM_TRANSACTED, 0, &stg);
1662     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1663
1664     test_file_access("winetest", create);
1665
1666     hr = IStorage_Commit(stg, STGC_DEFAULT);
1667     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1668
1669     test_file_access("winetest", create_commit);
1670
1671     IStorage_Release(stg);
1672
1673     test_file_access("winetest", create_close);
1674
1675     DeleteFileA("winetest");
1676
1677     /* STGM_SHARE_DENY_WRITE */
1678
1679     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1680                           STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
1681     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1682
1683     test_file_access("winetest", create);
1684
1685     hr = IStorage_Commit(stg, STGC_DEFAULT);
1686     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1687
1688     test_file_access("winetest", create_commit);
1689
1690     IStorage_Release(stg);
1691
1692     test_file_access("winetest", create_close);
1693
1694     DeleteFileA("winetest");
1695 }
1696
1697 static void test_readonly(void)
1698 {
1699     IStorage *stg, *stg2, *stg3;
1700     IStream *stream;
1701     HRESULT hr;
1702     static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1703     static const WCHAR storageW[] = {'s','t','o','r','a','g','e',0};
1704     static const WCHAR streamW[] = {'s','t','r','e','a','m',0};
1705
1706     hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1707     ok(hr == S_OK, "should succeed, res=%x\n", hr);
1708     if (SUCCEEDED(hr))
1709     {
1710         hr = IStorage_CreateStorage( stg, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2 );
1711         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1712         if (SUCCEEDED(hr))
1713         {
1714             hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stream );
1715             ok(hr == S_OK, "should succeed, res=%x\n", hr);
1716             if (SUCCEEDED(hr))
1717                 IStream_Release(stream);
1718             IStorage_Release(stg2);
1719         }
1720         IStorage_Release(stg);
1721     }
1722
1723     /* re-open read only */
1724     hr = StgOpenStorage( fileW, NULL, STGM_TRANSACTED | STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
1725     ok(hr == S_OK, "should succeed, res=%x\n", hr);
1726     if (SUCCEEDED(hr))
1727     {
1728         hr = IStorage_OpenStorage( stg, storageW, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2 );
1729         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1730         if (SUCCEEDED(hr))
1731         {
1732             /* CreateStream on read-only storage, name exists */
1733             hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1734             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1735             if (SUCCEEDED(hr))
1736                 IStream_Release(stream);
1737
1738             /* CreateStream on read-only storage, name does not exist */
1739             hr = IStorage_CreateStream( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1740             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1741             if (SUCCEEDED(hr))
1742                 IStream_Release(stream);
1743
1744             /* CreateStorage on read-only storage, name exists */
1745             hr = IStorage_CreateStorage( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1746             ok(hr == STG_E_FILEALREADYEXISTS, "should fail, res=%x\n", hr);
1747             if (SUCCEEDED(hr))
1748                 IStream_Release(stg3);
1749
1750             /* CreateStorage on read-only storage, name does not exist */
1751             hr = IStorage_CreateStorage( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1752             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1753             if (SUCCEEDED(hr))
1754                 IStream_Release(stg3);
1755
1756             /* DestroyElement on read-only storage, name exists */
1757             hr = IStorage_DestroyElement( stg2, streamW );
1758             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1759
1760             /* DestroyElement on read-only storage, name does not exist */
1761             hr = IStorage_DestroyElement( stg2, storageW );
1762             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1763
1764             IStorage_Release(stg2);
1765         }
1766
1767         IStorage_Release(stg);
1768     }
1769
1770     DeleteFileA("winetest");
1771 }
1772
1773 static void test_simple(void)
1774 {
1775     /* Tests for STGM_SIMPLE mode */
1776
1777     IStorage *stg, *stg2;
1778     HRESULT r;
1779     IStream *stm;
1780     static const WCHAR stgname[] = { 'S','t','g',0 };
1781     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1782     static const WCHAR stmname2[] = { 'S','m','a','l','l',0 };
1783     LARGE_INTEGER pos;
1784     ULARGE_INTEGER upos;
1785     DWORD count;
1786     STATSTG stat;
1787
1788     DeleteFileA(filenameA);
1789
1790     r = StgCreateDocfile( filename, STGM_SIMPLE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1791     ok(r == S_OK, "got %08x\n", r);
1792
1793     r = IStorage_CreateStorage(stg, stgname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2);
1794     ok(r == STG_E_INVALIDFUNCTION, "got %08x\n", r);
1795     if (SUCCEEDED(r)) IStorage_Release(stg2);
1796
1797     r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1798     ok(r == STG_E_INVALIDFLAG, "got %08x\n", r);
1799     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1800     ok(r == S_OK, "got %08x\n", r);
1801
1802     upos.QuadPart = 6000;
1803     r = IStream_SetSize(stm, upos);
1804     ok(r == S_OK, "got %08x\n", r);
1805
1806     r = IStream_Write(stm, "foo", 3, &count);
1807     ok(r == S_OK, "got %08x\n", r);
1808     ok(count == 3, "got %d\n", count);
1809
1810     pos.QuadPart = 0;
1811     r = IStream_Seek(stm, pos, STREAM_SEEK_CUR, &upos);
1812     ok(r == S_OK, "got %08x\n", r);
1813     ok(upos.QuadPart == 3, "got %d\n", upos.u.LowPart);
1814
1815     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1816     ok(r == S_OK ||
1817        broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1818        "got %08x\n", r);
1819     if (r == S_OK)
1820         ok(stat.cbSize.QuadPart == 3, "got %d\n", stat.cbSize.u.LowPart);
1821
1822     pos.QuadPart = 1;
1823     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
1824     ok(r == S_OK, "got %08x\n", r);
1825     ok(upos.QuadPart == 1, "got %d\n", upos.u.LowPart);
1826
1827     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1828     ok(r == S_OK ||
1829        broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1830        "got %08x\n", r);
1831     if (r == S_OK)
1832         ok(stat.cbSize.QuadPart == 1, "got %d\n", stat.cbSize.u.LowPart);
1833
1834     IStream_Release(stm);
1835
1836     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1837     ok(r == S_OK, "got %08x\n", r);
1838
1839     upos.QuadPart = 100;
1840     r = IStream_SetSize(stm, upos);
1841     ok(r == S_OK, "got %08x\n", r);
1842
1843     r = IStream_Write(stm, "foo", 3, &count);
1844     ok(r == S_OK, "got %08x\n", r);
1845     ok(count == 3, "got %d\n", count);
1846
1847     IStream_Release(stm);
1848
1849     IStorage_Commit(stg, STGC_DEFAULT);
1850     IStorage_Release(stg);
1851
1852     r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
1853     if (r == STG_E_INVALIDFLAG)
1854     {
1855         win_skip("Flag combination is not supported on NT4 and below\n");
1856         DeleteFileA(filenameA);
1857         return;
1858     }
1859     ok(r == S_OK, "got %08x\n", r);
1860
1861     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg2);
1862     ok(r == STG_E_INVALIDFUNCTION, "got %08x\n", r);
1863     if (SUCCEEDED(r)) IStorage_Release(stg2);
1864
1865     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1866     ok(r == S_OK, "got %08x\n", r);
1867
1868     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1869     ok(r == S_OK, "got %08x\n", r);
1870     ok(stat.cbSize.QuadPart == 6000, "got %d\n", stat.cbSize.u.LowPart);
1871
1872     IStream_Release(stm);
1873
1874     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1875     ok(r == S_OK, "got %08x\n", r);
1876
1877     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1878     ok(r == S_OK, "got %08x\n", r);
1879     ok(stat.cbSize.QuadPart == 4096, "got %d\n", stat.cbSize.u.LowPart);
1880
1881     IStream_Release(stm);
1882
1883
1884     IStorage_Release(stg);
1885
1886     DeleteFileA(filenameA);
1887 }
1888
1889 static void test_fmtusertypestg(void)
1890 {
1891     IStorage *stg;
1892     IEnumSTATSTG *stat;
1893     HRESULT hr;
1894     static const WCHAR fileW[] = {'f','m','t','t','e','s','t',0};
1895     static WCHAR userTypeW[] = {'S','t','g','U','s','r','T','y','p','e',0};
1896     static WCHAR strmNameW[] = {1,'C','o','m','p','O','b','j',0};
1897
1898     hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1899     ok(hr == S_OK, "should succeed, res=%x\n", hr);
1900
1901     if (SUCCEEDED(hr))
1902     {
1903         /* try to write the stream */
1904         hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1905         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1906
1907         /* check that the stream was created */
1908         hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1909         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1910         if (SUCCEEDED(hr))
1911         {
1912             BOOL found = FALSE;
1913             STATSTG statstg;
1914             DWORD got;
1915             while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1916             {
1917                 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1918                     found = TRUE;
1919                 else
1920                     ok(0, "found unexpected stream or storage\n");
1921             }
1922             ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1923             IEnumSTATSTG_Release(stat);
1924         }
1925
1926         /* re-write the stream */
1927         hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1928         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1929
1930         /* check that the stream is still there */
1931         hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1932         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1933         if (SUCCEEDED(hr))
1934         {
1935             BOOL found = FALSE;
1936             STATSTG statstg;
1937             DWORD got;
1938             while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1939             {
1940                 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1941                     found = TRUE;
1942                 else
1943                     ok(0, "found unexpected stream or storage\n");
1944             }
1945             ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1946             IEnumSTATSTG_Release(stat);
1947         }
1948
1949         IStorage_Release(stg);
1950         DeleteFileW( fileW );
1951     }
1952 }
1953
1954 static void test_references(void)
1955 {
1956     IStorage *stg,*stg2;
1957     HRESULT hr;
1958     unsigned c1,c2;
1959     static const WCHAR StorName[] = { 'D','a','t','a','S','p','a','c','e','I','n','f','o',0 };
1960
1961     DeleteFileA(filenameA);
1962
1963     hr = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1964     ok(hr==S_OK, "StgCreateDocfile failed\n");
1965
1966     if (SUCCEEDED(hr))
1967     {
1968         IStorage_Release(stg);
1969
1970         hr = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
1971         ok(hr==S_OK, "StgOpenStorage failed (result=%x)\n",hr);
1972
1973         if (SUCCEEDED(hr))
1974         {
1975             hr = IStorage_CreateStorage(stg,StorName,STGM_READWRITE | STGM_SHARE_EXCLUSIVE,0,0,&stg2);
1976             ok(hr == S_OK, "IStorage_CreateStorage failed (result=%x)\n",hr);
1977
1978             if (SUCCEEDED(hr))
1979             {
1980                 c1 = IStorage_AddRef(stg);
1981                 ok(c1 == 2, "creating internal storage added references to ancestor\n");
1982                 c1 = IStorage_AddRef(stg);
1983                 IStorage_Release(stg2);
1984                 c2 = IStorage_AddRef(stg) - 1;
1985                 ok(c1 == c2, "releasing internal storage removed references to ancestor\n");
1986             }
1987             c1 = IStorage_Release(stg);
1988             while ( c1 ) c1 = IStorage_Release(stg);
1989         }
1990     }
1991
1992     DeleteFileA(filenameA);
1993 }
1994
1995 /* dest
1996  *  |-StorageA
1997  *  |  `StreamA: "StreamA"
1998  *  |-StorageB
1999  *  |  `StreamB: "StreamB"
2000  *  `StreamC: "StreamC"
2001  */
2002 static HRESULT create_test_file(IStorage *dest)
2003 {
2004     IStorage *stgA = NULL, *stgB = NULL;
2005     IStream *strmA = NULL, *strmB = NULL, *strmC = NULL;
2006     const ULONG strmA_name_size = lstrlenW(strmA_name) * sizeof(WCHAR);
2007     const ULONG strmB_name_size = lstrlenW(strmB_name) * sizeof(WCHAR);
2008     const ULONG strmC_name_size = lstrlenW(strmC_name) * sizeof(WCHAR);
2009     ULONG bytes;
2010     HRESULT hr;
2011
2012     hr = IStorage_CreateStorage(dest, stgA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgA);
2013     ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
2014     if(FAILED(hr))
2015         goto cleanup;
2016
2017     hr = IStorage_CreateStream(stgA, strmA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmA);
2018     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2019     if(FAILED(hr))
2020         goto cleanup;
2021
2022     hr = IStream_Write(strmA, strmA_name, strmA_name_size, &bytes);
2023     ok(hr == S_OK && bytes == strmA_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmA_name_size);
2024
2025     hr = IStorage_CreateStorage(dest, stgB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgB);
2026     ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
2027     if(FAILED(hr))
2028         goto cleanup;
2029
2030     hr = IStorage_CreateStream(stgB, strmB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmB);
2031     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2032     if(FAILED(hr))
2033         goto cleanup;
2034
2035     hr = IStream_Write(strmB, strmB_name, strmB_name_size, &bytes);
2036     ok(hr == S_OK && bytes == strmB_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmB_name_size);
2037
2038     hr = IStorage_CreateStream(dest, strmC_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmC);
2039     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2040     if(FAILED(hr))
2041         goto cleanup;
2042
2043     hr = IStream_Write(strmC, strmC_name, strmC_name_size, &bytes);
2044     ok(hr == S_OK && bytes == strmC_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmC_name_size);
2045
2046 cleanup:
2047     if(strmC)
2048         IStream_Release(strmC);
2049     if(strmB)
2050         IStream_Release(strmB);
2051     if(stgB)
2052         IStorage_Release(stgB);
2053     if(strmA)
2054         IStream_Release(strmA);
2055     if(stgA)
2056         IStorage_Release(stgA);
2057
2058     return hr;
2059 }
2060
2061 static void test_copyto(void)
2062 {
2063     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2064     IStream *strm_tmp;
2065     WCHAR buf[64];
2066     HRESULT hr;
2067
2068     /* create & populate file1 */
2069     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2070     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2071     if(FAILED(hr))
2072         goto cleanup;
2073
2074     hr = create_test_file(file1);
2075     if(FAILED(hr))
2076         goto cleanup;
2077
2078     /* create file2 */
2079     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2080     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2081     if(FAILED(hr))
2082         goto cleanup;
2083
2084     /* copy file1 into file2 */
2085     hr = IStorage_CopyTo(file1, 0, NULL, NULL, NULL);
2086     ok(hr == STG_E_INVALIDPOINTER, "CopyTo should give STG_E_INVALIDPONITER, gave: 0x%08x\n", hr);
2087
2088     hr = IStorage_CopyTo(file1, 0, NULL, NULL, file2);
2089     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2090     if(FAILED(hr))
2091         goto cleanup;
2092
2093     /* verify that all of file1 was copied */
2094     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2095             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2096     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2097
2098     if(SUCCEEDED(hr)){
2099         hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2100                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2101         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2102
2103         if(SUCCEEDED(hr)){
2104             memset(buf, 0, sizeof(buf));
2105             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2106             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2107             if(SUCCEEDED(hr))
2108                 ok(lstrcmpW(buf, strmA_name) == 0,
2109                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmA_name), wine_dbgstr_w(buf));
2110
2111             IStream_Release(strm_tmp);
2112         }
2113
2114         IStorage_Release(stg_tmp);
2115     }
2116
2117     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2118             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2119     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2120
2121     if(SUCCEEDED(hr)){
2122         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2123                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2124         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2125
2126         if(SUCCEEDED(hr)){
2127             memset(buf, 0, sizeof(buf));
2128             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2129             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2130             if(SUCCEEDED(hr))
2131                 ok(lstrcmpW(buf, strmB_name) == 0,
2132                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2133
2134             IStream_Release(strm_tmp);
2135         }
2136
2137         IStorage_Release(stg_tmp);
2138     }
2139
2140     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2141             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2142     ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2143
2144     if(SUCCEEDED(hr)){
2145         memset(buf, 0, sizeof(buf));
2146         hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2147         ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2148         if(SUCCEEDED(hr))
2149             ok(lstrcmpW(buf, strmC_name) == 0,
2150                     "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2151
2152         IStream_Release(strm_tmp);
2153     }
2154
2155 cleanup:
2156     if(file1)
2157         IStorage_Release(file1);
2158     if(file2)
2159         IStorage_Release(file2);
2160
2161     DeleteFileW(file1_name);
2162     DeleteFileW(file2_name);
2163 }
2164
2165 static void test_copyto_snbexclusions(void)
2166 {
2167     static const WCHAR *snb_exclude[] = {stgA_name, strmB_name, strmC_name, 0};
2168
2169     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2170     IStream *strm_tmp;
2171     WCHAR buf[64];
2172     HRESULT hr;
2173
2174     /* create & populate file1 */
2175     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2176     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2177     if(FAILED(hr))
2178         goto cleanup;
2179
2180     hr = create_test_file(file1);
2181     if(FAILED(hr))
2182         goto cleanup;
2183
2184     /* create file2 */
2185     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2186     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2187     if(FAILED(hr))
2188         goto cleanup;
2189
2190     /* copy file1 to file2 with name exclusions */
2191     hr = IStorage_CopyTo(file1, 0, NULL, (SNB)snb_exclude, file2);
2192     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2193     if(FAILED(hr))
2194         goto cleanup;
2195
2196     /* verify that file1 copied over, respecting exclusions */
2197     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2198             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2199     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2200     if(SUCCEEDED(hr))
2201         IStorage_Release(stg_tmp);
2202
2203     hr = IStorage_OpenStream(file2, strmA_name, NULL,
2204             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2205     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2206     if(SUCCEEDED(hr))
2207         IStream_Release(strm_tmp);
2208
2209     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2210             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2211     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2212
2213     if(SUCCEEDED(hr)){
2214         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2215                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2216         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2217
2218         if(SUCCEEDED(hr)){
2219             memset(buf, 0, sizeof(buf));
2220             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2221             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2222             if(SUCCEEDED(hr))
2223                 ok(lstrcmpW(buf, strmB_name) == 0,
2224                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2225
2226             IStream_Release(strm_tmp);
2227         }
2228
2229         IStorage_Release(stg_tmp);
2230     }
2231
2232     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2233             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2234     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2235     if(SUCCEEDED(hr))
2236         IStream_Release(strm_tmp);
2237
2238 cleanup:
2239     if(file1)
2240         IStorage_Release(file1);
2241     if(file2)
2242         IStorage_Release(file2);
2243
2244     DeleteFileW(file1_name);
2245     DeleteFileW(file2_name);
2246 }
2247
2248 static void test_copyto_iidexclusions_storage(void)
2249 {
2250     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2251     IStream *strm_tmp;
2252     WCHAR buf[64];
2253     HRESULT hr;
2254
2255     /* create & populate file1 */
2256     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2257     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2258     if(FAILED(hr))
2259         goto cleanup;
2260
2261     hr = create_test_file(file1);
2262     if(FAILED(hr))
2263         goto cleanup;
2264
2265     /* create file2 */
2266     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2267     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2268     if(FAILED(hr))
2269         goto cleanup;
2270
2271     /* copy file1 to file2 with iid exclusions */
2272     hr = IStorage_CopyTo(file1, 1, &IID_IStorage, NULL, file2);
2273     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2274     if(FAILED(hr))
2275         goto cleanup;
2276
2277     /* verify that file1 copied over, respecting exclusions */
2278     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2279             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2280     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2281     if(SUCCEEDED(hr))
2282         IStorage_Release(stg_tmp);
2283
2284     hr = IStorage_OpenStream(file2, strmA_name, NULL,
2285             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2286     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2287     if(SUCCEEDED(hr))
2288         IStream_Release(strm_tmp);
2289
2290     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2291             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2292     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2293     if(SUCCEEDED(hr))
2294         IStorage_Release(stg_tmp);
2295
2296     hr = IStorage_OpenStream(file2, strmB_name, NULL,
2297             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2298     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2299     if(SUCCEEDED(hr))
2300         IStream_Release(strm_tmp);
2301
2302     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2303             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2304     ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2305
2306     if(SUCCEEDED(hr)){
2307         memset(buf, 0, sizeof(buf));
2308         hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2309         ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2310         if(SUCCEEDED(hr))
2311             ok(lstrcmpW(buf, strmC_name) == 0,
2312                     "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2313
2314         IStream_Release(strm_tmp);
2315     }
2316
2317 cleanup:
2318     if(file1)
2319         IStorage_Release(file1);
2320     if(file2)
2321         IStorage_Release(file2);
2322
2323     DeleteFileW(file1_name);
2324     DeleteFileW(file2_name);
2325 }
2326
2327 static void test_copyto_iidexclusions_stream(void)
2328 {
2329     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2330     IStream *strm_tmp;
2331     HRESULT hr;
2332
2333     /* create & populate file1 */
2334     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2335     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2336     if(FAILED(hr))
2337         goto cleanup;
2338
2339     hr = create_test_file(file1);
2340     if(FAILED(hr))
2341         goto cleanup;
2342
2343     /* create file2 */
2344     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2345     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2346     if(FAILED(hr))
2347         goto cleanup;
2348
2349     /* copy file1 to file2 with iid exclusions */
2350     hr = IStorage_CopyTo(file1, 1, &IID_IStream, NULL, file2);
2351     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2352     if(FAILED(hr))
2353         goto cleanup;
2354
2355     /* verify that file1 copied over, respecting exclusions */
2356     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2357             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2358     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2359
2360     if(SUCCEEDED(hr)){
2361         hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2362                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2363         ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2364         if(SUCCEEDED(hr))
2365             IStream_Release(strm_tmp);
2366
2367         IStorage_Release(stg_tmp);
2368     }
2369
2370     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2371             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2372     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2373
2374     if(SUCCEEDED(hr)){
2375         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2376                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2377         ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2378         if(SUCCEEDED(hr))
2379             IStream_Release(strm_tmp);
2380
2381         IStorage_Release(stg_tmp);
2382     }
2383
2384     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2385             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2386     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2387     if(SUCCEEDED(hr))
2388         IStream_Release(strm_tmp);
2389
2390 cleanup:
2391     if(file1)
2392         IStorage_Release(file1);
2393     if(file2)
2394         IStorage_Release(file2);
2395
2396     DeleteFileW(file1_name);
2397     DeleteFileW(file2_name);
2398 }
2399
2400 static void test_rename(void)
2401 {
2402     IStorage *stg, *stg2;
2403     IStream *stm;
2404     HRESULT r;
2405     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
2406     static const WCHAR stgname2[] = { 'S','T','G',0 };
2407     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
2408     static const WCHAR stmname2[] = { 'E','N','T','S',0 };
2409
2410     DeleteFileA(filenameA);
2411
2412     /* create the file */
2413     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
2414                             STGM_READWRITE, 0, &stg);
2415     ok(r==S_OK, "StgCreateDocfile failed\n");
2416
2417     /* create a substorage */
2418     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
2419     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
2420
2421     /* create a stream in the substorage */
2422     r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
2423     ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
2424     IStream_Release(stm);
2425
2426     /* rename the stream */
2427     r = IStorage_RenameElement(stg2, stmname, stmname2);
2428     ok(r==S_OK, "IStorage->RenameElement failed, hr=%08x\n", r);
2429
2430     /* cannot open stream with old name */
2431     r = IStorage_OpenStream(stg2, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2432     ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2433     if (SUCCEEDED(r)) IStream_Release(stm);
2434
2435     /* can open stream with new name */
2436     r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2437     ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
2438     if (SUCCEEDED(r)) IStream_Release(stm);
2439
2440     IStorage_Release(stg2);
2441
2442     /* rename the storage */
2443     IStorage_RenameElement(stg, stgname, stgname2);
2444
2445     /* cannot open storage with old name */
2446     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2447     ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2448     if (SUCCEEDED(r)) IStorage_Release(stg2);
2449
2450     /* can open storage with new name */
2451     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2452     ok(r==S_OK, "IStorage_OpenStream should fail, hr=%08x\n", r);
2453     if (SUCCEEDED(r))
2454     {
2455         /* opened storage still has the stream */
2456         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2457         ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
2458         if (SUCCEEDED(r)) IStream_Release(stm);
2459
2460         IStorage_Release(stg2);
2461     }
2462
2463     IStorage_Release(stg);
2464
2465     r = DeleteFileA(filenameA);
2466     ok( r == TRUE, "deleted file\n");
2467 }
2468
2469 START_TEST(storage32)
2470 {
2471     CHAR temp[MAX_PATH];
2472
2473     GetTempPathA(MAX_PATH, temp);
2474     if(!GetTempFileNameA(temp, "stg", 0, filenameA))
2475     {
2476         win_skip("Could not create temp file, %u\n", GetLastError());
2477         return;
2478     }
2479     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
2480     DeleteFileA(filenameA);
2481
2482     test_hglobal_storage_stat();
2483     test_create_storage_modes();
2484     test_storage_stream();
2485     test_open_storage();
2486     test_storage_suminfo();
2487     test_storage_refcount();
2488     test_streamenum();
2489     test_transact();
2490     test_substorage_share();
2491     test_revert();
2492     test_parent_free();
2493     test_nonroot_transacted();
2494     test_ReadClassStm();
2495     test_access();
2496     test_writeclassstg();
2497     test_readonly();
2498     test_simple();
2499     test_fmtusertypestg();
2500     test_references();
2501     test_copyto();
2502     test_copyto_snbexclusions();
2503     test_copyto_iidexclusions_storage();
2504     test_copyto_iidexclusions_stream();
2505     test_rename();
2506 }