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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  19  */
  20
  21 #include <stdio.h>
  22
  23 #define COBJMACROS
  24
  25 #include "wine/test.h"
  26 #include "windef.h"
  27 #include "winbase.h"
  28 #include "winerror.h"
  29 #include "ole2.h"
  30 #include "objidl.h"
  31 #include "initguid.h"
  32
  33 DEFINE_GUID( test_stg_cls, 0x88888888, 0x0425, 0x0000, 0,0,0,0,0,0,0,0);
  34
  35 static void test_hglobal_storage_stat(void)
  36 {
  37     ILockBytes *ilb = NULL;
  38     IStorage *stg = NULL;
  39     HRESULT r;
  40     STATSTG stat;
  41     DWORD mode, refcount;
  42
  43     r = CreateILockBytesOnHGlobal( NULL, TRUE, &ilb );
  44     ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
  45
  46     mode = STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE;/*0x1012*/
  47     r = StgCreateDocfileOnILockBytes( ilb, mode, 0,  &stg );
  48     ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
  49
  50     r = WriteClassStg( stg, &test_stg_cls );
  51     ok( r == S_OK, "WriteClassStg failed\n");
  52
  53     memset( &stat, 0, sizeof stat );
  54     r = IStorage_Stat( stg, &stat, 0 );
  55
  56     ok( stat.pwcsName == NULL, "storage name not null\n");
  57     ok( stat.type == 1, "type is wrong\n");
  58     ok( stat.grfMode == 0x12, "grf mode is incorrect\n");
  59     ok( !memcmp(&stat.clsid, &test_stg_cls, sizeof test_stg_cls), "CLSID is wrong\n");
  60
  61     refcount = IStorage_Release( stg );
  62     ok( refcount == 0, "IStorage refcount is wrong\n");
  63     refcount = ILockBytes_Release( ilb );
  64     ok( refcount == 0, "ILockBytes refcount is wrong\n");
  65 }
  66
  67 static void test_create_storage_modes(void)
  68 {
  69    static const WCHAR szPrefix[] = { 's','t','g',0 };
  70    static const WCHAR szDot[] = { '.',0 };
  71    WCHAR filename[MAX_PATH];
  72    IStorage *stg = NULL;
  73    HRESULT r;
  74
  75    if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
  76       return;
  77
  78    DeleteFileW(filename);
  79
  80    /* test with some invalid parameters */
  81    r = StgCreateDocfile( NULL, 0, 0, &stg);
  82    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  83    r = StgCreateDocfile( filename, 0, 0, &stg);
  84    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  85    r = StgCreateDocfile( filename, STGM_CREATE, 0, &stg);
  86    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  87    r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE, 0, &stg);
  88    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  89    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &stg);
  90    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  91    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, NULL);
  92    ok(r==STG_E_INVALIDPOINTER, "StgCreateDocfile succeeded\n");
  93    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, &stg);
  94    ok(r==STG_E_INVALIDPARAMETER, "StgCreateDocfile succeeded\n");
  95    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
  96    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  97    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READ, 0, &stg);
  98    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
  99    r = StgCreateDocfile( filename, STGM_PRIORITY, 0, &stg);
 100    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 101
 102    /* StgCreateDocfile seems to be very particular about the flags it accepts */
 103    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | STGM_WRITE, 0, &stg);
 104    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 105    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 8, 0, &stg);
 106    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 107    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80, 0, &stg);
 108    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 109    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800, 0, &stg);
 110    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 111    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x8000, 0, &stg);
 112    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 113    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80000, 0, &stg);
 114    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 115    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800000, 0, &stg);
 116    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 117    ok(stg == NULL, "stg was set\n");
 118
 119    /* check what happens if the file already exists */
 120    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 121    ok(r==S_OK, "StgCreateDocfile failed\n");
 122    r = IStorage_Release(stg);
 123    ok(r == 0, "storage not released\n");
 124    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 125    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 126    r = StgCreateDocfile( filename, STGM_READ, 0, &stg);
 127    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 128    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE, 0, &stg);
 129    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 130    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE, 0, &stg);
 131    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 132    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE, 0, &stg);
 133    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 134    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
 135    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 136    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, &stg);
 137    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 138    r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_WRITE, 0, &stg);
 139    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 140    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_WRITE, 0, &stg);
 141    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
 142    r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
 143    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
 144    ok(DeleteFileW(filename), "failed to delete file\n");
 145
 146    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 147    ok(r==S_OK, "StgCreateDocfile failed\n");
 148    r = IStorage_Release(stg);
 149    ok(r == 0, "storage not released\n");
 150    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED |STGM_FAILIFTHERE, 0, &stg);
 151    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 152    r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_WRITE, 0, &stg);
 153    ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
 154
 155    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
 156    ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
 157    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 158    ok(r==S_OK, "StgCreateDocfile failed\n");
 159    r = IStorage_Release(stg);
 160    ok(r == 0, "storage not released\n");
 161
 162    ok(DeleteFileW(filename), "failed to delete file\n");
 163
 164    /* test the way excel uses StgCreateDocFile */
 165    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 166    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 167    if(r == S_OK)
 168    {
 169       r = IStorage_Release(stg);
 170       ok(r == 0, "storage not released\n");
 171       ok(DeleteFileW(filename), "failed to delete file\n");
 172    }
 173
 174    /* looks like we need STGM_TRANSACTED or STGM_CREATE */
 175    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
 176    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 177    if(r == S_OK)
 178    {
 179       r = IStorage_Release(stg);
 180       ok(r == 0, "storage not released\n");
 181       ok(DeleteFileW(filename), "failed to delete file\n");
 182    }
 183
 184    r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_WRITE, 0, &stg);
 185    ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
 186    if(r == S_OK)
 187    {
 188       r = IStorage_Release(stg);
 189       ok(r == 0, "storage not released\n");
 190       ok(DeleteFileW(filename), "failed to delete file\n");
 191    }
 192
 193    r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
 194    ok(r==S_OK, "StgCreateDocfile the powerpoint way failed\n");
 195    if(r == S_OK)
 196    {
 197       r = IStorage_Release(stg);
 198       ok(r == 0, "storage not released\n");
 199       ok(DeleteFileW(filename), "failed to delete file\n");
 200    }
 201
 202    /* test the way msi uses StgCreateDocfile */
 203    r = StgCreateDocfile( filename, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg);
 204    ok(r==S_OK, "StgCreateDocFile failed\n");
 205    r = IStorage_Release(stg);
 206    ok(r == 0, "storage not released\n");
 207    ok(DeleteFileW(filename), "failed to delete file\n");
 208 }
 209
 210 static void test_storage_stream(void)
 211 {
 212     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 213     static const WCHAR szPrefix[] = { 's','t','g',0 };
 214     static const WCHAR szDot[] = { '.',0 };
 215     static const WCHAR longname[] = {
 216         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
 217         'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
 218     };
 219     WCHAR filename[MAX_PATH];
 220     IStorage *stg = NULL;
 221     HRESULT r;
 222     IStream *stm = NULL;
 223     ULONG count = 0;
 224     LARGE_INTEGER pos;
 225     ULARGE_INTEGER p;
 226     unsigned char buffer[0x100];
 227
 228     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 229         return;
 230
 231     DeleteFileW(filename);
 232
 233     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 234     ok(r==S_OK, "StgCreateDocfile failed\n");
 235
 236     /* try create some invalid streams */
 237     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, 0, &stm );
 238     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 239     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 1, &stm );
 240     ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
 241     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, NULL );
 242     ok(r==STG_E_INVALIDPOINTER, "IStorage->CreateStream wrong error\n");
 243     r = IStorage_CreateStream(stg, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 244     ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error\n");
 245     r = IStorage_CreateStream(stg, longname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 246     ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error, got %ld GetLastError()=%ld\n", r, GetLastError());
 247     r = IStorage_CreateStream(stg, stmname, STGM_READWRITE, 0, 0, &stm );
 248     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 249     r = IStorage_CreateStream(stg, stmname, STGM_READ, 0, 0, &stm );
 250     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 251     r = IStorage_CreateStream(stg, stmname, STGM_WRITE, 0, 0, &stm );
 252     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 253     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, 0, &stm );
 254     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 255     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READ, 0, 0, &stm );
 256     ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
 257
 258     /* now really create a stream and delete it */
 259     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 260     ok(r==S_OK, "IStorage->CreateStream failed\n");
 261     r = IStream_Release(stm);
 262     ok(r == 0, "wrong ref count\n");
 263     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 264     ok(r==STG_E_FILEALREADYEXISTS, "IStorage->CreateStream failed\n");
 265     r = IStorage_DestroyElement(stg,stmname);
 266     ok(r==S_OK, "IStorage->DestroyElement failed\n");
 267
 268     /* create a stream and write to it */
 269     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 270     ok(r==S_OK, "IStorage->CreateStream failed\n");
 271
 272     r = IStream_Write(stm, NULL, 0, NULL );
 273     ok(r==STG_E_INVALIDPOINTER, "IStream->Write wrong error\n");
 274     r = IStream_Write(stm, "Hello\n", 0, NULL );
 275     ok(r==S_OK, "failed to write stream\n");
 276     r = IStream_Write(stm, "Hello\n", 0, &count );
 277     ok(r==S_OK, "failed to write stream\n");
 278     r = IStream_Write(stm, "Hello\n", 6, &count );
 279     ok(r==S_OK, "failed to write stream\n");
 280     r = IStream_Commit(stm, STGC_DEFAULT );
 281     ok(r==S_OK, "failed to commit stream\n");
 282     r = IStream_Commit(stm, STGC_DEFAULT );
 283     ok(r==S_OK, "failed to commit stream\n");
 284
 285     /* seek round a bit, reset the stream size */
 286     pos.QuadPart = 0;
 287     r = IStream_Seek(stm, pos, 3, &p );
 288     ok(r==STG_E_INVALIDFUNCTION, "IStream->Seek returned wrong error\n");
 289     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
 290     ok(r==S_OK, "failed to seek stream\n");
 291     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 292     ok(r==S_OK, "failed to seek stream\n");
 293     r = IStream_SetSize(stm,p);
 294     ok(r==S_OK, "failed to set pos\n");
 295     pos.QuadPart = 10;
 296     r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
 297     ok(r==S_OK, "failed to seek stream\n");
 298     ok(p.QuadPart == 10, "at wrong place\n");
 299     pos.QuadPart = 0;
 300     r = IStream_Seek(stm, pos, STREAM_SEEK_END, &p );
 301     ok(r==S_OK, "failed to seek stream\n");
 302     ok(p.QuadPart == 0, "at wrong place\n");
 303     r = IStream_Read(stm, buffer, sizeof buffer, &count );
 304     ok(r==S_OK, "failed to set pos\n");
 305     ok(count == 0, "read bytes from empty stream\n");
 306
 307     /* wrap up */
 308     r = IStream_Release(stm);
 309     ok(r == 0, "wrong ref count\n");
 310     r = IStorage_Release(stg);
 311     ok(r == 0, "wrong ref count\n");
 312     r = DeleteFileW(filename);
 313     ok(r, "file should exist\n");
 314 }
 315
 316 static BOOL touch_file(LPCWSTR filename)
 317 {
 318     HANDLE file;
 319
 320     file = CreateFileW(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
 321                 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
 322     if (file==INVALID_HANDLE_VALUE)
 323         return FALSE;
 324     CloseHandle(file);
 325     return TRUE;
 326 }
 327
 328 static BOOL is_zero_length(LPCWSTR filename)
 329 {
 330     HANDLE file;
 331     DWORD len;
 332
 333     file = CreateFileW(filename, GENERIC_READ, 0, NULL,
 334                 OPEN_EXISTING, 0, NULL);
 335     if (file==INVALID_HANDLE_VALUE)
 336         return FALSE;
 337     len = GetFileSize(file, NULL);
 338     CloseHandle(file);
 339     return len == 0;
 340 }
 341
 342 static void test_open_storage(void)
 343 {
 344     static const WCHAR szPrefix[] = { 's','t','g',0 };
 345     static const WCHAR szNonExist[] = { 'n','o','n','e','x','i','s','t',0 };
 346     static const WCHAR szDot[] = { '.',0 };
 347     WCHAR filename[MAX_PATH];
 348     IStorage *stg = NULL, *stg2 = NULL;
 349     HRESULT r;
 350     DWORD stgm;
 351
 352     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 353         return;
 354
 355     /* try opening a zero length file - it should stay zero length */
 356     DeleteFileW(filename);
 357     touch_file(filename);
 358     stgm = STGM_NOSCRATCH | STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READWRITE;
 359     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 360     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 361
 362     stgm = STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
 363     r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
 364     ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
 365     ok(is_zero_length(filename), "file length changed\n");
 366
 367     DeleteFileW(filename);
 368
 369     /* create the file */
 370     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 371     ok(r==S_OK, "StgCreateDocfile failed\n");
 372     IStorage_Release(stg);
 373
 374     r = StgOpenStorage( filename, NULL, 0, NULL, 0, &stg);
 375     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage wrong error\n");
 376     r = StgOpenStorage( NULL, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 377     ok(r==STG_E_INVALIDNAME, "StgOpenStorage wrong error\n");
 378     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, NULL);
 379     ok(r==STG_E_INVALIDPOINTER, "StgOpenStorage wrong error\n");
 380     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 1, &stg);
 381     ok(r==STG_E_INVALIDPARAMETER, "StgOpenStorage wrong error\n");
 382     r = StgOpenStorage( szNonExist, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 383     ok(r==STG_E_FILENOTFOUND, "StgOpenStorage failed\n");
 384     r = StgOpenStorage( filename, NULL, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 385     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 386     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
 387     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 388     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_READ | STGM_READ, NULL, 0, &stg);
 389     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 390     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 391     ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
 392
 393     /* open it for real */
 394     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg); /* XLViewer 97/2000 */
 395     ok(r==S_OK, "StgOpenStorage failed\n");
 396     if(stg)
 397     {
 398         r = IStorage_Release(stg);
 399         ok(r == 0, "wrong ref count\n");
 400     }
 401
 402     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READ, NULL, 0, &stg);
 403     ok(r==S_OK, "StgOpenStorage failed\n");
 404     if(stg)
 405     {
 406         r = IStorage_Release(stg);
 407         ok(r == 0, "wrong ref count\n");
 408     }
 409
 410     /* test the way word opens its custom dictionary */
 411     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_TRANSACTED |
 412                         STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
 413     ok(r==S_OK, "StgOpenStorage failed\n");
 414     if(stg)
 415     {
 416         r = IStorage_Release(stg);
 417         ok(r == 0, "wrong ref count\n");
 418     }
 419
 420     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 421     ok(r==S_OK, "StgOpenStorage failed\n");
 422     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2);
 423     ok(r==STG_E_SHAREVIOLATION, "StgOpenStorage failed\n");
 424     if(stg)
 425     {
 426         r = IStorage_Release(stg);
 427         ok(r == 0, "wrong ref count\n");
 428     }
 429
 430     /* now try write to a storage file we opened read-only */
 431     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
 432     ok(r==S_OK, "StgOpenStorage failed\n");
 433     if(stg)
 434     {
 435         static const WCHAR stmname[] =  { 'w','i','n','e','t','e','s','t',0};
 436         IStream *stm = NULL;
 437         IStorage *stg2 = NULL;
 438
 439         r = IStorage_CreateStream( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
 440                                    0, 0, &stm );
 441         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 442         r = IStorage_CreateStorage( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
 443         ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
 444
 445         r = IStorage_Release(stg);
 446         ok(r == 0, "wrong ref count\n");
 447     }
 448
 449     /* open like visio 2003 */
 450     stg = NULL;
 451     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
 452     ok(r == S_OK, "should succeed\n");
 453     if (stg)
 454         IStorage_Release(stg);
 455
 456     /* test other sharing modes with STGM_PRIORITY */
 457     stg = NULL;
 458     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
 459     ok(r == S_OK, "should succeed\n");
 460     if (stg)
 461         IStorage_Release(stg);
 462
 463     stg = NULL;
 464     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
 465     ok(r == S_OK, "should succeed\n");
 466     if (stg)
 467         IStorage_Release(stg);
 468
 469     stg = NULL;
 470     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_READ, NULL, 0, &stg);
 471     ok(r == S_OK, "should succeed\n");
 472     if (stg)
 473         IStorage_Release(stg);
 474
 475     /* open like Project 2003 */
 476     stg = NULL;
 477     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg);
 478     ok(r == S_OK, "should succeed\n");
 479     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg2);
 480     ok(r == S_OK, "should succeed\n");
 481     if (stg2)
 482         IStorage_Release(stg2);
 483     if (stg)
 484         IStorage_Release(stg);
 485
 486     stg = NULL;
 487     r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_READWRITE, NULL, 0, &stg);
 488     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 489
 490     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_PRIORITY, NULL, 0, &stg);
 491     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 492
 493     r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_PRIORITY, NULL, 0, &stg);
 494     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 495
 496     r = StgOpenStorage( filename, NULL, STGM_DELETEONRELEASE | STGM_PRIORITY, NULL, 0, &stg);
 497     ok(r == STG_E_INVALIDFUNCTION, "should fail\n");
 498
 499     r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_PRIORITY, NULL, 0, &stg);
 500     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 501
 502     r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg);
 503     ok(r == STG_E_INVALIDFLAG, "should fail\n");
 504
 505     r = DeleteFileW(filename);
 506     ok(r, "file didn't exist\n");
 507 }
 508
 509 static void test_storage_suminfo(void)
 510 {
 511     static const WCHAR szDot[] = { '.',0 };
 512     static const WCHAR szPrefix[] = { 's','t','g',0 };
 513     WCHAR filename[MAX_PATH];
 514     IStorage *stg = NULL;
 515     IPropertySetStorage *propset = NULL;
 516     IPropertyStorage *ps = NULL;
 517     HRESULT r;
 518
 519     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 520         return;
 521
 522     DeleteFileW(filename);
 523
 524     /* create the file */
 525     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 526                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 527     ok(r==S_OK, "StgCreateDocfile failed\n");
 528
 529     r = IStorage_QueryInterface( stg, &IID_IPropertySetStorage, (LPVOID) &propset );
 530     ok(r == S_OK, "query interface failed\n");
 531
 532     /* delete it */
 533     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 534     ok(r == STG_E_FILENOTFOUND, "deleted property set storage\n");
 535
 536     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 537                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 538     ok(r == STG_E_FILENOTFOUND, "opened property set storage\n");
 539
 540     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 541                                 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
 542     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 543
 544     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 545                                 STGM_READ, &ps );
 546     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 547
 548     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0, 0, &ps );
 549     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 550
 551     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 552                                 STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 553     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 554
 555     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 556                                 STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
 557     ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
 558
 559     /* now try really creating a a property set */
 560     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 561                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 562     ok(r == S_OK, "failed to create property set storage\n");
 563
 564     if( ps )
 565         IPropertyStorage_Release(ps);
 566
 567     /* now try creating the same thing again */
 568     r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
 569                                 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
 570     ok(r == S_OK, "failed to create property set storage\n");
 571     if( ps )
 572         IPropertyStorage_Release(ps);
 573
 574     /* should be able to open it */
 575     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 576             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 577     ok(r == S_OK, "open failed\n");
 578     if(r == S_OK)
 579         IPropertyStorage_Release(ps);
 580
 581     /* delete it */
 582     r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
 583     ok(r == S_OK, "failed to delete property set storage\n");
 584
 585     /* try opening with an invalid FMTID */
 586     r = IPropertySetStorage_Open( propset, NULL,
 587             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 588     ok(r == E_INVALIDARG, "open succeeded\n");
 589     if(r == S_OK)
 590         IPropertyStorage_Release(ps);
 591
 592     /* try a bad guid */
 593     r = IPropertySetStorage_Open( propset, &IID_IStorage,
 594             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 595     ok(r == STG_E_FILENOTFOUND, "open succeeded\n");
 596     if(r == S_OK)
 597         IPropertyStorage_Release(ps);
 598
 599
 600     /* try some invalid flags */
 601     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 602             STGM_CREATE | STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 603     ok(r == STG_E_INVALIDFLAG, "open succeeded\n");
 604     if(r == S_OK)
 605         IPropertyStorage_Release(ps);
 606
 607     /* after deleting it, it should be gone */
 608     r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
 609             STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
 610     ok(r == STG_E_FILENOTFOUND, "open failed\n");
 611     if(r == S_OK)
 612         IPropertyStorage_Release(ps);
 613
 614     r = IPropertySetStorage_Release( propset );
 615     ok(r == 1, "ref count wrong\n");
 616
 617     r = IStorage_Release(stg);
 618     ok(r == 0, "ref count wrong\n");
 619
 620     DeleteFileW(filename);
 621 }
 622
 623 static void test_storage_refcount(void)
 624 {
 625     static const WCHAR szPrefix[] = { 's','t','g',0 };
 626     static const WCHAR szDot[] = { '.',0 };
 627     WCHAR filename[MAX_PATH];
 628     IStorage *stg = NULL;
 629     IStorage *stgprio = NULL;
 630     HRESULT r;
 631     IStream *stm = NULL;
 632     static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
 633     LARGE_INTEGER pos;
 634     ULARGE_INTEGER upos;
 635     STATSTG stat;
 636     char buffer[10];
 637
 638     if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
 639         return;
 640
 641     DeleteFileW(filename);
 642
 643     /* create the file */
 644     r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
 645                             STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
 646     ok(r==S_OK, "StgCreateDocfile failed\n");
 647
 648     r = WriteClassStg( stg, &test_stg_cls );
 649     ok( r == S_OK, "WriteClassStg failed\n");
 650
 651     r = IStorage_Commit( stg, STGC_DEFAULT );
 652     ok( r == S_OK, "IStorage_Commit failed\n");
 653
 654     /* now create a stream */
 655     r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
 656     ok(r==S_OK, "IStorage->CreateStream failed\n");
 657
 658     r = IStorage_Release( stg );
 659     ok (r == 0, "storage not released\n");
 660
 661     pos.QuadPart = 0;
 662     r = IStream_Seek( stm, pos, 0, &upos );
 663     ok (r == STG_E_REVERTED, "seek should fail\n");
 664
 665     r = IStream_Stat( stm, &stat, STATFLAG_DEFAULT );
 666     ok (r == STG_E_REVERTED, "stat should fail\n");
 667
 668     r = IStream_Write( stm, "Test string", strlen("Test string"), NULL);
 669     ok (r == STG_E_REVERTED, "IStream_Write should return STG_E_REVERTED instead of 0x%08lx\n", r);
 670
 671     r = IStream_Read( stm, buffer, sizeof(buffer), NULL);
 672     ok (r == STG_E_REVERTED, "IStream_Read should return STG_E_REVERTED instead of 0x%08lx\n", r);
 673
 674     r = IStream_Release(stm);
 675     ok (r == 0, "stream not released\n");
 676
 677     /* tests that STGM_PRIORITY doesn't prevent readwrite access from other
 678      * StgOpenStorage calls in transacted mode */
 679     r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stgprio);
 680     ok(r==S_OK, "StgOpenStorage failed with error 0x%08lx\n", r);
 681
 682     todo_wine {
 683     /* non-transacted mode read/write fails */
 684     r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
 685     ok(r==STG_E_LOCKVIOLATION, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08lx\n", r);
 686     }
 687
 688     /* non-transacted mode read-only succeeds */
 689     r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE|STGM_READ, NULL, 0, &stg);
 690     ok(r==S_OK, "StgOpenStorage failed with error 0x%08lx\n", r);
 691     IStorage_Release(stg);
 692
 693     r = StgOpenStorage( filename, NULL, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, NULL, 0, &stg);
 694     ok(r==S_OK, "StgOpenStorage failed with error 0x%08lx\n", r);
 695     if(stg)
 696     {
 697         static const WCHAR stgname[] = { ' ',' ',' ','2','9',0 };
 698         static const WCHAR stgname2[] = { 'C','V','_','i','e','w',0 };
 699         static const WCHAR stmname2[] = { 'V','a','r','2','D','a','t','a',0 };
 700         IStorage *stg2;
 701         IStorage *stg3;
 702         STATSTG statstg;
 703
 704         r = IStorage_Stat( stg, &statstg, STATFLAG_NONAME );
 705         ok(r == S_OK, "Stat should have succeded instead of returning 0x%08lx\n", r);
 706         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %ld\n", statstg.type);
 707         ok(statstg.cbSize.LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %ld\n", statstg.cbSize.LowPart);
 708         ok(statstg.cbSize.HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %ld\n", statstg.cbSize.HighPart);
 709         ok(statstg.grfMode == (STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE),
 710             "Statstg grfMode should have been 0x10022 instead of 0x%lx\n", statstg.grfMode);
 711         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %ld\n", statstg.grfLocksSupported);
 712         ok(IsEqualCLSID(&statstg.clsid, &test_stg_cls), "Statstg clsid is not test_stg_cls\n");
 713         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %ld\n", statstg.grfStateBits);
 714         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %ld\n", statstg.reserved);
 715
 716         r = IStorage_CreateStorage( stg, stgname, STGM_SHARE_EXCLUSIVE, 0, 0, &stg2 );
 717         ok(r == S_OK, "CreateStorage should have succeeded instead of returning 0x%08lx\n", r);
 718
 719         r = IStorage_Stat( stg2, &statstg, STATFLAG_DEFAULT );
 720         ok(r == S_OK, "Stat should have succeded instead of returning 0x%08lx\n", r);
 721         ok(!lstrcmpW(statstg.pwcsName, stgname),
 722             "Statstg pwcsName should have been the name the storage was created with\n");
 723         ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %ld\n", statstg.type);
 724         ok(statstg.cbSize.LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %ld\n", statstg.cbSize.LowPart);
 725         ok(statstg.cbSize.HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %ld\n", statstg.cbSize.HighPart);
 726         ok(statstg.grfMode == STGM_SHARE_EXCLUSIVE,
 727             "Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%lx\n", statstg.grfMode);
 728         ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %ld\n", statstg.grfLocksSupported);
 729         ok(IsEqualCLSID(&statstg.clsid, &CLSID_NULL), "Statstg clsid is not CLSID_NULL\n");
 730         ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %ld\n", statstg.grfStateBits);
 731         ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %ld\n", statstg.reserved);
 732         CoTaskMemFree(statstg.pwcsName);
 733
 734         r = IStorage_CreateStorage( stg2, stgname2, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stg3 );
 735         ok(r == STG_E_ACCESSDENIED, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08lx\n", r);
 736
 737         r = IStorage_CreateStream( stg2, stmname2, STGM_CREATE|STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
 738         ok(r == STG_E_ACCESSDENIED, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08lx\n", r);
 739
 740         IStorage_Release(stg2);
 741
 742         r = IStorage_Release(stg);
 743         ok(r == 0, "wrong ref count\n");
 744     }
 745     IStorage_Release(stgprio);
 746
 747     DeleteFileW(filename);
 748 }
 749
 750 START_TEST(storage32)
 751 {
 752     test_hglobal_storage_stat();
 753     test_create_storage_modes();
 754     test_storage_stream();
 755     test_open_storage();
 756     test_storage_suminfo();
 757     test_storage_refcount();
 758 }