git.oblomov.eu Git - wine/blob - 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 void test_hglobal_storage_stat(void)
  37 {
  38     ILockBytes *ilb = NULL;
  39     IStorage *stg = NULL;
  40     HRESULT r;
  41     STATSTG stat;
  42     DWORD mode, refcount;
  43
  44     r = CreateILockBytesOnHGlobal( NULL, TRUE, &ilb );
  45     ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
  46
  47     mode = STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE;/*0x1012*/
  48     r = StgCreateDocfileOnILockBytes( ilb, mode, 0,  &stg );
  49     ok( r == S_OK, "StgCreateDocfileOnILockBytes failed\n");
  50
  51     r = WriteClassStg( stg, &test_stg_cls );
  52     ok( r == S_OK, "WriteClassStg failed\n");
  53
  54     memset( &stat, 0, sizeof stat );
  55     r = IStorage_Stat( stg, &stat, 0 );
  56
  57     ok( stat.pwcsName == NULL, "storage name not null\n");
  58     ok( stat.type == 1, "type is wrong\n");
  59     ok( stat.grfMode == 0x12, "grf mode is incorrect\n");
  60     ok( !memcmp(&stat.clsid, &test_stg_cls, sizeof test_stg_cls), "CLSID is wrong\n");
  61
  62     refcount = IStorage_Release( stg );
  63     ok( refcount == 0, "IStorage refcount is wrong\n");
  64     refcount = ILockBytes_Release( ilb );
  65     ok( refcount == 0, "ILockBytes refcount is wrong\n");
  66 }
  67
  68 static void test_create_storage_modes(void)
  69 {
  70    static const WCHAR szPrefix[] = { 's','t','g',0 };
  71    static const WCHAR szDot[] = { '.',0 };
  72    WCHAR filename[MAX_PATH];
  73    IStorage *stg = NULL;
  74    HRESULT r;
  75
  76    if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
  77       return;
  78
  79    DeleteFileW(filename);
  80
  81    /* test with some invalid parameters */
  82    r = StgCreateDocfile( NULL, 0, 0, &stg);
  83    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  84    r = StgCreateDocfile( filename, 0, 0, &stg);
  85    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  86    r = StgCreateDocfile( filename, STGM_CREATE, 0, &stg);
  87    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  88    r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE, 0, &stg);
  89    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  90    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &stg);
  91    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  92    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, NULL);
  93    ok(r==STG_E_INVALIDPOINTER, "StgCreateDocfile succeeded\n");
  94    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, &stg);
  95    ok(r==STG_E_INVALIDPARAMETER, "StgCreateDocfile succeeded\n");
  96    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
  97    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  98    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READ, 0, &stg);
  99    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 100    r = StgCreateDocfile( filename, STGM_PRIORITY, 0, &stg);
 101    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 102
 103    /* StgCreateDocfile seems to be very particular about the flags it accepts */
 104    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | STGM_WRITE, 0, &stg);
 105    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 106    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 8, 0, &stg);
 107    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 108    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80, 0, &stg);
 109    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 110    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800, 0, &stg);
 111    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 112    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x8000, 0, &stg);
 113    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 114    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80000, 0, &stg);
 115    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 116    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800000, 0, &stg);
 117    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 118    ok(stg == NULL, "stg was set\n");
 119
 120    /* check what happens if the file already exists (which is how it's meant to be used) */
 121    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 122    ok(r==S_OK, "StgCreateDocfile failed\n");
 123    r = IStorage_Release(stg);
 124    ok(r == 0, "storage not released\n");
 125    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 126    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n"); /* FAILIFTHERE is default */
 127    r = StgCreateDocfile( filename, STGM_READ, 0, &stg);
 128    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n"); /* need at least readmode and sharemode */
 129    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE, 0, &stg);
 130    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 131    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE, 0, &stg);
 132    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 133    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE, 0, &stg);
 134    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 135    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
 136    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 137    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, &stg);
 138    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 139    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_WRITE, 0, &stg);
 140    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 141    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_WRITE, 0, &stg);
 142    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 143    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
 144    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
 145    r = StgCreateDocfile( filename, STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
 146    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
 147    ok(DeleteFileW(filename), "failed to delete file\n");
 148
 149    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 150    ok(r==S_OK, "StgCreateDocfile failed\n");
 151    r = IStorage_Release(stg);
 152    ok(r == 0, "storage not released\n");
 153    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED |STGM_FAILIFTHERE, 0, &stg);
 154    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 155    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_WRITE, 0, &stg);
 156    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 157
 158    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
 159    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 160    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 161    ok(r==S_OK, "StgCreateDocfile failed\n");
 162    r = IStorage_Release(stg);
 163    ok(r == 0, "storage not released\n");
 164    ok(DeleteFileW(filename), "failed to delete file\n");
 165
 166    /* test the way excel uses StgCreateDocFile */
 167    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 168    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 169    if(r == S_OK)
 170    {
 171       r = IStorage_Release(stg);
 172       ok(r == 0, "storage not released\n");
 173       ok(DeleteFileW(filename), "failed to delete file\n");
 174    }
 175
 176    /* and the way windows media uses it ... */
 177    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_NONE | STGM_READWRITE | STGM_TRANSACTED, 0, &stg);
 178    ok(r==S_OK, "StgCreateDocfile the windows media way failed\n");
 179    if (r == S_OK)
 180    {
 181       r = IStorage_Release(stg);
 182       ok(r == 0, "storage not released\n");
 183       ok(DeleteFileW(filename), "failed to delete file\n");
 184    }
 185
 186    /* looks like we need STGM_TRANSACTED or STGM_CREATE */
 187    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 188    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 189    if(r == S_OK)
 190    {
 191       r = IStorage_Release(stg);
 192       ok(r == 0, "storage not released\n");
 193       ok(DeleteFileW(filename), "failed to delete file\n");
 194    }
 195
 196    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_WRITE, 0, &stg);
 197    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 198    if(r == S_OK)
 199    {
 200       r = IStorage_Release(stg);
 201       ok(r == 0, "storage not released\n");
 202       ok(DeleteFileW(filename), "failed to delete file\n");
 203    }
 204
 205    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 206    ok(r==S_OK, "StgCreateDocfile the powerpoint way failed\n");
 207    if(r == S_OK)
 208    {
 209       r = IStorage_Release(stg);
 210       ok(r == 0, "storage not released\n");
 211       ok(DeleteFileW(filename), "failed to delete file\n");
 212    }
 213
 214    /* test the way msi uses StgCreateDocfile */
 215    r = StgCreateDocfile( filename, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg);
 216    ok(r==S_OK, "StgCreateDocFile failed\n");
 217    r = IStorage_Release(stg);
 218    ok(r == 0, "storage not released\n");
 219    ok(DeleteFileW(filename), "failed to delete file\n");
 220 }
 221
 222 static void test_storage_stream(void)
 223 {
 224     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 225     static const WCHAR szPrefix[] = { 's','t','g',0 };
 226     static const WCHAR szDot[] = { '.',0 };
 227     static const WCHAR longname[] = {
 228         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
 229         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
 230     };
 231     WCHAR filename[MAX_PATH];
 232     IStorage *stg = NULL;
 233     HRESULT r;
 234     IStream *stm = NULL;
 235     IStream *stm2 = NULL;
 236     ULONG count = 0;
 237     LARGE_INTEGER pos;
 238     ULARGE_INTEGER p;
 239     unsigned char buffer[0x100];
 240
 241     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 242         return;
 243
 244     DeleteFileW(filename);
 245
 246     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 247     ok(r==S_OK, "StgCreateDocfile failed\n");
 248
 249     /* try create some invalid streams */
 250     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, 0, &stm );
 251     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 252     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 1, &stm );
 253     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 254     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, NULL );
 255     ok(r==STG_E_INVALIDPOINTER, "IStorage->CreateStream wrong error\n");
 256     r = IStorage_CreateStream(stg, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 257     ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error\n");
 258     r = IStorage_CreateStream(stg, longname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 259     ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error, got %d GetLastError()=%d\n", r, GetLastError());
 260     r = IStorage_CreateStream(stg, stmname, STGM_READWRITE, 0, 0, &stm );
 261     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 262     r = IStorage_CreateStream(stg, stmname, STGM_READ, 0, 0, &stm );
 263     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 264     r = IStorage_CreateStream(stg, stmname, STGM_WRITE, 0, 0, &stm );
 265     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 266     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, 0, &stm );
 267     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 268     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READ, 0, 0, &stm );
 269     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 270
 271     /* now really create a stream and delete it */
 272     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 273     ok(r==S_OK, "IStorage->CreateStream failed\n");
 274     r = IStream_Release(stm);
 275     ok(r == 0, "wrong ref count\n");
 276     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 277     ok(r==STG_E_FILEALREADYEXISTS, "IStorage->CreateStream failed\n");
 278     r = IStorage_DestroyElement(stg,stmname);
 279     ok(r==S_OK, "IStorage->DestroyElement failed\n");
 280
 281     /* create a stream and write to it */
 282     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 283     ok(r==S_OK, "IStorage->CreateStream failed\n");
 284
 285     r = IStream_Clone(stm, &stm2);
 286     ok(r==S_OK, "failed to clone stream\n");
 287
 288     r = IStream_Write(stm, NULL, 0, NULL );
 289     ok(r==STG_E_INVALIDPOINTER, "IStream->Write wrong error\n");
 290     r = IStream_Write(stm, "Hello\n", 0, NULL );
 291     ok(r==S_OK, "failed to write stream\n");
 292     r = IStream_Write(stm, "Hello\n", 0, &count );
 293     ok(r==S_OK, "failed to write stream\n");
 294     r = IStream_Write(stm, "Hello\n", 6, &count );
 295     ok(r==S_OK, "failed to write stream\n");
 296     r = IStream_Commit(stm, STGC_DEFAULT );
 297     ok(r==S_OK, "failed to commit stream\n");
 298     r = IStream_Commit(stm, STGC_DEFAULT );
 299     ok(r==S_OK, "failed to commit stream\n");
 300
 301     /* seek round a bit, reset the stream size */
 302     pos.QuadPart = 0;
 303     r = IStream_Seek(stm, pos, 3, &p );
 304     ok(r==STG_E_INVALIDFUNCTION, "IStream->Seek returned wrong error\n");
 305     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
 306     ok(r==S_OK, "failed to seek stream\n");
 307     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 308     ok(r==S_OK, "failed to seek stream\n");
 309     r = IStream_SetSize(stm,p);
 310     ok(r==S_OK, "failed to set pos\n");
 311     pos.QuadPart = 10;
 312     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 313     ok(r==S_OK, "failed to seek stream\n");
 314     ok(p.QuadPart == 10, "at wrong place\n");
 315     pos.QuadPart = 0;
 316     r = IStream_Seek(stm, pos, STREAM_SEEK_END, &p );
 317     ok(r==S_OK, "failed to seek stream\n");
 318     ok(p.QuadPart == 0, "at wrong place\n");
 319     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 320     ok(r==S_OK, "failed to set pos\n");
 321     ok(count == 0, "read bytes from empty stream\n");
 322
 323     /* wrap up */
 324     r = IStream_Release(stm2);
 325     ok(r == 0, "wrong ref count\n");
 326     r = IStream_Release(stm);
 327     ok(r == 0, "wrong ref count\n");
 328     r = IStorage_Release(stg);
 329     ok(r == 0, "wrong ref count\n");
 330     r = DeleteFileW(filename);
 331     ok(r, "file should exist\n");
 332 }
 333
 334 static BOOL touch_file(LPCWSTR filename)
 335 {
 336     HANDLE file;
 337
 338     file = CreateFileW(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
 339                 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 340     if (file==INVALID_HANDLE_VALUE)
 341         return FALSE;
 342     CloseHandle(file);
 343     return TRUE;
 344 }
 345
 346 static BOOL is_zero_length(LPCWSTR filename)
 347 {
 348     HANDLE file;
 349     DWORD len;
 350
 351     file = CreateFileW(filename, GENERIC_READ, 0, NULL,
 352                 OPEN_EXISTING, 0, NULL);
 353     if (file==INVALID_HANDLE_VALUE)
 354         return FALSE;
 355     len = GetFileSize(file, NULL);
 356     CloseHandle(file);
 357     return len == 0;
 358 }
 359
 360 static BOOL is_existing_file(LPCWSTR filename)
 361 {
 362     HANDLE file;
 363
 364     file = CreateFileW(filename, GENERIC_READ, 0, NULL,
 365                        OPEN_EXISTING, 0, NULL);
 366     if (file==INVALID_HANDLE_VALUE)
 367         return FALSE;
 368     CloseHandle(file);
 369     return TRUE;
 370 }
 371
 372 static void test_open_storage(void)
 373 {
 374     static const WCHAR szPrefix[] = { 's','t','g',0 };
 375     static const WCHAR szNonExist[] = { 'n','o','n','e','x','i','s','t',0 };
 376     static const WCHAR szDot[] = { '.',0 };
 377     WCHAR filename[MAX_PATH];
 378     IStorage *stg = NULL, *stg2 = NULL;
 379     HRESULT r;
 380     DWORD stgm;
 381
 382     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 383         return;
 384
 385     /* try opening a zero length file - it should stay zero length */
 386     DeleteFileW(filename);
 387     touch_file(filename);
 388     stgm = STGM_NOSCRATCH | STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READWRITE;
 389     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 390     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 391
 392     stgm = STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
 393     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 394     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 395     ok(is_zero_length(filename), "file length changed\n");
 396
 397     DeleteFileW(filename);
 398
 399     /* try opening a nonexistent file - it should not create it */
 400     stgm = STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
 401     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 402     ok(r!=S_OK, "StgOpenStorage failed: 0x%08x\n", r);
 403     if (r==S_OK) IStorage_Release(stg);
 404     ok(!is_existing_file(filename), "StgOpenStorage should not create a file\n");
 405     DeleteFileW(filename);
 406
 407     /* create the file */
 408     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 409     ok(r==S_OK, "StgCreateDocfile failed\n");
 410     IStorage_Release(stg);
 411
 412     r = StgOpenStorage( filename, NULL, 0, NULL, 0, &stg);
 413     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage wrong error\n");
 414     r = StgOpenStorage( NULL, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 415     ok(r==STG_E_INVALIDNAME, "StgOpenStorage wrong error\n");
 416     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, NULL);
 417     ok(r==STG_E_INVALIDPOINTER, "StgOpenStorage wrong error\n");
 418     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 1, &stg);
 419     ok(r==STG_E_INVALIDPARAMETER, "StgOpenStorage wrong error\n");
 420     r = StgOpenStorage( szNonExist, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 421     ok(r==STG_E_FILENOTFOUND, "StgOpenStorage failed\n");
 422     r = StgOpenStorage( filename, NULL, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 423     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 424     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
 425     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 426     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_READ | STGM_READ, NULL, 0, &stg);
 427     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 428     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 429     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 430
 431     /* open it for real */
 432     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg); /* XLViewer 97/2000 */
 433     ok(r==S_OK, "StgOpenStorage failed\n");
 434     if(stg)
 435     {
 436         r = IStorage_Release(stg);
 437         ok(r == 0, "wrong ref count\n");
 438     }
 439
 440     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READ, NULL, 0, &stg);
 441     ok(r==S_OK, "StgOpenStorage failed\n");
 442     if(stg)
 443     {
 444         r = IStorage_Release(stg);
 445         ok(r == 0, "wrong ref count\n");
 446     }
 447
 448     /* test the way word opens its custom dictionary */
 449     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_TRANSACTED |
 450                         STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 451     ok(r==S_OK, "StgOpenStorage failed\n");
 452     if(stg)
 453     {
 454         r = IStorage_Release(stg);
 455         ok(r == 0, "wrong ref count\n");
 456     }
 457
 458     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 459     ok(r==S_OK, "StgOpenStorage failed\n");
 460     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2);
 461     ok(r==STG_E_SHAREVIOLATION, "StgOpenStorage failed\n");
 462     if(stg)
 463     {
 464         r = IStorage_Release(stg);
 465         ok(r == 0, "wrong ref count\n");
 466     }
 467
 468     /* now try write to a storage file we opened read-only */
 469     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 470     ok(r==S_OK, "StgOpenStorage failed\n");
 471     if(stg)
 472     {
 473         static const WCHAR stmname[] =  { 'w','i','n','e','t','e','s','t',0};
 474         IStream *stm = NULL;
 475         IStorage *stg2 = NULL;
 476
 477         r = IStorage_CreateStream( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
 478                                    0, 0, &stm );
 479         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 480         r = IStorage_CreateStorage( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
 481         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 482
 483         r = IStorage_Release(stg);
 484         ok(r == 0, "wrong ref count\n");
 485     }
 486
 487     /* open like visio 2003 */
 488     stg = NULL;
 489     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
 490     ok(r == S_OK, "should succeed\n");
 491     if (stg)
 492         IStorage_Release(stg);
 493
 494     /* test other sharing modes with STGM_PRIORITY */
 495     stg = NULL;
 496     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 497     ok(r == S_OK, "should succeed\n");
 498     if (stg)
 499         IStorage_Release(stg);
 500
 501     stg = NULL;
 502     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 503     ok(r == S_OK, "should succeed\n");
 504     if (stg)
 505         IStorage_Release(stg);
 506
 507     stg = NULL;
 508     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_READ, NULL, 0, &stg);
 509     ok(r == S_OK, "should succeed\n");
 510     if (stg)
 511         IStorage_Release(stg);
 512
 513     /* open like Project 2003 */
 514     stg = NULL;
 515     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg);
 516     ok(r == S_OK, "should succeed\n");
 517     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg2);
 518     ok(r == S_OK, "should succeed\n");
 519     if (stg2)
 520         IStorage_Release(stg2);
 521     if (stg)
 522         IStorage_Release(stg);
 523
 524     stg = NULL;
 525     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_READWRITE, NULL, 0, &stg);
 526     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 527
 528     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_PRIORITY, NULL, 0, &stg);
 529     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 530
 531     r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_PRIORITY, NULL, 0, &stg);
 532     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 533
 534     r = StgOpenStorage( filename, NULL, STGM_DELETEONRELEASE | STGM_PRIORITY, NULL, 0, &stg);
 535     ok(r == STG_E_INVALIDFUNCTION, "should fail\n");
 536
 537     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_PRIORITY, NULL, 0, &stg);
 538     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 539
 540     r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg);
 541     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 542
 543     r = DeleteFileW(filename);
 544     ok(r, "file didn't exist\n");
 545 }
 546
 547 static void test_storage_suminfo(void)
 548 {
 549     static const WCHAR szDot[] = { '.',0 };
 550     static const WCHAR szPrefix[] = { 's','t','g',0 };
 551     WCHAR filename[MAX_PATH];
 552     IStorage *stg = NULL;
 553     IPropertySetStorage *propset = NULL;
 554     IPropertyStorage *ps = NULL;
 555     HRESULT r;
 556
 557     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 558         return;
 559
 560     DeleteFileW(filename);
 561
 562     /* create the file */
 563     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 564                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 565     ok(r==S_OK, "StgCreateDocfile failed\n");
 566
 567     r = IStorage_QueryInterface( stg, &IID_IPropertySetStorage, (LPVOID) &propset );
 568     ok(r == S_OK, "query interface failed\n");
 569
 570     /* delete it */
 571     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 572     ok(r == STG_E_FILENOTFOUND, "deleted property set storage\n");
 573
 574     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 575                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 576     ok(r == STG_E_FILENOTFOUND, "opened property set storage\n");
 577
 578     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 579                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 580     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 581
 582     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 583                                 STGM_READ, &ps );
 584     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 585
 586     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0, 0, &ps );
 587     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 588
 589     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 590                                 STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 591     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 592
 593     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 594                                 STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 595     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 596
 597     /* now try really creating a property set */
 598     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 599                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 600     ok(r == S_OK, "failed to create property set storage\n");
 601
 602     if( ps )
 603         IPropertyStorage_Release(ps);
 604
 605     /* now try creating the same thing again */
 606     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 607                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 608     ok(r == S_OK, "failed to create property set storage\n");
 609     if( ps )
 610         IPropertyStorage_Release(ps);
 611
 612     /* should be able to open it */
 613     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 614             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 615     ok(r == S_OK, "open failed\n");
 616     if(r == S_OK)
 617         IPropertyStorage_Release(ps);
 618
 619     /* delete it */
 620     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 621     ok(r == S_OK, "failed to delete property set storage\n");
 622
 623     /* try opening with an invalid FMTID */
 624     r = IPropertySetStorage_Open( propset, NULL,
 625             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 626     ok(r == E_INVALIDARG, "open succeeded\n");
 627     if(r == S_OK)
 628         IPropertyStorage_Release(ps);
 629
 630     /* try a bad guid */
 631     r = IPropertySetStorage_Open( propset, &IID_IStorage,
 632             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 633     ok(r == STG_E_FILENOTFOUND, "open succeeded\n");
 634     if(r == S_OK)
 635         IPropertyStorage_Release(ps);
 636
 637
 638     /* try some invalid flags */
 639     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 640             STGM_CREATE | STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 641     ok(r == STG_E_INVALIDFLAG, "open succeeded\n");
 642     if(r == S_OK)
 643         IPropertyStorage_Release(ps);
 644
 645     /* after deleting it, it should be gone */
 646     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 647             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 648     ok(r == STG_E_FILENOTFOUND, "open failed\n");
 649     if(r == S_OK)
 650         IPropertyStorage_Release(ps);
 651
 652     r = IPropertySetStorage_Release( propset );
 653     ok(r == 1, "ref count wrong\n");
 654
 655     r = IStorage_Release(stg);
 656     ok(r == 0, "ref count wrong\n");
 657
 658     DeleteFileW(filename);
 659 }
 660
 661 static void test_storage_refcount(void)
 662 {
 663     static const WCHAR szPrefix[] = { 's','t','g',0 };
 664     static const WCHAR szDot[] = { '.',0 };
 665     WCHAR filename[MAX_PATH];
 666     IStorage *stg = NULL;
 667     IStorage *stgprio = NULL;
 668     HRESULT r;
 669     IStream *stm = NULL;
 670     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 671     LARGE_INTEGER pos;
 672     ULARGE_INTEGER upos;
 673     STATSTG stat;
 674     char buffer[10];
 675
 676     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 677         return;
 678
 679     DeleteFileW(filename);
 680
 681     /* create the file */
 682     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 683                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 684     ok(r==S_OK, "StgCreateDocfile failed\n");
 685
 686     r = WriteClassStg( stg, &test_stg_cls );
 687     ok( r == S_OK, "WriteClassStg failed\n");
 688
 689     r = IStorage_Commit( stg, STGC_DEFAULT );
 690     ok( r == S_OK, "IStorage_Commit failed\n");
 691
 692     /* now create a stream */
 693     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 694     ok(r==S_OK, "IStorage->CreateStream failed\n");
 695
 696     r = IStorage_Release( stg );
 697     ok (r == 0, "storage not released\n");
 698
 699     pos.QuadPart = 0;
 700     r = IStream_Seek( stm, pos, 0, &upos );
 701     ok (r == STG_E_REVERTED, "seek should fail\n");
 702
 703     r = IStream_Stat( stm, &stat, STATFLAG_DEFAULT );
 704     ok (r == STG_E_REVERTED, "stat should fail\n");
 705
 706     r = IStream_Write( stm, "Test string", strlen("Test string"), NULL);
 707     ok (r == STG_E_REVERTED, "IStream_Write should return STG_E_REVERTED instead of 0x%08x\n", r);
 708
 709     r = IStream_Read( stm, buffer, sizeof(buffer), NULL);
 710     ok (r == STG_E_REVERTED, "IStream_Read should return STG_E_REVERTED instead of 0x%08x\n", r);
 711
 712     r = IStream_Release(stm);
 713     ok (r == 0, "stream not released\n");
 714
 715     /* tests that STGM_PRIORITY doesn't prevent readwrite access from other
 716      * StgOpenStorage calls in transacted mode */
 717     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stgprio);
 718     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
 719
 720     todo_wine {
 721     /* non-transacted mode read/write fails */
 722     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
 723     ok(r==STG_E_LOCKVIOLATION, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08x\n", r);
 724     }
 725
 726     /* non-transacted mode read-only succeeds */
 727     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE|STGM_READ, NULL, 0, &stg);
 728     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
 729     IStorage_Release(stg);
 730
 731     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, NULL, 0, &stg);
 732     ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
 733     if(stg)
 734     {
 735         static const WCHAR stgname[] = { ' ',' ',' ','2','9',0 };
 736         static const WCHAR stgname2[] = { 'C','V','_','i','e','w',0 };
 737         static const WCHAR stmname2[] = { 'V','a','r','2','D','a','t','a',0 };
 738         IStorage *stg2;
 739         IStorage *stg3;
 740         STATSTG statstg;
 741
 742         r = IStorage_Stat( stg, &statstg, STATFLAG_NONAME );
 743         ok(r == S_OK, "Stat should have succeded instead of returning 0x%08x\n", r);
 744         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
 745         ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
 746         ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
 747         ok(statstg.grfMode == (STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE),
 748             "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg.grfMode);
 749         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
 750         ok(IsEqualCLSID(&statstg.clsid, &test_stg_cls), "Statstg clsid is not test_stg_cls\n");
 751         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
 752         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
 753
 754         r = IStorage_CreateStorage( stg, stgname, STGM_SHARE_EXCLUSIVE, 0, 0, &stg2 );
 755         ok(r == S_OK, "CreateStorage should have succeeded instead of returning 0x%08x\n", r);
 756
 757         r = IStorage_Stat( stg2, &statstg, STATFLAG_DEFAULT );
 758         ok(r == S_OK, "Stat should have succeded instead of returning 0x%08x\n", r);
 759         ok(!lstrcmpW(statstg.pwcsName, stgname),
 760             "Statstg pwcsName should have been the name the storage was created with\n");
 761         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
 762         ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
 763         ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
 764         ok(statstg.grfMode == STGM_SHARE_EXCLUSIVE,
 765             "Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%x\n", statstg.grfMode);
 766         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
 767         ok(IsEqualCLSID(&statstg.clsid, &CLSID_NULL), "Statstg clsid is not CLSID_NULL\n");
 768         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
 769         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
 770         CoTaskMemFree(statstg.pwcsName);
 771
 772         r = IStorage_CreateStorage( stg2, stgname2, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stg3 );
 773         ok(r == STG_E_ACCESSDENIED, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
 774
 775         r = IStorage_CreateStream( stg2, stmname2, STGM_CREATE|STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
 776         ok(r == STG_E_ACCESSDENIED, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
 777
 778         IStorage_Release(stg2);
 779
 780         r = IStorage_Release(stg);
 781         ok(r == 0, "wrong ref count\n");
 782     }
 783     IStorage_Release(stgprio);
 784
 785     DeleteFileW(filename);
 786 }
 787
 788 static void test_streamenum(void)
 789 {
 790     static const WCHAR szPrefix[] = { 's','t','g',0 };
 791     static const WCHAR szDot[] = { '.',0 };
 792     WCHAR filename[MAX_PATH];
 793     IStorage *stg = NULL;
 794     HRESULT r;
 795     IStream *stm = NULL;
 796     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 797     STATSTG stat;
 798     IEnumSTATSTG *ee = NULL;
 799     ULONG count;
 800
 801     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 802         return;
 803
 804     DeleteFileW(filename);
 805
 806     /* create the file */
 807     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 808                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 809     ok(r==S_OK, "StgCreateDocfile failed\n");
 810
 811     r = WriteClassStg( stg, &test_stg_cls );
 812     ok( r == S_OK, "WriteClassStg failed\n");
 813
 814     r = IStorage_Commit( stg, STGC_DEFAULT );
 815     ok( r == S_OK, "IStorage_Commit failed\n");
 816
 817     /* now create a stream */
 818     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 819     ok(r==S_OK, "IStorage->CreateStream failed\n");
 820
 821     r = IStream_Release(stm);
 822
 823     /* first enum ... should be 1 stream */
 824     r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
 825     ok(r==S_OK, "IStorage->EnumElements failed\n");
 826
 827     count = 0xf00;
 828     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
 829     ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
 830     ok(count == 1, "count wrong\n");
 831
 832     r = IEnumSTATSTG_Release(ee);
 833
 834     /* second enum... destroy the stream before reading */
 835     r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
 836     ok(r==S_OK, "IStorage->EnumElements failed\n");
 837
 838     r = IStorage_DestroyElement(stg, stmname);
 839     ok(r==S_OK, "IStorage->EnumElements failed\n");
 840
 841     todo_wine {
 842     count = 0xf00;
 843     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
 844     ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
 845     ok(count == 0, "count wrong\n");
 846     }
 847
 848     /* reset and try again */
 849     r = IEnumSTATSTG_Reset(ee);
 850     ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
 851
 852     count = 0xf00;
 853     r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
 854     ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
 855     ok(count == 0, "count wrong\n");
 856
 857     r = IEnumSTATSTG_Release(ee);
 858     ok (r == 0, "enum not released\n");
 859
 860     r = IStorage_Release( stg );
 861     ok (r == 0, "storage not released\n");
 862
 863     DeleteFileW(filename);
 864 }
 865
 866 static void test_transact(void)
 867 {
 868     static const WCHAR szPrefix[] = { 's','t','g',0 };
 869     static const WCHAR szDot[] = { '.',0 };
 870     WCHAR filename[MAX_PATH];
 871     IStorage *stg = NULL, *stg2 = NULL;
 872     HRESULT r;
 873     IStream *stm = NULL;
 874     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 875     static const WCHAR stmname2[] = { 'F','O','O',0 };
 876
 877     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 878         return;
 879
 880     DeleteFileW(filename);
 881
 882     /* create the file */
 883     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 884                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 885     ok(r==S_OK, "StgCreateDocfile failed\n");
 886
 887     /* now create a stream, but don't commit it */
 888     r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 889     ok(r==S_OK, "IStorage->CreateStream failed\n");
 890
 891     r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
 892     ok(r==S_OK, "IStream->Write failed\n");
 893
 894     r = IStream_Release(stm);
 895
 896     r = IStorage_Commit(stg, 0);
 897     ok(r==S_OK, "IStorage->Commit failed\n");
 898
 899     /* now create a stream, but don't commit it */
 900     stm = NULL;
 901     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 902     ok(r==S_OK, "IStorage->CreateStream failed\n");
 903
 904     r = IStream_Write(stm, "this is stream 2\n", 16, NULL);
 905     ok(r==S_OK, "IStream->Write failed\n");
 906
 907     r = IStream_Commit(stm, STGC_ONLYIFCURRENT | STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
 908     ok(r==S_OK, "IStream->Commit failed\n");
 909
 910     r = IStream_Release(stm);
 911
 912     IStorage_Release(stg);
 913
 914     stm = NULL;
 915     stg = NULL;
 916     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg);
 917     ok(r==S_OK, "StgOpenStorage failed\n");
 918
 919     if (!stg)
 920         return;
 921
 922     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
 923     ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
 924
 925     r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
 926     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
 927
 928     r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
 929     ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
 930
 931     r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
 932     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
 933
 934     todo_wine {
 935     r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
 936     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
 937     }
 938     if (stm)
 939         r = IStream_Release(stm);
 940
 941     r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
 942     ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
 943
 944     r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
 945     ok(r==S_OK, "IStorage->OpenStream should fail %08x\n", r);
 946     if (stm)
 947         r = IStream_Release(stm);
 948
 949     IStorage_Release(stg);
 950
 951     r = DeleteFileW(filename);
 952     ok( r == TRUE, "deleted file\n");
 953 }
 954
 955 static void test_ReadClassStm(void)
 956 {
 957     CLSID clsid;
 958     HRESULT hr;
 959     IStream *pStream;
 960     static const LARGE_INTEGER llZero;
 961
 962     hr = ReadClassStm(NULL, &clsid);
 963     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 964
 965     hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
 966     ok_ole_success(hr, "CreateStreamOnHGlobal");
 967     hr = WriteClassStm(pStream, &test_stg_cls);
 968     ok_ole_success(hr, "WriteClassStm");
 969
 970     hr = ReadClassStm(pStream, NULL);
 971     ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
 972
 973     /* test not rewound stream */
 974     hr = ReadClassStm(pStream, &clsid);
 975     ok(hr == STG_E_READFAULT, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
 976     ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid should have been zeroed\n");
 977
 978     hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
 979     ok_ole_success(hr, "IStream_Seek");
 980     hr = ReadClassStm(pStream, &clsid);
 981     ok_ole_success(hr, "ReadClassStm");
 982     ok(IsEqualCLSID(&clsid, &test_stg_cls), "clsid should have been set to CLSID_WineTest\n");
 983 }
 984
 985 START_TEST(storage32)
 986 {
 987     test_hglobal_storage_stat();
 988     test_create_storage_modes();
 989     test_storage_stream();
 990     test_open_storage();
 991     test_storage_suminfo();
 992     test_storage_refcount();
 993     test_streamenum();
 994     test_transact();
 995     test_ReadClassStm();
 996 }