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         todo_wine 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         todo_wine 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         todo_wine ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1077         if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stgname);
1078
1079 #if 0
1080         /* This crashes on Wine. */
1081
1082         /* destroying an object while it's open invalidates it */
1083         r = IStorage_DestroyElement(stg, stgname);
1084         ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1085
1086         r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1087         todo_wine ok(r==STG_E_REVERTED, "IStorage->CreateStream failed, hr=%08x\n", r);
1088
1089         if (r == S_OK)
1090             IStorage_Release(stm);
1091 #endif
1092
1093         IStorage_Release(stg2);
1094     }
1095
1096     /* create a read/write stream and try to open it again */
1097     r = IStorage_CreateStream(stg, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1098     ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
1099
1100     if (r == S_OK)
1101     {
1102         r = IStorage_OpenStream(stg, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1103         todo_wine ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1104
1105         if (r == S_OK)
1106             IStorage_Release(stm2);
1107
1108         r = IStorage_OpenStream(stg, stmname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1109         todo_wine ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1110
1111         if (r == S_OK)
1112             IStorage_Release(stm2);
1113
1114         /* cannot rename the stream while it's open */
1115         r = IStorage_RenameElement(stg, stmname, othername);
1116         todo_wine ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1117         if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stmname);
1118
1119         /* destroying an object while it's open invalidates it */
1120         r = IStorage_DestroyElement(stg, stmname);
1121         ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1122
1123         r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1124         todo_wine ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1125
1126         IStorage_Release(stm);
1127     }
1128
1129     IStorage_Release(stg);
1130
1131     r = DeleteFileA(filenameA);
1132     ok( r == TRUE, "deleted file\n");
1133 }
1134
1135 static void test_revert(void)
1136 {
1137     IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1138     HRESULT r;
1139     IStream *stm = NULL, *stm2 = NULL;
1140     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1141     static const WCHAR stmname2[] = { 'F','O','O',0 };
1142     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1143     static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
1144     STATSTG statstg;
1145
1146     DeleteFileA(filenameA);
1147
1148     /* create the file */
1149     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1150                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1151     ok(r==S_OK, "StgCreateDocfile failed\n");
1152
1153     /* commit a new stream and storage */
1154     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1155     ok(r==S_OK, "IStorage->CreateStream failed\n");
1156
1157     r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
1158     ok(r==S_OK, "IStream->Write failed\n");
1159
1160     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1161     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1162
1163     if (r == S_OK)
1164     {
1165         /* Create two substorages but only commit one */
1166         r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1167         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1168
1169         if (r == S_OK)
1170             IStorage_Release(stg3);
1171
1172         r = IStorage_Commit(stg, 0);
1173         ok(r==S_OK, "IStorage->Commit failed\n");
1174
1175         r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1176         ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1177
1178         if (r == S_OK)
1179             IStorage_Release(stg3);
1180     }
1181
1182     /* now create a stream and storage, then revert */
1183     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
1184     ok(r==S_OK, "IStorage->CreateStream failed\n");
1185
1186     r = IStream_Write(stm2, "this is stream 2\n", 16, NULL);
1187     ok(r==S_OK, "IStream->Write failed\n");
1188
1189     r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1190     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1191
1192     r = IStorage_Revert(stg);
1193
1194     /* all open objects become invalid */
1195     todo_wine {
1196     r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1197     ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1198
1199     r = IStream_Write(stm2, "this shouldn't work\n", 20, NULL);
1200     ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1201
1202     r = IStorage_Stat(stg2, &statstg, STATFLAG_NONAME);
1203     ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1204
1205     r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
1206     ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1207     }
1208
1209     IStream_Release(stm);
1210     IStream_Release(stm2);
1211     IStorage_Release(stg2);
1212     IStorage_Release(stg3);
1213
1214     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
1215     ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
1216
1217     r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1218     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1219
1220     r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1221     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1222
1223     r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1224     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1225
1226     todo_wine {
1227     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1228     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1229     }
1230     if (r == S_OK)
1231         IStream_Release(stm);
1232
1233     todo_wine {
1234     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1235     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1236     }
1237     if (r == S_OK)
1238         IStorage_Release(stg2);
1239
1240     r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1241     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1242
1243     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1244     ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1245     if (r == S_OK)
1246         IStream_Release(stm);
1247
1248     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1249     ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1250     if (r == S_OK)
1251     {
1252         r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1253         ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1254         if (r == S_OK)
1255             IStorage_Release(stg3);
1256
1257         r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1258         todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1259         if (r == S_OK)
1260             IStorage_Release(stg3);
1261
1262         IStorage_Release(stg2);
1263     }
1264
1265     IStorage_Release(stg);
1266
1267     r = DeleteFileA(filenameA);
1268     ok( r == TRUE, "deleted file\n");
1269
1270     /* Revert only invalidates objects in transacted mode */
1271     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1272                             STGM_READWRITE, 0, &stg);
1273     ok(r==S_OK, "StgCreateDocfile failed\n");
1274
1275     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1276     ok(r==S_OK, "IStorage->CreateStream failed\n");
1277
1278     r = IStorage_Revert(stg);
1279     todo_wine ok(r==S_OK, "IStorage->Revert failed %08x\n", r);
1280
1281     r = IStream_Write(stm, "this works\n", 11, NULL);
1282     ok(r==S_OK, "IStream_Write should succeed %08x\n", r);
1283
1284     IStream_Release(stm);
1285     IStream_Release(stg);
1286
1287     r = DeleteFileA(filenameA);
1288     ok( r == TRUE, "deleted file\n");
1289 }
1290
1291 static void test_nonroot_transacted(void)
1292 {
1293     IStorage *stg = NULL, *stg2 = NULL;
1294     HRESULT r;
1295     IStream *stm = NULL;
1296     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1297     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1298     static const WCHAR stmname2[] = { 'F','O','O',0 };
1299
1300     DeleteFileA(filenameA);
1301
1302     /* create a transacted file */
1303     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1304                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1305     ok(r==S_OK, "StgCreateDocfile failed\n");
1306
1307     /* create a transacted substorage */
1308     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1309     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1310
1311     if (r == S_OK)
1312     {
1313         /* create and commit stmname */
1314         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1315         ok(r==S_OK, "IStorage->CreateStream failed\n");
1316         if (r == S_OK)
1317             IStream_Release(stm);
1318
1319         IStorage_Commit(stg2, 0);
1320
1321         /* create and revert stmname2 */
1322         r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1323         ok(r==S_OK, "IStorage->CreateStream failed\n");
1324         if (r == S_OK)
1325             IStream_Release(stm);
1326
1327         IStorage_Revert(stg2);
1328
1329         /* check that Commit and Revert really worked */
1330         r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1331         ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1332         if (r == S_OK)
1333             IStream_Release(stm);
1334
1335         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1336         todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1337         if (r == S_OK)
1338             IStream_Release(stm);
1339
1340         IStorage_Release(stg2);
1341     }
1342
1343     IStream_Release(stg);
1344
1345     /* create a non-transacted file */
1346     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1347                             STGM_READWRITE, 0, &stg);
1348     ok(r==S_OK, "StgCreateDocfile failed\n");
1349
1350     /* create a transacted substorage */
1351     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1352     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1353
1354     if (r == S_OK)
1355     {
1356         /* create and commit stmname */
1357         r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1358         ok(r==S_OK, "IStorage->CreateStream failed\n");
1359         if (r == S_OK)
1360             IStream_Release(stm);
1361
1362         IStorage_Commit(stg2, 0);
1363
1364         /* create and revert stmname2 */
1365         r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1366         ok(r==S_OK, "IStorage->CreateStream failed\n");
1367         if (r == S_OK)
1368             IStream_Release(stm);
1369
1370         IStorage_Revert(stg2);
1371
1372         /* check that Commit and Revert really worked */
1373         r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1374         ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1375         if (r == S_OK)
1376             IStream_Release(stm);
1377
1378         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1379         todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1380         if (r == S_OK)
1381             IStream_Release(stm);
1382
1383         IStorage_Release(stg2);
1384     }
1385
1386     IStream_Release(stg);
1387
1388     r = DeleteFileA(filenameA);
1389     ok( r == TRUE, "deleted file\n");
1390 }
1391
1392 static void test_ReadClassStm(void)
1393 {
1394     CLSID clsid;
1395     HRESULT hr;
1396     IStream *pStream;
1397     static const LARGE_INTEGER llZero;
1398
1399     hr = ReadClassStm(NULL, &clsid);
1400     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1401
1402     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1403     ok_ole_success(hr, "CreateStreamOnHGlobal");
1404     hr = WriteClassStm(pStream, &test_stg_cls);
1405     ok_ole_success(hr, "WriteClassStm");
1406
1407     hr = ReadClassStm(pStream, NULL);
1408     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1409
1410     /* test not rewound stream */
1411     hr = ReadClassStm(pStream, &clsid);
1412     ok(hr == STG_E_READFAULT, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
1413     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid should have been zeroed\n");
1414
1415     hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
1416     ok_ole_success(hr, "IStream_Seek");
1417     hr = ReadClassStm(pStream, &clsid);
1418     ok_ole_success(hr, "ReadClassStm");
1419     ok(IsEqualCLSID(&clsid, &test_stg_cls), "clsid should have been set to CLSID_WineTest\n");
1420 }
1421
1422 struct access_res
1423 {
1424     BOOL gothandle;
1425     DWORD lasterr;
1426     BOOL ignore;
1427 };
1428
1429 static const struct access_res create[16] =
1430 {
1431     { TRUE, ERROR_SUCCESS, TRUE },
1432     { TRUE, ERROR_SUCCESS, TRUE },
1433     { TRUE, ERROR_SUCCESS, FALSE },
1434     { TRUE, ERROR_SUCCESS, FALSE },
1435     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1436     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1437     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1438     { TRUE, ERROR_SUCCESS, FALSE },
1439     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1440     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1441     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1442     { TRUE, ERROR_SUCCESS, TRUE },
1443     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1444     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1445     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1446     { TRUE, ERROR_SUCCESS, TRUE }
1447 };
1448
1449 static const struct access_res create_commit[16] =
1450 {
1451     { TRUE, ERROR_SUCCESS, TRUE },
1452     { TRUE, ERROR_SUCCESS, TRUE },
1453     { TRUE, ERROR_SUCCESS, FALSE },
1454     { TRUE, ERROR_SUCCESS, FALSE },
1455     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1456     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1457     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1458     { TRUE, ERROR_SUCCESS, FALSE },
1459     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1460     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1461     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1462     { TRUE, ERROR_SUCCESS, TRUE },
1463     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1464     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1465     { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1466     { TRUE, ERROR_SUCCESS, TRUE }
1467 };
1468
1469 static const struct access_res create_close[16] =
1470 {
1471     { TRUE, ERROR_SUCCESS, FALSE },
1472     { TRUE, ERROR_SUCCESS, FALSE },
1473     { TRUE, ERROR_SUCCESS, FALSE },
1474     { TRUE, ERROR_SUCCESS, FALSE },
1475     { TRUE, ERROR_SUCCESS, FALSE },
1476     { TRUE, ERROR_SUCCESS, FALSE },
1477     { TRUE, ERROR_SUCCESS, FALSE },
1478     { TRUE, ERROR_SUCCESS, FALSE },
1479     { TRUE, ERROR_SUCCESS, FALSE },
1480     { TRUE, ERROR_SUCCESS, FALSE },
1481     { TRUE, ERROR_SUCCESS, FALSE },
1482     { TRUE, ERROR_SUCCESS, FALSE },
1483     { TRUE, ERROR_SUCCESS, FALSE },
1484     { TRUE, ERROR_SUCCESS, FALSE },
1485     { TRUE, ERROR_SUCCESS, FALSE },
1486     { TRUE, ERROR_SUCCESS }
1487 };
1488
1489 static void _test_file_access(LPCSTR file, const struct access_res *ares, DWORD line)
1490 {
1491     DWORD access = 0, share = 0;
1492     DWORD lasterr;
1493     HANDLE hfile;
1494     int i, j, idx = 0;
1495
1496     for (i = 0; i < 4; i++)
1497     {
1498         if (i == 0) access = 0;
1499         if (i == 1) access = GENERIC_READ;
1500         if (i == 2) access = GENERIC_WRITE;
1501         if (i == 3) access = GENERIC_READ | GENERIC_WRITE;
1502
1503         for (j = 0; j < 4; j++)
1504         {
1505             if (ares[idx].ignore)
1506                 continue;
1507
1508             if (j == 0) share = 0;
1509             if (j == 1) share = FILE_SHARE_READ;
1510             if (j == 2) share = FILE_SHARE_WRITE;
1511             if (j == 3) share = FILE_SHARE_READ | FILE_SHARE_WRITE;
1512
1513             SetLastError(0xdeadbeef);
1514             hfile = CreateFileA(file, access, share, NULL, OPEN_EXISTING,
1515                                 FILE_ATTRIBUTE_NORMAL, 0);
1516             lasterr = GetLastError();
1517
1518             ok((hfile != INVALID_HANDLE_VALUE) == ares[idx].gothandle,
1519                "(%d, handle, %d): Expected %d, got %d\n",
1520                line, idx, ares[idx].gothandle,
1521                (hfile != INVALID_HANDLE_VALUE));
1522
1523             ok(lasterr == ares[idx].lasterr ||
1524                broken(lasterr == 0xdeadbeef) /* win9x */,
1525                "(%d, lasterr, %d): Expected %d, got %d\n",
1526                line, idx, ares[idx].lasterr, lasterr);
1527
1528             CloseHandle(hfile);
1529             idx++;
1530         }
1531     }
1532 }
1533
1534 #define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
1535
1536 static void test_access(void)
1537 {
1538     IStorage *stg;
1539     HRESULT hr;
1540
1541     static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1542
1543     /* STGM_TRANSACTED */
1544
1545     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1546                           STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, &stg);
1547     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1548
1549     test_file_access("winetest", create);
1550
1551     hr = IStorage_Commit(stg, STGC_DEFAULT);
1552     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1553
1554     test_file_access("winetest", create_commit);
1555
1556     IStorage_Release(stg);
1557
1558     test_file_access("winetest", create_close);
1559
1560     DeleteFileA("winetest");
1561
1562     /* STGM_DIRECT */
1563
1564     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1565                           STGM_SHARE_EXCLUSIVE | STGM_DIRECT, 0, &stg);
1566     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1567
1568     test_file_access("winetest", create);
1569
1570     hr = IStorage_Commit(stg, STGC_DEFAULT);
1571     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1572
1573     test_file_access("winetest", create_commit);
1574
1575     IStorage_Release(stg);
1576
1577     test_file_access("winetest", create_close);
1578
1579     DeleteFileA("winetest");
1580
1581     /* STGM_SHARE_DENY_NONE */
1582
1583     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1584                           STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
1585     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1586
1587     test_file_access("winetest", create);
1588
1589     hr = IStorage_Commit(stg, STGC_DEFAULT);
1590     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1591
1592     test_file_access("winetest", create_commit);
1593
1594     IStorage_Release(stg);
1595
1596     test_file_access("winetest", create_close);
1597
1598     DeleteFileA("winetest");
1599
1600     /* STGM_SHARE_DENY_READ */
1601
1602     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1603                           STGM_SHARE_DENY_READ | STGM_TRANSACTED, 0, &stg);
1604     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1605
1606     test_file_access("winetest", create);
1607
1608     hr = IStorage_Commit(stg, STGC_DEFAULT);
1609     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1610
1611     test_file_access("winetest", create_commit);
1612
1613     IStorage_Release(stg);
1614
1615     test_file_access("winetest", create_close);
1616
1617     DeleteFileA("winetest");
1618
1619     /* STGM_SHARE_DENY_WRITE */
1620
1621     hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1622                           STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
1623     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1624
1625     test_file_access("winetest", create);
1626
1627     hr = IStorage_Commit(stg, STGC_DEFAULT);
1628     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1629
1630     test_file_access("winetest", create_commit);
1631
1632     IStorage_Release(stg);
1633
1634     test_file_access("winetest", create_close);
1635
1636     DeleteFileA("winetest");
1637 }
1638
1639 static void test_readonly(void)
1640 {
1641     IStorage *stg, *stg2, *stg3;
1642     IStream *stream;
1643     HRESULT hr;
1644     static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1645     static const WCHAR storageW[] = {'s','t','o','r','a','g','e',0};
1646     static const WCHAR streamW[] = {'s','t','r','e','a','m',0};
1647
1648     hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1649     ok(hr == S_OK, "should succeed, res=%x\n", hr);
1650     if (SUCCEEDED(hr))
1651     {
1652         hr = IStorage_CreateStorage( stg, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2 );
1653         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1654         if (SUCCEEDED(hr))
1655         {
1656             hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stream );
1657             ok(hr == S_OK, "should succeed, res=%x\n", hr);
1658             if (SUCCEEDED(hr))
1659                 IStream_Release(stream);
1660             IStorage_Release(stg2);
1661         }
1662         IStorage_Release(stg);
1663     }
1664
1665     /* re-open read only */
1666     hr = StgOpenStorage( fileW, NULL, STGM_TRANSACTED | STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
1667     ok(hr == S_OK, "should succeed, res=%x\n", hr);
1668     if (SUCCEEDED(hr))
1669     {
1670         hr = IStorage_OpenStorage( stg, storageW, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2 );
1671         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1672         if (SUCCEEDED(hr))
1673         {
1674             /* CreateStream on read-only storage, name exists */
1675             hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1676             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1677             if (SUCCEEDED(hr))
1678                 IStream_Release(stream);
1679
1680             /* CreateStream on read-only storage, name does not exist */
1681             hr = IStorage_CreateStream( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1682             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1683             if (SUCCEEDED(hr))
1684                 IStream_Release(stream);
1685
1686             /* CreateStorage on read-only storage, name exists */
1687             hr = IStorage_CreateStorage( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1688             ok(hr == STG_E_FILEALREADYEXISTS, "should fail, res=%x\n", hr);
1689             if (SUCCEEDED(hr))
1690                 IStream_Release(stg3);
1691
1692             /* CreateStorage on read-only storage, name does not exist */
1693             hr = IStorage_CreateStorage( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1694             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1695             if (SUCCEEDED(hr))
1696                 IStream_Release(stg3);
1697
1698             /* DestroyElement on read-only storage, name exists */
1699             hr = IStorage_DestroyElement( stg2, streamW );
1700             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1701
1702             /* DestroyElement on read-only storage, name does not exist */
1703             hr = IStorage_DestroyElement( stg2, storageW );
1704             ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1705
1706             IStorage_Release(stg2);
1707         }
1708
1709         IStorage_Release(stg);
1710     }
1711
1712     DeleteFileA("winetest");
1713 }
1714
1715 static void test_simple(void)
1716 {
1717     /* Tests for STGM_SIMPLE mode */
1718
1719     IStorage *stg;
1720     HRESULT r;
1721     IStream *stm;
1722     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1723     static const WCHAR stmname2[] = { 'S','m','a','l','l',0 };
1724     LARGE_INTEGER pos;
1725     ULARGE_INTEGER upos;
1726     DWORD count;
1727     STATSTG stat;
1728
1729     DeleteFileA(filenameA);
1730
1731     r = StgCreateDocfile( filename, STGM_SIMPLE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1732     ok(r == S_OK, "got %08x\n", r);
1733
1734     r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1735     ok(r == STG_E_INVALIDFLAG, "got %08x\n", r);
1736     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1737     ok(r == S_OK, "got %08x\n", r);
1738
1739     upos.QuadPart = 6000;
1740     r = IStream_SetSize(stm, upos);
1741     ok(r == S_OK, "got %08x\n", r);
1742
1743     r = IStream_Write(stm, "foo", 3, &count);
1744     ok(r == S_OK, "got %08x\n", r);
1745     ok(count == 3, "got %d\n", count);
1746
1747     pos.QuadPart = 0;
1748     r = IStream_Seek(stm, pos, STREAM_SEEK_CUR, &upos);
1749     ok(r == S_OK, "got %08x\n", r);
1750     ok(upos.QuadPart == 3, "got %d\n", upos.u.LowPart);
1751
1752     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1753     ok(r == S_OK ||
1754        broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1755        "got %08x\n", r);
1756     if (r == S_OK)
1757         ok(stat.cbSize.QuadPart == 3, "got %d\n", stat.cbSize.u.LowPart);
1758
1759     pos.QuadPart = 1;
1760     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
1761     ok(r == S_OK, "got %08x\n", r);
1762     ok(upos.QuadPart == 1, "got %d\n", upos.u.LowPart);
1763
1764     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1765     ok(r == S_OK ||
1766        broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1767        "got %08x\n", r);
1768     if (r == S_OK)
1769         ok(stat.cbSize.QuadPart == 1, "got %d\n", stat.cbSize.u.LowPart);
1770
1771     IStream_Release(stm);
1772
1773     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1774     ok(r == S_OK, "got %08x\n", r);
1775
1776     upos.QuadPart = 100;
1777     r = IStream_SetSize(stm, upos);
1778     ok(r == S_OK, "got %08x\n", r);
1779
1780     r = IStream_Write(stm, "foo", 3, &count);
1781     ok(r == S_OK, "got %08x\n", r);
1782     ok(count == 3, "got %d\n", count);
1783
1784     IStream_Release(stm);
1785
1786     IStorage_Commit(stg, STGC_DEFAULT);
1787     IStorage_Release(stg);
1788
1789     r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
1790     if (r == STG_E_INVALIDFLAG)
1791     {
1792         win_skip("Flag combination is not supported on NT4 and below\n");
1793         DeleteFileA(filenameA);
1794         return;
1795     }
1796     ok(r == S_OK, "got %08x\n", r);
1797
1798     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1799     ok(r == S_OK, "got %08x\n", r);
1800
1801     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1802     ok(r == S_OK, "got %08x\n", r);
1803     ok(stat.cbSize.QuadPart == 6000, "got %d\n", stat.cbSize.u.LowPart);
1804
1805     IStream_Release(stm);
1806
1807     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1808     ok(r == S_OK, "got %08x\n", r);
1809
1810     r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1811     ok(r == S_OK, "got %08x\n", r);
1812     ok(stat.cbSize.QuadPart == 4096, "got %d\n", stat.cbSize.u.LowPart);
1813
1814     IStream_Release(stm);
1815
1816
1817     IStorage_Release(stg);
1818
1819     DeleteFileA(filenameA);
1820 }
1821
1822 static void test_fmtusertypestg(void)
1823 {
1824     IStorage *stg;
1825     IEnumSTATSTG *stat;
1826     HRESULT hr;
1827     static const WCHAR fileW[] = {'f','m','t','t','e','s','t',0};
1828     static WCHAR userTypeW[] = {'S','t','g','U','s','r','T','y','p','e',0};
1829     static WCHAR strmNameW[] = {1,'C','o','m','p','O','b','j',0};
1830
1831     hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1832     ok(hr == S_OK, "should succeed, res=%x\n", hr);
1833
1834     if (SUCCEEDED(hr))
1835     {
1836         /* try to write the stream */
1837         hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1838         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1839
1840         /* check that the stream was created */
1841         hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1842         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1843         if (SUCCEEDED(hr))
1844         {
1845             BOOL found = FALSE;
1846             STATSTG statstg;
1847             DWORD got;
1848             while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1849             {
1850                 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1851                     found = TRUE;
1852                 else
1853                     ok(0, "found unexpected stream or storage\n");
1854             }
1855             ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1856             IEnumSTATSTG_Release(stat);
1857         }
1858
1859         /* re-write the stream */
1860         hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1861         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1862
1863         /* check that the stream is still there */
1864         hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1865         ok(hr == S_OK, "should succeed, res=%x\n", hr);
1866         if (SUCCEEDED(hr))
1867         {
1868             BOOL found = FALSE;
1869             STATSTG statstg;
1870             DWORD got;
1871             while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1872             {
1873                 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1874                     found = TRUE;
1875                 else
1876                     ok(0, "found unexpected stream or storage\n");
1877             }
1878             ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1879             IEnumSTATSTG_Release(stat);
1880         }
1881
1882         IStorage_Release(stg);
1883         DeleteFileW( fileW );
1884     }
1885 }
1886
1887 static void test_references(void)
1888 {
1889     IStorage *stg,*stg2;
1890     HRESULT hr;
1891     unsigned c1,c2;
1892     static const WCHAR StorName[] = { 'D','a','t','a','S','p','a','c','e','I','n','f','o',0 };
1893
1894     DeleteFileA(filenameA);
1895
1896     hr = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1897     ok(hr==S_OK, "StgCreateDocfile failed\n");
1898
1899     if (SUCCEEDED(hr))
1900     {
1901         IStorage_Release(stg);
1902
1903         hr = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
1904         ok(hr==S_OK, "StgOpenStorage failed (result=%x)\n",hr);
1905
1906         if (SUCCEEDED(hr))
1907         {
1908             hr = IStorage_CreateStorage(stg,StorName,STGM_READWRITE | STGM_SHARE_EXCLUSIVE,0,0,&stg2);
1909             ok(hr == S_OK, "IStorage_CreateStorage failed (result=%x)\n",hr);
1910
1911             if (SUCCEEDED(hr))
1912             {
1913                 c1 = IStorage_AddRef(stg);
1914                 ok(c1 == 2, "creating internal storage added references to ancestor\n");
1915                 c1 = IStorage_AddRef(stg);
1916                 IStorage_Release(stg2);
1917                 c2 = IStorage_AddRef(stg) - 1;
1918                 ok(c1 == c2, "releasing internal storage removed references to ancestor\n");
1919             }
1920             c1 = IStorage_Release(stg);
1921             while ( c1 ) c1 = IStorage_Release(stg);
1922         }
1923     }
1924
1925     DeleteFileA(filenameA);
1926 }
1927
1928 /* dest
1929  *  |-StorageA
1930  *  |  `StreamA: "StreamA"
1931  *  |-StorageB
1932  *  |  `StreamB: "StreamB"
1933  *  `StreamC: "StreamC"
1934  */
1935 static HRESULT create_test_file(IStorage *dest)
1936 {
1937     IStorage *stgA = NULL, *stgB = NULL;
1938     IStream *strmA = NULL, *strmB = NULL, *strmC = NULL;
1939     const ULONG strmA_name_size = lstrlenW(strmA_name) * sizeof(WCHAR);
1940     const ULONG strmB_name_size = lstrlenW(strmB_name) * sizeof(WCHAR);
1941     const ULONG strmC_name_size = lstrlenW(strmC_name) * sizeof(WCHAR);
1942     ULONG bytes;
1943     HRESULT hr;
1944
1945     hr = IStorage_CreateStorage(dest, stgA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgA);
1946     ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
1947     if(FAILED(hr))
1948         goto cleanup;
1949
1950     hr = IStorage_CreateStream(stgA, strmA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmA);
1951     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
1952     if(FAILED(hr))
1953         goto cleanup;
1954
1955     hr = IStream_Write(strmA, strmA_name, strmA_name_size, &bytes);
1956     ok(hr == S_OK && bytes == strmA_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmA_name_size);
1957
1958     hr = IStorage_CreateStorage(dest, stgB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgB);
1959     ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
1960     if(FAILED(hr))
1961         goto cleanup;
1962
1963     hr = IStorage_CreateStream(stgB, strmB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmB);
1964     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
1965     if(FAILED(hr))
1966         goto cleanup;
1967
1968     hr = IStream_Write(strmB, strmB_name, strmB_name_size, &bytes);
1969     ok(hr == S_OK && bytes == strmB_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmB_name_size);
1970
1971     hr = IStorage_CreateStream(dest, strmC_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmC);
1972     ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
1973     if(FAILED(hr))
1974         goto cleanup;
1975
1976     hr = IStream_Write(strmC, strmC_name, strmC_name_size, &bytes);
1977     ok(hr == S_OK && bytes == strmC_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmC_name_size);
1978
1979 cleanup:
1980     if(strmC)
1981         IStream_Release(strmC);
1982     if(strmB)
1983         IStream_Release(strmB);
1984     if(stgB)
1985         IStorage_Release(stgB);
1986     if(strmA)
1987         IStream_Release(strmA);
1988     if(stgA)
1989         IStorage_Release(stgA);
1990
1991     return hr;
1992 }
1993
1994 static void test_copyto(void)
1995 {
1996     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
1997     IStream *strm_tmp;
1998     WCHAR buf[64];
1999     HRESULT hr;
2000
2001     /* create & populate file1 */
2002     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2003     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2004     if(FAILED(hr))
2005         goto cleanup;
2006
2007     hr = create_test_file(file1);
2008     if(FAILED(hr))
2009         goto cleanup;
2010
2011     /* create file2 */
2012     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2013     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2014     if(FAILED(hr))
2015         goto cleanup;
2016
2017     /* copy file1 into file2 */
2018     hr = IStorage_CopyTo(file1, 0, NULL, NULL, NULL);
2019     ok(hr == STG_E_INVALIDPOINTER, "CopyTo should give STG_E_INVALIDPONITER, gave: 0x%08x\n", hr);
2020
2021     hr = IStorage_CopyTo(file1, 0, NULL, NULL, file2);
2022     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2023     if(FAILED(hr))
2024         goto cleanup;
2025
2026     /* verify that all of file1 was copied */
2027     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2028             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2029     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2030
2031     if(SUCCEEDED(hr)){
2032         hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2033                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2034         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2035
2036         if(SUCCEEDED(hr)){
2037             memset(buf, 0, sizeof(buf));
2038             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2039             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2040             if(SUCCEEDED(hr))
2041                 ok(lstrcmpW(buf, strmA_name) == 0,
2042                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmA_name), wine_dbgstr_w(buf));
2043
2044             IStream_Release(strm_tmp);
2045         }
2046
2047         IStorage_Release(stg_tmp);
2048     }
2049
2050     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2051             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2052     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2053
2054     if(SUCCEEDED(hr)){
2055         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2056                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2057         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2058
2059         if(SUCCEEDED(hr)){
2060             memset(buf, 0, sizeof(buf));
2061             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2062             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2063             if(SUCCEEDED(hr))
2064                 ok(lstrcmpW(buf, strmB_name) == 0,
2065                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2066
2067             IStream_Release(strm_tmp);
2068         }
2069
2070         IStorage_Release(stg_tmp);
2071     }
2072
2073     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2074             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2075     ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2076
2077     if(SUCCEEDED(hr)){
2078         memset(buf, 0, sizeof(buf));
2079         hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2080         ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2081         if(SUCCEEDED(hr))
2082             ok(lstrcmpW(buf, strmC_name) == 0,
2083                     "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2084
2085         IStream_Release(strm_tmp);
2086     }
2087
2088 cleanup:
2089     if(file1)
2090         IStorage_Release(file1);
2091     if(file2)
2092         IStorage_Release(file2);
2093
2094     DeleteFileW(file1_name);
2095     DeleteFileW(file2_name);
2096 }
2097
2098 static void test_copyto_snbexclusions(void)
2099 {
2100     static const WCHAR *snb_exclude[] = {stgA_name, strmB_name, strmC_name, 0};
2101
2102     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2103     IStream *strm_tmp;
2104     WCHAR buf[64];
2105     HRESULT hr;
2106
2107     /* create & populate file1 */
2108     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2109     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2110     if(FAILED(hr))
2111         goto cleanup;
2112
2113     hr = create_test_file(file1);
2114     if(FAILED(hr))
2115         goto cleanup;
2116
2117     /* create file2 */
2118     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2119     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2120     if(FAILED(hr))
2121         goto cleanup;
2122
2123     /* copy file1 to file2 with name exclusions */
2124     hr = IStorage_CopyTo(file1, 0, NULL, (SNB)snb_exclude, file2);
2125     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2126     if(FAILED(hr))
2127         goto cleanup;
2128
2129     /* verify that file1 copied over, respecting exclusions */
2130     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2131             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2132     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2133     if(SUCCEEDED(hr))
2134         IStorage_Release(stg_tmp);
2135
2136     hr = IStorage_OpenStream(file2, strmA_name, NULL,
2137             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2138     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2139     if(SUCCEEDED(hr))
2140         IStream_Release(strm_tmp);
2141
2142     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2143             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2144     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2145
2146     if(SUCCEEDED(hr)){
2147         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2148                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2149         ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2150
2151         if(SUCCEEDED(hr)){
2152             memset(buf, 0, sizeof(buf));
2153             hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2154             ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2155             if(SUCCEEDED(hr))
2156                 ok(lstrcmpW(buf, strmB_name) == 0,
2157                         "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2158
2159             IStream_Release(strm_tmp);
2160         }
2161
2162         IStorage_Release(stg_tmp);
2163     }
2164
2165     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2166             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2167     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2168     if(SUCCEEDED(hr))
2169         IStream_Release(strm_tmp);
2170
2171 cleanup:
2172     if(file1)
2173         IStorage_Release(file1);
2174     if(file2)
2175         IStorage_Release(file2);
2176
2177     DeleteFileW(file1_name);
2178     DeleteFileW(file2_name);
2179 }
2180
2181 static void test_copyto_iidexclusions_storage(void)
2182 {
2183     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2184     IStream *strm_tmp;
2185     WCHAR buf[64];
2186     HRESULT hr;
2187
2188     /* create & populate file1 */
2189     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2190     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2191     if(FAILED(hr))
2192         goto cleanup;
2193
2194     hr = create_test_file(file1);
2195     if(FAILED(hr))
2196         goto cleanup;
2197
2198     /* create file2 */
2199     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2200     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2201     if(FAILED(hr))
2202         goto cleanup;
2203
2204     /* copy file1 to file2 with iid exclusions */
2205     hr = IStorage_CopyTo(file1, 1, &IID_IStorage, NULL, file2);
2206     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2207     if(FAILED(hr))
2208         goto cleanup;
2209
2210     /* verify that file1 copied over, respecting exclusions */
2211     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2212             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2213     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2214     if(SUCCEEDED(hr))
2215         IStorage_Release(stg_tmp);
2216
2217     hr = IStorage_OpenStream(file2, strmA_name, NULL,
2218             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2219     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2220     if(SUCCEEDED(hr))
2221         IStream_Release(strm_tmp);
2222
2223     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2224             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2225     ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2226     if(SUCCEEDED(hr))
2227         IStorage_Release(stg_tmp);
2228
2229     hr = IStorage_OpenStream(file2, strmB_name, NULL,
2230             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2231     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2232     if(SUCCEEDED(hr))
2233         IStream_Release(strm_tmp);
2234
2235     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2236             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2237     ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2238
2239     if(SUCCEEDED(hr)){
2240         memset(buf, 0, sizeof(buf));
2241         hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2242         ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2243         if(SUCCEEDED(hr))
2244             ok(lstrcmpW(buf, strmC_name) == 0,
2245                     "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2246
2247         IStream_Release(strm_tmp);
2248     }
2249
2250 cleanup:
2251     if(file1)
2252         IStorage_Release(file1);
2253     if(file2)
2254         IStorage_Release(file2);
2255
2256     DeleteFileW(file1_name);
2257     DeleteFileW(file2_name);
2258 }
2259
2260 static void test_copyto_iidexclusions_stream(void)
2261 {
2262     IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2263     IStream *strm_tmp;
2264     HRESULT hr;
2265
2266     /* create & populate file1 */
2267     hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2268     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2269     if(FAILED(hr))
2270         goto cleanup;
2271
2272     hr = create_test_file(file1);
2273     if(FAILED(hr))
2274         goto cleanup;
2275
2276     /* create file2 */
2277     hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2278     ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2279     if(FAILED(hr))
2280         goto cleanup;
2281
2282     /* copy file1 to file2 with iid exclusions */
2283     hr = IStorage_CopyTo(file1, 1, &IID_IStream, NULL, file2);
2284     ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2285     if(FAILED(hr))
2286         goto cleanup;
2287
2288     /* verify that file1 copied over, respecting exclusions */
2289     hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2290             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2291     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2292
2293     if(SUCCEEDED(hr)){
2294         hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2295                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2296         ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2297         if(SUCCEEDED(hr))
2298             IStream_Release(strm_tmp);
2299
2300         IStorage_Release(stg_tmp);
2301     }
2302
2303     hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2304             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2305     ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2306
2307     if(SUCCEEDED(hr)){
2308         hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2309                 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2310         ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2311         if(SUCCEEDED(hr))
2312             IStream_Release(strm_tmp);
2313
2314         IStorage_Release(stg_tmp);
2315     }
2316
2317     hr = IStorage_OpenStream(file2, strmC_name, NULL,
2318             STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2319     ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2320     if(SUCCEEDED(hr))
2321         IStream_Release(strm_tmp);
2322
2323 cleanup:
2324     if(file1)
2325         IStorage_Release(file1);
2326     if(file2)
2327         IStorage_Release(file2);
2328
2329     DeleteFileW(file1_name);
2330     DeleteFileW(file2_name);
2331 }
2332
2333 static void test_rename(void)
2334 {
2335     IStorage *stg, *stg2;
2336     IStream *stm;
2337     HRESULT r;
2338     static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
2339     static const WCHAR stgname2[] = { 'S','T','G',0 };
2340     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
2341     static const WCHAR stmname2[] = { 'E','N','T','S',0 };
2342
2343     DeleteFileA(filenameA);
2344
2345     /* create the file */
2346     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
2347                             STGM_READWRITE, 0, &stg);
2348     ok(r==S_OK, "StgCreateDocfile failed\n");
2349
2350     /* create a substorage */
2351     r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
2352     ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
2353
2354     /* create a stream in the substorage */
2355     r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
2356     ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
2357     IStream_Release(stm);
2358
2359     /* rename the stream */
2360     r = IStorage_RenameElement(stg2, stmname, stmname2);
2361     ok(r==S_OK, "IStorage->RenameElement failed, hr=%08x\n", r);
2362
2363     /* cannot open stream with old name */
2364     r = IStorage_OpenStream(stg2, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2365     ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2366     if (SUCCEEDED(r)) IStream_Release(stm);
2367
2368     /* can open stream with new name */
2369     r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2370     ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
2371     if (SUCCEEDED(r)) IStream_Release(stm);
2372
2373     IStorage_Release(stg2);
2374
2375     /* rename the storage */
2376     IStorage_RenameElement(stg, stgname, stgname2);
2377
2378     /* cannot open storage with old name */
2379     r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2380     ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2381     if (SUCCEEDED(r)) IStorage_Release(stg2);
2382
2383     /* can open storage with new name */
2384     r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2385     ok(r==S_OK, "IStorage_OpenStream should fail, hr=%08x\n", r);
2386     if (SUCCEEDED(r))
2387     {
2388         /* opened storage still has the stream */
2389         r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2390         ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
2391         if (SUCCEEDED(r)) IStream_Release(stm);
2392
2393         IStorage_Release(stg2);
2394     }
2395
2396     IStorage_Release(stg);
2397
2398     r = DeleteFileA(filenameA);
2399     ok( r == TRUE, "deleted file\n");
2400 }
2401
2402 START_TEST(storage32)
2403 {
2404     CHAR temp[MAX_PATH];
2405
2406     GetTempPathA(MAX_PATH, temp);
2407     if(!GetTempFileNameA(temp, "stg", 0, filenameA))
2408     {
2409         win_skip("Could not create temp file, %u\n", GetLastError());
2410         return;
2411     }
2412     MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
2413     DeleteFileA(filenameA);
2414
2415     test_hglobal_storage_stat();
2416     test_create_storage_modes();
2417     test_storage_stream();
2418     test_open_storage();
2419     test_storage_suminfo();
2420     test_storage_refcount();
2421     test_streamenum();
2422     test_transact();
2423     test_substorage_share();
2424     test_revert();
2425     test_nonroot_transacted();
2426     test_ReadClassStm();
2427     test_access();
2428     test_writeclassstg();
2429     test_readonly();
2430     test_simple();
2431     test_fmtusertypestg();
2432     test_references();
2433     test_copyto();
2434     test_copyto_snbexclusions();
2435     test_copyto_iidexclusions_storage();
2436     test_copyto_iidexclusions_stream();
2437     test_rename();
2438 }