mirror of
https://github.com/reactos/reactos.git
synced 2024-08-28 14:18:41 +00:00
3084 lines
114 KiB
C
3084 lines
114 KiB
C
/*
|
|
* Unit tests for OLE storage
|
|
*
|
|
* Copyright (c) 2004 Mike McCormack
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#define WIN32_NO_STATUS
|
|
#define _INC_WINDOWS
|
|
#define COM_NO_WINDOWS_H
|
|
|
|
//#include <stdio.h>
|
|
|
|
#define COBJMACROS
|
|
|
|
//#include <windows.h>
|
|
#include <wine/test.h>
|
|
#include <winnls.h>
|
|
#include <ole2.h>
|
|
//#include "objidl.h"
|
|
#include <initguid.h>
|
|
|
|
DEFINE_GUID( test_stg_cls, 0x88888888, 0x0425, 0x0000, 0,0,0,0,0,0,0,0);
|
|
|
|
#define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
|
|
|
|
static CHAR filenameA[MAX_PATH];
|
|
static WCHAR filename[MAX_PATH];
|
|
|
|
static const char file1_nameA[] = {'c','o','p','y','t','e','s','t','A',0};
|
|
static const WCHAR file1_name[] = {'c','o','p','y','t','e','s','t','A',0};
|
|
static const char file2_nameA[] = {'c','o','p','y','t','e','s','t','B',0};
|
|
static const WCHAR file2_name[] = {'c','o','p','y','t','e','s','t','B',0};
|
|
static const WCHAR stgA_name[] = {'S','t','o','r','a','g','e','A',0};
|
|
static const WCHAR stgB_name[] = {'S','t','o','r','a','g','e','B',0};
|
|
static const WCHAR strmA_name[] = {'S','t','r','e','a','m','A',0};
|
|
static const WCHAR strmB_name[] = {'S','t','r','e','a','m','B',0};
|
|
static const WCHAR strmC_name[] = {'S','t','r','e','a','m','C',0};
|
|
|
|
/* Win9x and WinMe don't have lstrcmpW */
|
|
static int strcmp_ww(LPCWSTR strw1, LPCWSTR strw2)
|
|
{
|
|
CHAR stra1[512], stra2[512];
|
|
WideCharToMultiByte(CP_ACP, 0, strw1, -1, stra1, sizeof(stra1), NULL, NULL);
|
|
WideCharToMultiByte(CP_ACP, 0, strw2, -1, stra2, sizeof(stra2), NULL, NULL);
|
|
return lstrcmpA(stra1, stra2);
|
|
}
|
|
|
|
static void test_hglobal_storage_stat(void)
|
|
{
|
|
ILockBytes *ilb = NULL;
|
|
IStorage *stg = NULL;
|
|
HRESULT r;
|
|
STATSTG stat;
|
|
DWORD mode, refcount;
|
|
|
|
r = CreateILockBytesOnHGlobal( NULL, TRUE, &ilb );
|
|
ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
|
|
|
|
r = StgIsStorageILockBytes( ilb );
|
|
ok( r == S_FALSE, "StgIsStorageILockBytes should have failed\n");
|
|
|
|
mode = STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE;/*0x1012*/
|
|
r = StgCreateDocfileOnILockBytes( ilb, mode, 0, &stg );
|
|
ok( r == S_OK, "StgCreateDocfileOnILockBytes failed\n");
|
|
|
|
r = WriteClassStg( stg, &test_stg_cls );
|
|
ok( r == S_OK, "WriteClassStg failed\n");
|
|
|
|
r = StgIsStorageILockBytes( ilb );
|
|
ok( r == S_OK, "StgIsStorageILockBytes failed\n");
|
|
|
|
memset( &stat, 0, sizeof stat );
|
|
r = IStorage_Stat( stg, &stat, 0 );
|
|
|
|
ok( stat.pwcsName == NULL, "storage name not null\n");
|
|
ok( stat.type == 1, "type is wrong\n");
|
|
ok( stat.grfMode == 0x12, "grf mode is incorrect\n");
|
|
ok( !memcmp(&stat.clsid, &test_stg_cls, sizeof test_stg_cls), "CLSID is wrong\n");
|
|
|
|
refcount = IStorage_Release( stg );
|
|
ok( refcount == 0, "IStorage refcount is wrong\n");
|
|
refcount = ILockBytes_Release( ilb );
|
|
ok( refcount == 0, "ILockBytes refcount is wrong\n");
|
|
}
|
|
|
|
static void test_create_storage_modes(void)
|
|
{
|
|
IStorage *stg = NULL;
|
|
HRESULT r;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* test with some invalid parameters */
|
|
r = StgCreateDocfile( NULL, 0, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, 0, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_CREATE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, NULL);
|
|
ok(r==STG_E_INVALIDPOINTER, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, &stg);
|
|
ok(r==STG_E_INVALIDPARAMETER, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READ, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_PRIORITY, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
|
|
/* StgCreateDocfile seems to be very particular about the flags it accepts */
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | STGM_WRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 8, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x8000, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80000, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800000, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
ok(stg == NULL, "stg was set\n");
|
|
|
|
/* check what happens if the file already exists (which is how it's meant to be used) */
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n"); /* FAILIFTHERE is default */
|
|
r = StgCreateDocfile( filename, STGM_READ, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n"); /* need at least readmode and sharemode */
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_WRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_WRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
|
|
r = StgCreateDocfile( filename, STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED |STGM_FAILIFTHERE, 0, &stg);
|
|
ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
|
|
r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_WRITE, 0, &stg);
|
|
ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
|
|
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
|
|
/* test the way excel uses StgCreateDocFile */
|
|
r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
|
|
if(r == S_OK)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
}
|
|
|
|
/* and the way windows media uses it ... */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_NONE | STGM_READWRITE | STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile the windows media way failed\n");
|
|
if (r == S_OK)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
}
|
|
|
|
/* looks like we need STGM_TRANSACTED or STGM_CREATE */
|
|
r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
|
|
if(r == S_OK)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
}
|
|
|
|
r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_WRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
|
|
if(r == S_OK)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
}
|
|
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile the powerpoint way failed\n");
|
|
if(r == S_OK)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
}
|
|
|
|
/* test the way msi uses StgCreateDocfile */
|
|
r = StgCreateDocfile( filename, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocFile failed\n");
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
}
|
|
|
|
static void test_stgcreatestorageex(void)
|
|
{
|
|
HRESULT (WINAPI *pStgCreateStorageEx)(const WCHAR* pwcsName, DWORD grfMode, DWORD stgfmt, DWORD grfAttrs, STGOPTIONS* pStgOptions, void* reserved, REFIID riid, void** ppObjectOpen);
|
|
HMODULE hOle32 = GetModuleHandle("ole32");
|
|
IStorage *stg = NULL;
|
|
STGOPTIONS stgoptions = {1, 0, 4096};
|
|
HRESULT r;
|
|
|
|
pStgCreateStorageEx = (void *) GetProcAddress(hOle32, "StgCreateStorageEx");
|
|
if (!pStgCreateStorageEx)
|
|
{
|
|
win_skip("skipping test on NT4\n");
|
|
return;
|
|
}
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* Verify that StgCreateStorageEx can accept an options param */
|
|
r = pStgCreateStorageEx( filename,
|
|
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
|
|
STGFMT_DOCFILE,
|
|
0,
|
|
&stgoptions,
|
|
NULL,
|
|
&IID_IStorage,
|
|
(void **) &stg);
|
|
ok(r==S_OK || r==STG_E_UNIMPLEMENTEDFUNCTION, "StgCreateStorageEx with options failed\n");
|
|
if (r==STG_E_UNIMPLEMENTEDFUNCTION)
|
|
{
|
|
/* We're on win98 which means all bets are off. Let's get out of here. */
|
|
win_skip("skipping test on win9x\n");
|
|
return;
|
|
}
|
|
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
|
|
/* Verify that StgCreateStorageEx can accept a NULL pStgOptions */
|
|
r = pStgCreateStorageEx( filename,
|
|
STGM_SHARE_EXCLUSIVE | STGM_READWRITE,
|
|
STGFMT_STORAGE,
|
|
0,
|
|
NULL,
|
|
NULL,
|
|
&IID_IStorage,
|
|
(void **) &stg);
|
|
ok(r==S_OK, "StgCreateStorageEx with NULL options failed\n");
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "storage not released\n");
|
|
ok(DeleteFileA(filenameA), "failed to delete file\n");
|
|
}
|
|
|
|
static void test_storage_stream(void)
|
|
{
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR longname[] = {
|
|
'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
|
|
'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
|
|
};
|
|
IStorage *stg = NULL;
|
|
HRESULT r;
|
|
IStream *stm = NULL;
|
|
IStream *stm2 = NULL;
|
|
ULONG count = 0;
|
|
LARGE_INTEGER pos;
|
|
ULARGE_INTEGER p;
|
|
unsigned char buffer[0x100];
|
|
IUnknown *unk;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* try create some invalid streams */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, 0, &stm );
|
|
ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 1, &stm );
|
|
ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, NULL );
|
|
ok(r==STG_E_INVALIDPOINTER, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, longname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==STG_E_INVALIDNAME || broken(r==S_OK) /* nt4 */,
|
|
"IStorage->CreateStream wrong error, got %d GetLastError()=%d\n", r, GetLastError());
|
|
r = IStorage_CreateStream(stg, stmname, STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, stmname, STGM_READ, 0, 0, &stm );
|
|
ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, stmname, STGM_WRITE, 0, 0, &stm );
|
|
ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READ, 0, 0, &stm );
|
|
ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
|
|
|
|
/* now really create a stream and delete it */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
/* test for support interfaces */
|
|
r = IStream_QueryInterface(stm, &IID_IPersist, (void**)&unk);
|
|
ok(r==E_NOINTERFACE, "got 0x%08x\n", r);
|
|
r = IStream_QueryInterface(stm, &IID_IPersistStream, (void**)&unk);
|
|
ok(r==E_NOINTERFACE, "got 0x%08x\n", r);
|
|
|
|
r = IStream_Release(stm);
|
|
ok(r == 0, "wrong ref count\n");
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==STG_E_FILEALREADYEXISTS, "IStorage->CreateStream failed\n");
|
|
r = IStorage_DestroyElement(stg,stmname);
|
|
ok(r==S_OK, "IStorage->DestroyElement failed\n");
|
|
|
|
/* create a stream and write to it */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Clone(stm, &stm2);
|
|
ok(r==S_OK, "failed to clone stream\n");
|
|
|
|
r = IStream_Write(stm, NULL, 0, NULL );
|
|
ok(r==STG_E_INVALIDPOINTER, "IStream->Write wrong error\n");
|
|
r = IStream_Write(stm, "Hello\n", 0, NULL );
|
|
ok(r==S_OK, "failed to write stream\n");
|
|
r = IStream_Write(stm, "Hello\n", 0, &count );
|
|
ok(r==S_OK, "failed to write stream\n");
|
|
r = IStream_Write(stm, "Hello\n", 6, &count );
|
|
ok(r==S_OK, "failed to write stream\n");
|
|
r = IStream_Commit(stm, STGC_DEFAULT );
|
|
ok(r==S_OK, "failed to commit stream\n");
|
|
r = IStream_Commit(stm, STGC_DEFAULT );
|
|
ok(r==S_OK, "failed to commit stream\n");
|
|
|
|
/* Read past the end of the stream. */
|
|
pos.QuadPart = 3;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 3, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to read\n");
|
|
ok(count == 3, "read bytes past end of stream\n");
|
|
pos.QuadPart = 10;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 10, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to read\n");
|
|
ok(count == 0, "read bytes past end of stream\n");
|
|
pos.QuadPart = 10000;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 10000, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to read\n");
|
|
ok(count == 0, "read bytes past end of stream\n");
|
|
|
|
/* Convert to a big block stream, and read past the end. */
|
|
p.QuadPart = 5000;
|
|
r = IStream_SetSize(stm,p);
|
|
ok(r==S_OK, "failed to set pos\n");
|
|
pos.QuadPart = 4997;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 4997, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to read\n");
|
|
ok(count == 3, "read bytes past end of stream\n");
|
|
pos.QuadPart = 5001;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 5001, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to read\n");
|
|
ok(count == 0, "read bytes past end of stream\n");
|
|
pos.QuadPart = 10000;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 10000, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to read\n");
|
|
ok(count == 0, "read bytes past end of stream\n");
|
|
|
|
/* seek round a bit, reset the stream size */
|
|
pos.QuadPart = 0;
|
|
r = IStream_Seek(stm, pos, 3, &p );
|
|
ok(r==STG_E_INVALIDFUNCTION, "IStream->Seek returned wrong error\n");
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
r = IStream_SetSize(stm,p);
|
|
ok(r==S_OK, "failed to set pos\n");
|
|
pos.QuadPart = 10;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 10, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to set pos\n");
|
|
ok(count == 0, "read bytes from empty stream\n");
|
|
pos.QuadPart = 10000;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 10000, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to set pos\n");
|
|
ok(count == 0, "read bytes from empty stream\n");
|
|
pos.QuadPart = 0;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_END, &p );
|
|
ok(r==S_OK, "failed to seek stream\n");
|
|
ok(p.QuadPart == 0, "at wrong place\n");
|
|
r = IStream_Read(stm, buffer, sizeof buffer, &count );
|
|
ok(r==S_OK, "failed to set pos\n");
|
|
ok(count == 0, "read bytes from empty stream\n");
|
|
|
|
/* wrap up */
|
|
r = IStream_Release(stm2);
|
|
ok(r == 0, "wrong ref count\n");
|
|
|
|
/* create a stream and write to it */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p);
|
|
ok(r==STG_E_REVERTED, "overwritten stream should return STG_E_REVERTED instead of 0x%08x\n", r);
|
|
|
|
r = IStream_Release(stm2);
|
|
ok(r == 0, "wrong ref count\n");
|
|
r = IStream_Release(stm);
|
|
ok(r == 0, "wrong ref count\n");
|
|
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "wrong ref count\n");
|
|
|
|
/* try create some invalid streams */
|
|
stg = NULL;
|
|
stm = NULL;
|
|
r = StgOpenStorage(filename, NULL, STGM_READ | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
|
|
ok(r == S_OK, "should succeed\n");
|
|
if (stg)
|
|
{
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
|
|
ok(r == STG_E_INVALIDFLAG, "IStorage->OpenStream should return STG_E_INVALIDFLAG instead of 0x%08x\n", r);
|
|
IStorage_Release(stg);
|
|
}
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok(r, "file should exist\n");
|
|
}
|
|
|
|
static BOOL touch_file(LPCSTR filename)
|
|
{
|
|
HANDLE file;
|
|
|
|
file = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
|
|
CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (file==INVALID_HANDLE_VALUE)
|
|
return FALSE;
|
|
CloseHandle(file);
|
|
return TRUE;
|
|
}
|
|
|
|
static BOOL is_zero_length(LPCSTR filename)
|
|
{
|
|
HANDLE file;
|
|
DWORD len;
|
|
|
|
file = CreateFileA(filename, GENERIC_READ, 0, NULL,
|
|
OPEN_EXISTING, 0, NULL);
|
|
if (file==INVALID_HANDLE_VALUE)
|
|
return FALSE;
|
|
len = GetFileSize(file, NULL);
|
|
CloseHandle(file);
|
|
return len == 0;
|
|
}
|
|
|
|
static BOOL is_existing_file(LPCSTR filename)
|
|
{
|
|
HANDLE file;
|
|
|
|
file = CreateFileA(filename, GENERIC_READ, 0, NULL,
|
|
OPEN_EXISTING, 0, NULL);
|
|
if (file==INVALID_HANDLE_VALUE)
|
|
return FALSE;
|
|
CloseHandle(file);
|
|
return TRUE;
|
|
}
|
|
|
|
static void test_open_storage(void)
|
|
{
|
|
static const WCHAR szNonExist[] = { 'n','o','n','e','x','i','s','t',0 };
|
|
IStorage *stg = NULL, *stg2 = NULL;
|
|
HRESULT r;
|
|
DWORD stgm;
|
|
|
|
/* try opening a zero length file - it should stay zero length */
|
|
DeleteFileA(filenameA);
|
|
touch_file(filenameA);
|
|
stgm = STGM_NOSCRATCH | STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READWRITE;
|
|
r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
|
|
ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
|
|
|
|
stgm = STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
|
|
r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
|
|
ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
|
|
ok(is_zero_length(filenameA), "file length changed\n");
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* try opening a nonexistent file - it should not create it */
|
|
stgm = STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
|
|
r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
|
|
ok(r!=S_OK, "StgOpenStorage failed: 0x%08x\n", r);
|
|
if (r==S_OK) IStorage_Release(stg);
|
|
ok(!is_existing_file(filenameA), "StgOpenStorage should not create a file\n");
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
IStorage_Release(stg);
|
|
|
|
r = StgOpenStorage( filename, NULL, 0, NULL, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgOpenStorage wrong error\n");
|
|
r = StgOpenStorage( NULL, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
|
|
ok(r==STG_E_INVALIDNAME, "StgOpenStorage wrong error\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, NULL);
|
|
ok(r==STG_E_INVALIDPOINTER, "StgOpenStorage wrong error\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 1, &stg);
|
|
ok(r==STG_E_INVALIDPARAMETER, "StgOpenStorage wrong error\n");
|
|
r = StgOpenStorage( szNonExist, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
|
|
ok(r==STG_E_FILENOTFOUND, "StgOpenStorage failed\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_READ | STGM_READ, NULL, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
|
|
ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
|
|
|
|
/* open it for real */
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg); /* XLViewer 97/2000 */
|
|
ok(r==S_OK, "StgOpenStorage failed\n");
|
|
if(stg)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "wrong ref count\n");
|
|
}
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READ, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed\n");
|
|
if(stg)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "wrong ref count\n");
|
|
}
|
|
|
|
/* test the way word opens its custom dictionary */
|
|
r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_TRANSACTED |
|
|
STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed\n");
|
|
if(stg)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "wrong ref count\n");
|
|
}
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2);
|
|
ok(r==STG_E_SHAREVIOLATION, "StgOpenStorage failed\n");
|
|
if(stg)
|
|
{
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "wrong ref count\n");
|
|
}
|
|
|
|
/* now try write to a storage file we opened read-only */
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed\n");
|
|
if(stg)
|
|
{
|
|
static const WCHAR stmname[] = { 'w','i','n','e','t','e','s','t',0};
|
|
IStream *stm = NULL;
|
|
IStorage *stg2 = NULL;
|
|
|
|
r = IStorage_CreateStream( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
|
|
0, 0, &stm );
|
|
ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
|
|
r = IStorage_CreateStorage( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
|
|
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "wrong ref count\n");
|
|
}
|
|
|
|
/* open like visio 2003 */
|
|
stg = NULL;
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
|
|
ok(r == S_OK, "should succeed\n");
|
|
if (stg)
|
|
IStorage_Release(stg);
|
|
|
|
/* test other sharing modes with STGM_PRIORITY */
|
|
stg = NULL;
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
|
|
ok(r == S_OK, "should succeed\n");
|
|
if (stg)
|
|
IStorage_Release(stg);
|
|
|
|
stg = NULL;
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
|
|
ok(r == S_OK, "should succeed\n");
|
|
if (stg)
|
|
IStorage_Release(stg);
|
|
|
|
stg = NULL;
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_READ, NULL, 0, &stg);
|
|
ok(r == S_OK, "should succeed\n");
|
|
if (stg)
|
|
IStorage_Release(stg);
|
|
|
|
/* open like Project 2003 */
|
|
stg = NULL;
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg);
|
|
ok(r == S_OK, "should succeed\n");
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg2);
|
|
ok(r == S_OK, "should succeed\n");
|
|
if (stg2)
|
|
IStorage_Release(stg2);
|
|
if (stg)
|
|
IStorage_Release(stg);
|
|
|
|
stg = NULL;
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_READWRITE, NULL, 0, &stg);
|
|
ok(r == STG_E_INVALIDFLAG, "should fail\n");
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_PRIORITY, NULL, 0, &stg);
|
|
ok(r == STG_E_INVALIDFLAG, "should fail\n");
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_PRIORITY, NULL, 0, &stg);
|
|
ok(r == STG_E_INVALIDFLAG, "should fail\n");
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_DELETEONRELEASE | STGM_PRIORITY, NULL, 0, &stg);
|
|
ok(r == STG_E_INVALIDFUNCTION, "should fail\n");
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_PRIORITY, NULL, 0, &stg);
|
|
ok(r == STG_E_INVALIDFLAG, "should fail\n");
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg);
|
|
ok(r == STG_E_INVALIDFLAG, "should fail\n");
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok(r, "file didn't exist\n");
|
|
}
|
|
|
|
static void test_storage_suminfo(void)
|
|
{
|
|
IStorage *stg = NULL;
|
|
IPropertySetStorage *propset = NULL;
|
|
IPropertyStorage *ps = NULL;
|
|
HRESULT r;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
r = IStorage_QueryInterface( stg, &IID_IPropertySetStorage, (LPVOID) &propset );
|
|
ok(r == S_OK, "query interface failed\n");
|
|
|
|
/* delete it */
|
|
r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
|
|
ok(r == STG_E_FILENOTFOUND, "deleted property set storage\n");
|
|
|
|
r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
|
|
STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
|
|
ok(r == STG_E_FILENOTFOUND, "opened property set storage\n");
|
|
|
|
r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
|
|
STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
|
|
ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
|
|
|
|
r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
|
|
STGM_READ, &ps );
|
|
ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
|
|
|
|
r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0, 0, &ps );
|
|
ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
|
|
|
|
r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
|
|
STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
|
|
ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
|
|
|
|
r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
|
|
STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
|
|
ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
|
|
|
|
/* now try really creating a property set */
|
|
r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
|
|
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
|
|
ok(r == S_OK, "failed to create property set storage\n");
|
|
|
|
if( ps )
|
|
IPropertyStorage_Release(ps);
|
|
|
|
/* now try creating the same thing again */
|
|
r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
|
|
STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
|
|
ok(r == S_OK, "failed to create property set storage\n");
|
|
if( ps )
|
|
IPropertyStorage_Release(ps);
|
|
|
|
/* should be able to open it */
|
|
r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
|
|
STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
|
|
ok(r == S_OK, "open failed\n");
|
|
if(r == S_OK)
|
|
IPropertyStorage_Release(ps);
|
|
|
|
/* delete it */
|
|
r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
|
|
ok(r == S_OK, "failed to delete property set storage\n");
|
|
|
|
/* try opening with an invalid FMTID */
|
|
r = IPropertySetStorage_Open( propset, NULL,
|
|
STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
|
|
ok(r == E_INVALIDARG, "open succeeded\n");
|
|
if(r == S_OK)
|
|
IPropertyStorage_Release(ps);
|
|
|
|
/* try a bad guid */
|
|
r = IPropertySetStorage_Open( propset, &IID_IStorage,
|
|
STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
|
|
ok(r == STG_E_FILENOTFOUND, "open succeeded\n");
|
|
if(r == S_OK)
|
|
IPropertyStorage_Release(ps);
|
|
|
|
|
|
/* try some invalid flags */
|
|
r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
|
|
STGM_CREATE | STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
|
|
ok(r == STG_E_INVALIDFLAG, "open succeeded\n");
|
|
if(r == S_OK)
|
|
IPropertyStorage_Release(ps);
|
|
|
|
/* after deleting it, it should be gone */
|
|
r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
|
|
STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
|
|
ok(r == STG_E_FILENOTFOUND, "open failed\n");
|
|
if(r == S_OK)
|
|
IPropertyStorage_Release(ps);
|
|
|
|
r = IPropertySetStorage_Release( propset );
|
|
ok(r == 1, "ref count wrong\n");
|
|
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "ref count wrong\n");
|
|
|
|
DeleteFileA(filenameA);
|
|
}
|
|
|
|
static void test_storage_refcount(void)
|
|
{
|
|
IStorage *stg = NULL;
|
|
IStorage *stgprio = NULL;
|
|
HRESULT r;
|
|
IStream *stm = NULL;
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
LARGE_INTEGER pos;
|
|
ULARGE_INTEGER upos;
|
|
STATSTG stat;
|
|
char buffer[10];
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
r = WriteClassStg( stg, &test_stg_cls );
|
|
ok( r == S_OK, "WriteClassStg failed\n");
|
|
|
|
r = IStorage_Commit( stg, STGC_DEFAULT );
|
|
ok( r == S_OK, "IStorage_Commit failed\n");
|
|
|
|
/* now create a stream */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStorage_Release( stg );
|
|
ok (r == 0, "storage not released\n");
|
|
|
|
pos.QuadPart = 0;
|
|
r = IStream_Seek( stm, pos, 0, &upos );
|
|
ok (r == STG_E_REVERTED, "seek should fail\n");
|
|
|
|
r = IStream_Stat( stm, &stat, STATFLAG_DEFAULT );
|
|
ok (r == STG_E_REVERTED, "stat should fail\n");
|
|
|
|
r = IStream_Write( stm, "Test string", strlen("Test string"), NULL);
|
|
ok (r == STG_E_REVERTED, "IStream_Write should return STG_E_REVERTED instead of 0x%08x\n", r);
|
|
|
|
r = IStream_Read( stm, buffer, sizeof(buffer), NULL);
|
|
ok (r == STG_E_REVERTED, "IStream_Read should return STG_E_REVERTED instead of 0x%08x\n", r);
|
|
|
|
r = IStream_Release(stm);
|
|
ok (r == 0, "stream not released\n");
|
|
|
|
/* tests that STGM_PRIORITY doesn't prevent readwrite access from other
|
|
* StgOpenStorage calls in transacted mode */
|
|
r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stgprio);
|
|
ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
|
|
|
|
todo_wine {
|
|
/* non-transacted mode read/write fails */
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
|
|
ok(r==STG_E_LOCKVIOLATION, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08x\n", r);
|
|
}
|
|
|
|
/* non-transacted mode read-only succeeds */
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE|STGM_READ, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
|
|
IStorage_Release(stg);
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
|
|
if(stg)
|
|
{
|
|
static const WCHAR stgname[] = { ' ',' ',' ','2','9',0 };
|
|
static const WCHAR stgname2[] = { 'C','V','_','i','e','w',0 };
|
|
static const WCHAR stmname2[] = { 'V','a','r','2','D','a','t','a',0 };
|
|
IStorage *stg2;
|
|
IStorage *stg3;
|
|
STATSTG statstg;
|
|
|
|
r = IStorage_Stat( stg, &statstg, STATFLAG_NONAME );
|
|
ok(r == S_OK, "Stat should have succeeded instead of returning 0x%08x\n", r);
|
|
ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
|
|
ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
|
|
ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
|
|
ok(statstg.grfMode == (STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE),
|
|
"Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg.grfMode);
|
|
ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
|
|
ok(IsEqualCLSID(&statstg.clsid, &test_stg_cls), "Statstg clsid is not test_stg_cls\n");
|
|
ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
|
|
ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
|
|
|
|
r = IStorage_CreateStorage( stg, stgname, STGM_SHARE_EXCLUSIVE, 0, 0, &stg2 );
|
|
ok(r == S_OK, "CreateStorage should have succeeded instead of returning 0x%08x\n", r);
|
|
|
|
r = IStorage_Stat( stg2, &statstg, STATFLAG_DEFAULT );
|
|
ok(r == S_OK, "Stat should have succeeded instead of returning 0x%08x\n", r);
|
|
ok(!memcmp(statstg.pwcsName, stgname, sizeof(stgname)),
|
|
"Statstg pwcsName should have been the name the storage was created with\n");
|
|
ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
|
|
ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
|
|
ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
|
|
ok(statstg.grfMode == STGM_SHARE_EXCLUSIVE,
|
|
"Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%x\n", statstg.grfMode);
|
|
ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
|
|
ok(IsEqualCLSID(&statstg.clsid, &CLSID_NULL), "Statstg clsid is not CLSID_NULL\n");
|
|
ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
|
|
ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
|
|
CoTaskMemFree(statstg.pwcsName);
|
|
|
|
r = IStorage_CreateStorage( stg2, stgname2, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stg3 );
|
|
ok(r == STG_E_ACCESSDENIED, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
|
|
|
|
r = IStorage_CreateStream( stg2, stmname2, STGM_CREATE|STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
|
|
ok(r == STG_E_ACCESSDENIED, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
|
|
|
|
IStorage_Release(stg2);
|
|
|
|
r = IStorage_Release(stg);
|
|
ok(r == 0, "wrong ref count\n");
|
|
}
|
|
IStorage_Release(stgprio);
|
|
|
|
DeleteFileA(filenameA);
|
|
}
|
|
|
|
static void test_writeclassstg(void)
|
|
{
|
|
IStorage *stg = NULL;
|
|
HRESULT r;
|
|
CLSID temp_cls;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
r = ReadClassStg( NULL, NULL );
|
|
ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
|
|
|
|
r = ReadClassStg( stg, NULL );
|
|
ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
|
|
|
|
temp_cls.Data1 = 0xdeadbeef;
|
|
r = ReadClassStg( stg, &temp_cls );
|
|
ok(r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
|
|
|
|
ok(IsEqualCLSID(&temp_cls, &CLSID_NULL), "ReadClassStg returned wrong clsid\n");
|
|
|
|
r = WriteClassStg( NULL, NULL );
|
|
ok(r == E_INVALIDARG, "WriteClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
|
|
|
|
r = WriteClassStg( stg, NULL );
|
|
ok(r == STG_E_INVALIDPOINTER, "WriteClassStg should return STG_E_INVALIDPOINTER instead of 0x%08X\n", r);
|
|
|
|
r = WriteClassStg( stg, &test_stg_cls );
|
|
ok( r == S_OK, "WriteClassStg failed with 0x%08X\n", r);
|
|
|
|
r = ReadClassStg( stg, &temp_cls );
|
|
ok( r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
|
|
ok(IsEqualCLSID(&temp_cls, &test_stg_cls), "ReadClassStg returned wrong clsid\n");
|
|
|
|
r = IStorage_Release( stg );
|
|
ok (r == 0, "storage not released\n");
|
|
|
|
DeleteFileA(filenameA);
|
|
}
|
|
|
|
static void test_streamenum(void)
|
|
{
|
|
IStorage *stg = NULL;
|
|
HRESULT r;
|
|
IStream *stm = NULL;
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR stmname2[] = { 'A','B','C','D','E','F','G','H','I',0 };
|
|
static const WCHAR stmname3[] = { 'A','B','C','D','E','F','G','H','I','J',0 };
|
|
STATSTG stat;
|
|
IEnumSTATSTG *ee = NULL;
|
|
ULONG count;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
r = WriteClassStg( stg, &test_stg_cls );
|
|
ok( r == S_OK, "WriteClassStg failed\n");
|
|
|
|
r = IStorage_Commit( stg, STGC_DEFAULT );
|
|
ok( r == S_OK, "IStorage_Commit failed\n");
|
|
|
|
/* now create a stream */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Release(stm);
|
|
|
|
/* first enum ... should be 1 stream */
|
|
r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
|
|
ok(r==S_OK, "IStorage->EnumElements failed\n");
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 1, "count wrong\n");
|
|
|
|
if (r == S_OK)
|
|
CoTaskMemFree(stat.pwcsName);
|
|
|
|
r = IEnumSTATSTG_Release(ee);
|
|
ok(r==S_OK, "EnumSTATSTG_Release failed with error 0x%08x\n", r);
|
|
|
|
/* second enum... destroy the stream before reading */
|
|
r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
|
|
ok(r==S_OK, "IStorage->EnumElements failed\n");
|
|
|
|
r = IStorage_DestroyElement(stg, stmname);
|
|
ok(r==S_OK, "IStorage->DestroyElement failed\n");
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 0, "count wrong\n");
|
|
|
|
/* reset and try again */
|
|
r = IEnumSTATSTG_Reset(ee);
|
|
ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 0, "count wrong\n");
|
|
|
|
/* add a stream before reading */
|
|
r = IEnumSTATSTG_Reset(ee);
|
|
ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
|
|
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Release(stm);
|
|
ok(r==S_OK, "Stream_Release failed with error 0x%08x\n", r);
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 1, "count wrong\n");
|
|
|
|
if (r == S_OK)
|
|
{
|
|
ok(lstrcmpiW(stat.pwcsName, stmname) == 0, "expected CONTENTS, got %s\n", wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
}
|
|
|
|
r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Release(stm);
|
|
ok(r==S_OK, "Stream_Release failed with error 0x%08x\n", r);
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 1, "count wrong\n");
|
|
|
|
if (r == S_OK)
|
|
{
|
|
ok(lstrcmpiW(stat.pwcsName, stmname2) == 0, "expected ABCDEFGHI, got %s\n", wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
}
|
|
|
|
/* delete previous and next stream after reading */
|
|
r = IStorage_CreateStream(stg, stmname3, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Release(stm);
|
|
ok(r==S_OK, "Stream_Release failed with error 0x%08x\n", r);
|
|
|
|
r = IEnumSTATSTG_Reset(ee);
|
|
ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 1, "count wrong\n");
|
|
|
|
if (r == S_OK)
|
|
{
|
|
ok(lstrcmpiW(stat.pwcsName, stmname) == 0, "expected CONTENTS, got %s\n", wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
}
|
|
|
|
r = IStorage_DestroyElement(stg, stmname);
|
|
ok(r==S_OK, "IStorage->DestroyElement failed\n");
|
|
|
|
r = IStorage_DestroyElement(stg, stmname2);
|
|
ok(r==S_OK, "IStorage->DestroyElement failed\n");
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 1, "count wrong\n");
|
|
|
|
if (r == S_OK)
|
|
{
|
|
ok(lstrcmpiW(stat.pwcsName, stmname3) == 0, "expected ABCDEFGHIJ, got %s\n", wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
}
|
|
|
|
r = IStorage_Release( stg );
|
|
todo_wine ok (r == 0, "storage not released\n");
|
|
|
|
/* enumerator is still valid and working after the storage is released */
|
|
r = IEnumSTATSTG_Reset(ee);
|
|
ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
|
|
|
|
count = 0xf00;
|
|
r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
|
|
ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
|
|
ok(count == 1, "count wrong\n");
|
|
|
|
if (r == S_OK)
|
|
{
|
|
ok(lstrcmpiW(stat.pwcsName, stmname3) == 0, "expected ABCDEFGHIJ, got %s\n", wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
}
|
|
|
|
/* the storage is left open until the enumerator is freed */
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, NULL, 0, &stg);
|
|
ok(r==STG_E_SHAREVIOLATION ||
|
|
r==STG_E_LOCKVIOLATION, /* XP-SP2/W2K3-SP1 and below */
|
|
"StgCreateDocfile failed, res=%x\n", r);
|
|
|
|
r = IEnumSTATSTG_Release(ee);
|
|
ok (r == 0, "enum not released\n");
|
|
|
|
DeleteFileA(filenameA);
|
|
}
|
|
|
|
static void test_transact(void)
|
|
{
|
|
IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
|
|
HRESULT r;
|
|
IStream *stm = NULL;
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR stmname2[] = { 'F','O','O',0 };
|
|
static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
|
|
static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* commit a new stream and storage */
|
|
r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
|
|
ok(r==S_OK, "IStream->Write failed\n");
|
|
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
/* Create two substorages but only commit one */
|
|
r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
r = IStorage_Commit(stg, 0);
|
|
ok(r==S_OK, "IStorage->Commit failed\n");
|
|
|
|
r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
/* now create a stream and storage, but don't commit them */
|
|
stm = NULL;
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Write(stm, "this is stream 2\n", 16, NULL);
|
|
ok(r==S_OK, "IStream->Write failed\n");
|
|
|
|
/* IStream::Commit does nothing for OLE storage streams */
|
|
r = IStream_Commit(stm, STGC_ONLYIFCURRENT | STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
|
|
ok(r==S_OK, "IStream->Commit failed\n");
|
|
|
|
r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStorage_Release(stg2);
|
|
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
stm = NULL;
|
|
stg = NULL;
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed\n");
|
|
|
|
if (!stg)
|
|
return;
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
|
|
ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStorage_Release(stg2);
|
|
|
|
r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
{
|
|
r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
|
|
ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_substorage_share(void)
|
|
{
|
|
IStorage *stg, *stg2, *stg3;
|
|
IStream *stm, *stm2;
|
|
HRESULT r;
|
|
static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR othername[] = { 'N','E','W','N','A','M','E',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a read/write storage and try to open it again */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage should fail %08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage should fail %08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
/* cannot rename the storage while it's open */
|
|
r = IStorage_RenameElement(stg, stgname, othername);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
|
|
if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stgname);
|
|
|
|
/* destroying an object while it's open invalidates it */
|
|
r = IStorage_DestroyElement(stg, stgname);
|
|
ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
|
|
|
|
r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
|
|
ok(r==STG_E_REVERTED, "IStorage->CreateStream failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
/* create a read/write stream and try to open it again */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
|
|
ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm2);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStream_Release(stm2);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm2);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStream_Release(stm2);
|
|
|
|
/* cannot rename the stream while it's open */
|
|
r = IStorage_RenameElement(stg, stmname, othername);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
|
|
if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stmname);
|
|
|
|
/* destroying an object while it's open invalidates it */
|
|
r = IStorage_DestroyElement(stg, stmname);
|
|
ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
|
|
|
|
r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
|
|
ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
|
|
|
|
IStream_Release(stm);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_revert(void)
|
|
{
|
|
IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
|
|
HRESULT r;
|
|
IStream *stm = NULL, *stm2 = NULL;
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR stmname2[] = { 'F','O','O',0 };
|
|
static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
|
|
static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
|
|
STATSTG statstg;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* commit a new stream and storage */
|
|
r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
|
|
ok(r==S_OK, "IStream->Write failed\n");
|
|
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
/* Create two substorages but only commit one */
|
|
r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
r = IStorage_Commit(stg, 0);
|
|
ok(r==S_OK, "IStorage->Commit failed\n");
|
|
|
|
r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
}
|
|
|
|
/* now create a stream and storage, then revert */
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStream_Write(stm2, "this is stream 2\n", 16, NULL);
|
|
ok(r==S_OK, "IStream->Write failed\n");
|
|
|
|
r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
r = IStorage_Revert(stg);
|
|
ok(r==S_OK, "Storage_Revert failed with error 0x%08x\n", r);
|
|
|
|
/* all open objects become invalid */
|
|
r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
|
|
ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
|
|
|
|
r = IStream_Write(stm2, "this shouldn't work\n", 20, NULL);
|
|
ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
|
|
|
|
r = IStorage_Stat(stg2, &statstg, STATFLAG_NONAME);
|
|
ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
|
|
|
|
r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
|
|
ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
|
|
|
|
IStream_Release(stm);
|
|
IStream_Release(stm2);
|
|
IStorage_Release(stg2);
|
|
IStorage_Release(stg3);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
|
|
ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStorage_Release(stg2);
|
|
|
|
r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
|
|
|
|
r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
|
|
ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
{
|
|
r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
|
|
ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
|
|
/* Revert only invalidates objects in transacted mode */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
r = IStorage_Revert(stg);
|
|
ok(r==S_OK, "IStorage->Revert failed %08x\n", r);
|
|
|
|
r = IStream_Write(stm, "this works\n", 11, NULL);
|
|
ok(r==S_OK, "IStream_Write should succeed %08x\n", r);
|
|
|
|
IStream_Release(stm);
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_parent_free(void)
|
|
{
|
|
IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
|
|
HRESULT r;
|
|
IStream *stm = NULL;
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
|
|
ULONG ref;
|
|
STATSTG statstg;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a new storage */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
/* now create a stream inside the new storage */
|
|
r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
|
|
if (r == S_OK)
|
|
{
|
|
/* create a storage inside the new storage */
|
|
r = IStorage_CreateStorage(stg2, stgname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg3 );
|
|
ok(r==S_OK, "IStorage->CreateStorage failed\n");
|
|
}
|
|
|
|
/* free the parent */
|
|
ref = IStorage_Release(stg2);
|
|
ok(ref == 0, "IStorage still has %u references\n", ref);
|
|
|
|
/* child objects are invalid */
|
|
if (r == S_OK)
|
|
{
|
|
r = IStream_Write(stm, "this should fail\n", 17, NULL);
|
|
ok(r==STG_E_REVERTED, "IStream->Write should fail, hr=%x\n", r);
|
|
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
|
|
ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
|
|
|
|
r = IStorage_SetStateBits(stg3, 1, 1);
|
|
ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
|
|
|
|
IStorage_Release(stg3);
|
|
}
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_nonroot_transacted(void)
|
|
{
|
|
IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
|
|
HRESULT r;
|
|
IStream *stm = NULL;
|
|
static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR stmname2[] = { 'F','O','O',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create a transacted file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a transacted substorage */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
/* create and commit stmname */
|
|
r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Commit(stg2, 0);
|
|
|
|
/* create and revert stmname2 */
|
|
r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Revert(stg2);
|
|
|
|
/* check that Commit and Revert really worked */
|
|
r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
/* create a read-only transacted substorage */
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, NULL, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->OpenStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
/* The storage can be modified. */
|
|
r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
if (r == S_OK)
|
|
IStorage_Release(stg3);
|
|
|
|
/* But changes cannot be committed. */
|
|
r = IStorage_Commit(stg2, 0);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->Commit should fail, hr=%08x\n", r);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
|
|
/* create a non-transacted file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a transacted substorage */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
if (r == S_OK)
|
|
{
|
|
/* create and commit stmname */
|
|
r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Commit(stg2, 0);
|
|
|
|
/* create and revert stmname2 */
|
|
r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
|
|
ok(r==S_OK, "IStorage->CreateStream failed\n");
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Revert(stg2);
|
|
|
|
/* check that Commit and Revert really worked */
|
|
r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
|
|
if (r == S_OK)
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_ReadClassStm(void)
|
|
{
|
|
CLSID clsid;
|
|
HRESULT hr;
|
|
IStream *pStream;
|
|
static const LARGE_INTEGER llZero;
|
|
|
|
hr = ReadClassStm(NULL, &clsid);
|
|
ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
|
|
|
|
hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
|
|
ok_ole_success(hr, "CreateStreamOnHGlobal");
|
|
hr = WriteClassStm(pStream, &test_stg_cls);
|
|
ok_ole_success(hr, "WriteClassStm");
|
|
|
|
hr = ReadClassStm(pStream, NULL);
|
|
ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
|
|
|
|
/* test not rewound stream */
|
|
hr = ReadClassStm(pStream, &clsid);
|
|
ok(hr == STG_E_READFAULT, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
|
|
ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid should have been zeroed\n");
|
|
|
|
hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
|
|
ok_ole_success(hr, "IStream_Seek");
|
|
hr = ReadClassStm(pStream, &clsid);
|
|
ok_ole_success(hr, "ReadClassStm");
|
|
ok(IsEqualCLSID(&clsid, &test_stg_cls), "clsid should have been set to CLSID_WineTest\n");
|
|
|
|
IStream_Release(pStream);
|
|
}
|
|
|
|
struct access_res
|
|
{
|
|
BOOL gothandle;
|
|
DWORD lasterr;
|
|
BOOL ignore;
|
|
};
|
|
|
|
static const struct access_res create[16] =
|
|
{
|
|
{ TRUE, ERROR_SUCCESS, TRUE },
|
|
{ TRUE, ERROR_SUCCESS, TRUE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, TRUE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, TRUE }
|
|
};
|
|
|
|
static const struct access_res create_commit[16] =
|
|
{
|
|
{ TRUE, ERROR_SUCCESS, TRUE },
|
|
{ TRUE, ERROR_SUCCESS, TRUE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, TRUE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ FALSE, ERROR_SHARING_VIOLATION, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, TRUE }
|
|
};
|
|
|
|
static const struct access_res create_close[16] =
|
|
{
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS, FALSE },
|
|
{ TRUE, ERROR_SUCCESS }
|
|
};
|
|
|
|
static void _test_file_access(LPCSTR file, const struct access_res *ares, DWORD line)
|
|
{
|
|
DWORD access = 0, share = 0;
|
|
DWORD lasterr;
|
|
HANDLE hfile;
|
|
int i, j, idx = 0;
|
|
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
if (i == 0) access = 0;
|
|
if (i == 1) access = GENERIC_READ;
|
|
if (i == 2) access = GENERIC_WRITE;
|
|
if (i == 3) access = GENERIC_READ | GENERIC_WRITE;
|
|
|
|
for (j = 0; j < 4; j++)
|
|
{
|
|
if (ares[idx].ignore)
|
|
continue;
|
|
|
|
if (j == 0) share = 0;
|
|
if (j == 1) share = FILE_SHARE_READ;
|
|
if (j == 2) share = FILE_SHARE_WRITE;
|
|
if (j == 3) share = FILE_SHARE_READ | FILE_SHARE_WRITE;
|
|
|
|
SetLastError(0xdeadbeef);
|
|
hfile = CreateFileA(file, access, share, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, 0);
|
|
lasterr = GetLastError();
|
|
|
|
ok((hfile != INVALID_HANDLE_VALUE) == ares[idx].gothandle,
|
|
"(%d, handle, %d): Expected %d, got %d\n",
|
|
line, idx, ares[idx].gothandle,
|
|
(hfile != INVALID_HANDLE_VALUE));
|
|
|
|
ok(lasterr == ares[idx].lasterr ||
|
|
broken(lasterr == 0xdeadbeef) /* win9x */,
|
|
"(%d, lasterr, %d): Expected %d, got %d\n",
|
|
line, idx, ares[idx].lasterr, lasterr);
|
|
|
|
CloseHandle(hfile);
|
|
idx++;
|
|
}
|
|
}
|
|
}
|
|
|
|
#define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
|
|
|
|
static void test_access(void)
|
|
{
|
|
IStorage *stg;
|
|
HRESULT hr;
|
|
|
|
static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
|
|
|
|
/* STGM_TRANSACTED */
|
|
|
|
hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
|
|
STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, &stg);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create);
|
|
|
|
hr = IStorage_Commit(stg, STGC_DEFAULT);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create_commit);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
test_file_access("winetest", create_close);
|
|
|
|
DeleteFileA("winetest");
|
|
|
|
/* STGM_DIRECT */
|
|
|
|
hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
|
|
STGM_SHARE_EXCLUSIVE | STGM_DIRECT, 0, &stg);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create);
|
|
|
|
hr = IStorage_Commit(stg, STGC_DEFAULT);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create_commit);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
test_file_access("winetest", create_close);
|
|
|
|
DeleteFileA("winetest");
|
|
|
|
/* STGM_SHARE_DENY_NONE */
|
|
|
|
hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
|
|
STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create);
|
|
|
|
hr = IStorage_Commit(stg, STGC_DEFAULT);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create_commit);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
test_file_access("winetest", create_close);
|
|
|
|
DeleteFileA("winetest");
|
|
|
|
/* STGM_SHARE_DENY_READ */
|
|
|
|
hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
|
|
STGM_SHARE_DENY_READ | STGM_TRANSACTED, 0, &stg);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create);
|
|
|
|
hr = IStorage_Commit(stg, STGC_DEFAULT);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create_commit);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
test_file_access("winetest", create_close);
|
|
|
|
DeleteFileA("winetest");
|
|
|
|
/* STGM_SHARE_DENY_WRITE */
|
|
|
|
hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
|
|
STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create);
|
|
|
|
hr = IStorage_Commit(stg, STGC_DEFAULT);
|
|
ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
|
|
|
|
test_file_access("winetest", create_commit);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
test_file_access("winetest", create_close);
|
|
|
|
DeleteFileA("winetest");
|
|
}
|
|
|
|
static void test_readonly(void)
|
|
{
|
|
IStorage *stg, *stg2, *stg3;
|
|
IStream *stream;
|
|
HRESULT hr;
|
|
static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
|
|
static const WCHAR storageW[] = {'s','t','o','r','a','g','e',0};
|
|
static const WCHAR streamW[] = {'s','t','r','e','a','m',0};
|
|
|
|
hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = IStorage_CreateStorage( stg, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2 );
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stream );
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
IStream_Release(stream);
|
|
IStorage_Release(stg2);
|
|
}
|
|
IStorage_Release(stg);
|
|
}
|
|
|
|
/* re-open read only */
|
|
hr = StgOpenStorage( fileW, NULL, STGM_TRANSACTED | STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = IStorage_OpenStorage( stg, storageW, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2 );
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
/* CreateStream on read-only storage, name exists */
|
|
hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
|
|
ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
IStream_Release(stream);
|
|
|
|
/* CreateStream on read-only storage, name does not exist */
|
|
hr = IStorage_CreateStream( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
|
|
ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
IStream_Release(stream);
|
|
|
|
/* CreateStorage on read-only storage, name exists */
|
|
hr = IStorage_CreateStorage( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
|
|
ok(hr == STG_E_FILEALREADYEXISTS, "should fail, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
IStorage_Release(stg3);
|
|
|
|
/* CreateStorage on read-only storage, name does not exist */
|
|
hr = IStorage_CreateStorage( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
|
|
ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
IStorage_Release(stg3);
|
|
|
|
/* DestroyElement on read-only storage, name exists */
|
|
hr = IStorage_DestroyElement( stg2, streamW );
|
|
ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
|
|
|
|
/* DestroyElement on read-only storage, name does not exist */
|
|
hr = IStorage_DestroyElement( stg2, storageW );
|
|
ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
}
|
|
|
|
DeleteFileA("winetest");
|
|
}
|
|
|
|
static void test_simple(void)
|
|
{
|
|
/* Tests for STGM_SIMPLE mode */
|
|
|
|
IStorage *stg, *stg2;
|
|
HRESULT r;
|
|
IStream *stm;
|
|
static const WCHAR stgname[] = { 'S','t','g',0 };
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR stmname2[] = { 'S','m','a','l','l',0 };
|
|
LARGE_INTEGER pos;
|
|
ULARGE_INTEGER upos;
|
|
DWORD count;
|
|
STATSTG stat;
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
r = StgCreateDocfile( filename, STGM_SIMPLE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2);
|
|
ok(r == STG_E_INVALIDFUNCTION, "got %08x\n", r);
|
|
if (SUCCEEDED(r)) IStorage_Release(stg2);
|
|
|
|
r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
|
|
ok(r == STG_E_INVALIDFLAG, "got %08x\n", r);
|
|
r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
upos.QuadPart = 6000;
|
|
r = IStream_SetSize(stm, upos);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
r = IStream_Write(stm, "foo", 3, &count);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
ok(count == 3, "got %d\n", count);
|
|
|
|
pos.QuadPart = 0;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_CUR, &upos);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
ok(upos.QuadPart == 3, "got %d\n", upos.u.LowPart);
|
|
|
|
r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
|
|
ok(r == S_OK ||
|
|
broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
|
|
"got %08x\n", r);
|
|
if (r == S_OK)
|
|
ok(stat.cbSize.QuadPart == 3, "got %d\n", stat.cbSize.u.LowPart);
|
|
|
|
pos.QuadPart = 1;
|
|
r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
ok(upos.QuadPart == 1, "got %d\n", upos.u.LowPart);
|
|
|
|
r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
|
|
ok(r == S_OK ||
|
|
broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
|
|
"got %08x\n", r);
|
|
if (r == S_OK)
|
|
ok(stat.cbSize.QuadPart == 1, "got %d\n", stat.cbSize.u.LowPart);
|
|
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
upos.QuadPart = 100;
|
|
r = IStream_SetSize(stm, upos);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
r = IStream_Write(stm, "foo", 3, &count);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
ok(count == 3, "got %d\n", count);
|
|
|
|
IStream_Release(stm);
|
|
|
|
IStorage_Commit(stg, STGC_DEFAULT);
|
|
IStorage_Release(stg);
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
|
|
if (r == STG_E_INVALIDFLAG)
|
|
{
|
|
win_skip("Flag combination is not supported on NT4 and below\n");
|
|
DeleteFileA(filenameA);
|
|
return;
|
|
}
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg2);
|
|
ok(r == STG_E_INVALIDFUNCTION, "got %08x\n", r);
|
|
if (SUCCEEDED(r)) IStorage_Release(stg2);
|
|
|
|
r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
ok(stat.cbSize.QuadPart == 6000, "got %d\n", stat.cbSize.u.LowPart);
|
|
|
|
IStream_Release(stm);
|
|
|
|
r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
|
|
r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
|
|
ok(r == S_OK, "got %08x\n", r);
|
|
ok(stat.cbSize.QuadPart == 4096, "got %d\n", stat.cbSize.u.LowPart);
|
|
|
|
IStream_Release(stm);
|
|
|
|
|
|
IStorage_Release(stg);
|
|
|
|
DeleteFileA(filenameA);
|
|
}
|
|
|
|
static void test_fmtusertypestg(void)
|
|
{
|
|
IStorage *stg;
|
|
IEnumSTATSTG *stat;
|
|
HRESULT hr;
|
|
static const char fileA[] = {'f','m','t','t','e','s','t',0};
|
|
static const WCHAR fileW[] = {'f','m','t','t','e','s','t',0};
|
|
static WCHAR userTypeW[] = {'S','t','g','U','s','r','T','y','p','e',0};
|
|
static WCHAR strmNameW[] = {1,'C','o','m','p','O','b','j',0};
|
|
|
|
hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
/* try to write the stream */
|
|
hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
|
|
/* check that the stream was created */
|
|
hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BOOL found = FALSE;
|
|
STATSTG statstg;
|
|
DWORD got;
|
|
while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
|
|
{
|
|
if (strcmp_ww(statstg.pwcsName, strmNameW) == 0)
|
|
found = TRUE;
|
|
else
|
|
ok(0, "found unexpected stream or storage\n");
|
|
CoTaskMemFree(statstg.pwcsName);
|
|
}
|
|
ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
|
|
IEnumSTATSTG_Release(stat);
|
|
}
|
|
|
|
/* re-write the stream */
|
|
hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
|
|
/* check that the stream is still there */
|
|
hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
|
|
ok(hr == S_OK, "should succeed, res=%x\n", hr);
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
BOOL found = FALSE;
|
|
STATSTG statstg;
|
|
DWORD got;
|
|
while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
|
|
{
|
|
if (strcmp_ww(statstg.pwcsName, strmNameW) == 0)
|
|
found = TRUE;
|
|
else
|
|
ok(0, "found unexpected stream or storage\n");
|
|
CoTaskMemFree(statstg.pwcsName);
|
|
}
|
|
ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
|
|
IEnumSTATSTG_Release(stat);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
DeleteFileA( fileA );
|
|
}
|
|
}
|
|
|
|
static void test_references(void)
|
|
{
|
|
IStorage *stg,*stg2;
|
|
HRESULT hr;
|
|
unsigned c1,c2;
|
|
static const WCHAR StorName[] = { 'D','a','t','a','S','p','a','c','e','I','n','f','o',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
hr = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(hr==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
IStorage_Release(stg);
|
|
|
|
hr = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
|
|
ok(hr==S_OK, "StgOpenStorage failed (result=%x)\n",hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
hr = IStorage_CreateStorage(stg,StorName,STGM_READWRITE | STGM_SHARE_EXCLUSIVE,0,0,&stg2);
|
|
ok(hr == S_OK, "IStorage_CreateStorage failed (result=%x)\n",hr);
|
|
|
|
if (SUCCEEDED(hr))
|
|
{
|
|
c1 = IStorage_AddRef(stg);
|
|
ok(c1 == 2, "creating internal storage added references to ancestor\n");
|
|
c1 = IStorage_AddRef(stg);
|
|
IStorage_Release(stg2);
|
|
c2 = IStorage_AddRef(stg) - 1;
|
|
ok(c1 == c2, "releasing internal storage removed references to ancestor\n");
|
|
}
|
|
c1 = IStorage_Release(stg);
|
|
while ( c1 ) c1 = IStorage_Release(stg);
|
|
}
|
|
}
|
|
|
|
DeleteFileA(filenameA);
|
|
}
|
|
|
|
/* dest
|
|
* |-StorageA
|
|
* | `StreamA: "StreamA"
|
|
* |-StorageB
|
|
* | `StreamB: "StreamB"
|
|
* `StreamC: "StreamC"
|
|
*/
|
|
static HRESULT create_test_file(IStorage *dest)
|
|
{
|
|
IStorage *stgA = NULL, *stgB = NULL;
|
|
IStream *strmA = NULL, *strmB = NULL, *strmC = NULL;
|
|
const ULONG strmA_name_size = lstrlenW(strmA_name) * sizeof(WCHAR);
|
|
const ULONG strmB_name_size = lstrlenW(strmB_name) * sizeof(WCHAR);
|
|
const ULONG strmC_name_size = lstrlenW(strmC_name) * sizeof(WCHAR);
|
|
ULONG bytes;
|
|
HRESULT hr;
|
|
|
|
hr = IStorage_CreateStorage(dest, stgA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgA);
|
|
ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = IStorage_CreateStream(stgA, strmA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmA);
|
|
ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = IStream_Write(strmA, strmA_name, strmA_name_size, &bytes);
|
|
ok(hr == S_OK && bytes == strmA_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmA_name_size);
|
|
|
|
hr = IStorage_CreateStorage(dest, stgB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgB);
|
|
ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = IStorage_CreateStream(stgB, strmB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmB);
|
|
ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = IStream_Write(strmB, strmB_name, strmB_name_size, &bytes);
|
|
ok(hr == S_OK && bytes == strmB_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmB_name_size);
|
|
|
|
hr = IStorage_CreateStream(dest, strmC_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmC);
|
|
ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = IStream_Write(strmC, strmC_name, strmC_name_size, &bytes);
|
|
ok(hr == S_OK && bytes == strmC_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmC_name_size);
|
|
|
|
cleanup:
|
|
if(strmC)
|
|
IStream_Release(strmC);
|
|
if(strmB)
|
|
IStream_Release(strmB);
|
|
if(stgB)
|
|
IStorage_Release(stgB);
|
|
if(strmA)
|
|
IStream_Release(strmA);
|
|
if(stgA)
|
|
IStorage_Release(stgA);
|
|
|
|
return hr;
|
|
}
|
|
|
|
static void test_copyto(void)
|
|
{
|
|
IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
|
|
IStream *strm_tmp;
|
|
WCHAR buf[64];
|
|
HRESULT hr;
|
|
|
|
/* create & populate file1 */
|
|
hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = create_test_file(file1);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* create file2 */
|
|
hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* copy file1 into file2 */
|
|
hr = IStorage_CopyTo(file1, 0, NULL, NULL, NULL);
|
|
ok(hr == STG_E_INVALIDPOINTER, "CopyTo should give STG_E_INVALIDPONITER, gave: 0x%08x\n", hr);
|
|
|
|
hr = IStorage_CopyTo(file1, 0, NULL, NULL, file2);
|
|
ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* verify that all of file1 was copied */
|
|
hr = IStorage_OpenStorage(file2, stgA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
memset(buf, 0, sizeof(buf));
|
|
hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
|
|
ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
ok(strcmp_ww(buf, strmA_name) == 0,
|
|
"Expected %s to be read, got %s\n", wine_dbgstr_w(strmA_name), wine_dbgstr_w(buf));
|
|
|
|
IStream_Release(strm_tmp);
|
|
}
|
|
|
|
IStorage_Release(stg_tmp);
|
|
}
|
|
|
|
hr = IStorage_OpenStorage(file2, stgB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
memset(buf, 0, sizeof(buf));
|
|
hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
|
|
ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
ok(strcmp_ww(buf, strmB_name) == 0,
|
|
"Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
|
|
|
|
IStream_Release(strm_tmp);
|
|
}
|
|
|
|
IStorage_Release(stg_tmp);
|
|
}
|
|
|
|
hr = IStorage_OpenStream(file2, strmC_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
memset(buf, 0, sizeof(buf));
|
|
hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
|
|
ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
ok(strcmp_ww(buf, strmC_name) == 0,
|
|
"Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
|
|
|
|
IStream_Release(strm_tmp);
|
|
}
|
|
|
|
cleanup:
|
|
if(file1)
|
|
IStorage_Release(file1);
|
|
if(file2)
|
|
IStorage_Release(file2);
|
|
|
|
DeleteFileA(file1_nameA);
|
|
DeleteFileA(file2_nameA);
|
|
}
|
|
|
|
static void test_copyto_snbexclusions(void)
|
|
{
|
|
static const WCHAR *snb_exclude[] = {stgA_name, strmB_name, strmC_name, 0};
|
|
|
|
IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
|
|
IStream *strm_tmp;
|
|
WCHAR buf[64];
|
|
HRESULT hr;
|
|
|
|
/* create & populate file1 */
|
|
hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = create_test_file(file1);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* create file2 */
|
|
hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* copy file1 to file2 with name exclusions */
|
|
hr = IStorage_CopyTo(file1, 0, NULL, (SNB)snb_exclude, file2);
|
|
ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* verify that file1 copied over, respecting exclusions */
|
|
hr = IStorage_OpenStorage(file2, stgA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStorage_Release(stg_tmp);
|
|
|
|
hr = IStorage_OpenStream(file2, strmA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStream_Release(strm_tmp);
|
|
|
|
hr = IStorage_OpenStorage(file2, stgB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
memset(buf, 0, sizeof(buf));
|
|
hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
|
|
ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
ok(strcmp_ww(buf, strmB_name) == 0,
|
|
"Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
|
|
|
|
IStream_Release(strm_tmp);
|
|
}
|
|
|
|
IStorage_Release(stg_tmp);
|
|
}
|
|
|
|
hr = IStorage_OpenStream(file2, strmC_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStream_Release(strm_tmp);
|
|
|
|
cleanup:
|
|
if(file1)
|
|
IStorage_Release(file1);
|
|
if(file2)
|
|
IStorage_Release(file2);
|
|
|
|
DeleteFileA(file1_nameA);
|
|
DeleteFileA(file2_nameA);
|
|
}
|
|
|
|
static void test_copyto_iidexclusions_storage(void)
|
|
{
|
|
IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
|
|
IStream *strm_tmp;
|
|
WCHAR buf[64];
|
|
HRESULT hr;
|
|
|
|
/* create & populate file1 */
|
|
hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = create_test_file(file1);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* create file2 */
|
|
hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* copy file1 to file2 with iid exclusions */
|
|
hr = IStorage_CopyTo(file1, 1, &IID_IStorage, NULL, file2);
|
|
ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* verify that file1 copied over, respecting exclusions */
|
|
hr = IStorage_OpenStorage(file2, stgA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStorage_Release(stg_tmp);
|
|
|
|
hr = IStorage_OpenStream(file2, strmA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStream_Release(strm_tmp);
|
|
|
|
hr = IStorage_OpenStorage(file2, stgB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStorage_Release(stg_tmp);
|
|
|
|
hr = IStorage_OpenStream(file2, strmB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStream_Release(strm_tmp);
|
|
|
|
hr = IStorage_OpenStream(file2, strmC_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
memset(buf, 0, sizeof(buf));
|
|
hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
|
|
ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
ok(strcmp_ww(buf, strmC_name) == 0,
|
|
"Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
|
|
|
|
IStream_Release(strm_tmp);
|
|
}
|
|
|
|
cleanup:
|
|
if(file1)
|
|
IStorage_Release(file1);
|
|
if(file2)
|
|
IStorage_Release(file2);
|
|
|
|
DeleteFileA(file1_nameA);
|
|
DeleteFileA(file2_nameA);
|
|
}
|
|
|
|
static void test_copyto_iidexclusions_stream(void)
|
|
{
|
|
IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
|
|
IStream *strm_tmp;
|
|
HRESULT hr;
|
|
|
|
/* create & populate file1 */
|
|
hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
hr = create_test_file(file1);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* create file2 */
|
|
hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
|
|
ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* copy file1 to file2 with iid exclusions */
|
|
hr = IStorage_CopyTo(file1, 1, &IID_IStream, NULL, file2);
|
|
ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
|
|
if(FAILED(hr))
|
|
goto cleanup;
|
|
|
|
/* verify that file1 copied over, respecting exclusions */
|
|
hr = IStorage_OpenStorage(file2, stgA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStream_Release(strm_tmp);
|
|
|
|
IStorage_Release(stg_tmp);
|
|
}
|
|
|
|
hr = IStorage_OpenStorage(file2, stgB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
|
|
ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
|
|
|
|
if(SUCCEEDED(hr)){
|
|
hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStream_Release(strm_tmp);
|
|
|
|
IStorage_Release(stg_tmp);
|
|
}
|
|
|
|
hr = IStorage_OpenStream(file2, strmC_name, NULL,
|
|
STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
|
|
ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
|
|
if(SUCCEEDED(hr))
|
|
IStream_Release(strm_tmp);
|
|
|
|
cleanup:
|
|
if(file1)
|
|
IStorage_Release(file1);
|
|
if(file2)
|
|
IStorage_Release(file2);
|
|
|
|
DeleteFileA(file1_nameA);
|
|
DeleteFileA(file2_nameA);
|
|
}
|
|
|
|
static void test_rename(void)
|
|
{
|
|
IStorage *stg, *stg2;
|
|
IStream *stm;
|
|
HRESULT r;
|
|
static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
|
|
static const WCHAR stgname2[] = { 'S','T','G',0 };
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
static const WCHAR stmname2[] = { 'E','N','T','S',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a substorage */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* create a stream in the substorage */
|
|
r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
|
|
ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
|
|
IStream_Release(stm);
|
|
|
|
/* rename the stream */
|
|
r = IStorage_RenameElement(stg2, stmname, stmname2);
|
|
ok(r==S_OK, "IStorage->RenameElement failed, hr=%08x\n", r);
|
|
|
|
/* cannot open stream with old name */
|
|
r = IStorage_OpenStream(stg2, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
|
|
if (SUCCEEDED(r)) IStream_Release(stm);
|
|
|
|
/* can open stream with new name */
|
|
r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
|
|
if (SUCCEEDED(r)) IStream_Release(stm);
|
|
|
|
IStorage_Release(stg2);
|
|
|
|
/* rename the storage */
|
|
IStorage_RenameElement(stg, stgname, stgname2);
|
|
|
|
/* cannot open storage with old name */
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
|
|
ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
|
|
if (SUCCEEDED(r)) IStorage_Release(stg2);
|
|
|
|
/* can open storage with new name */
|
|
r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
|
|
ok(r==S_OK, "IStorage_OpenStream should fail, hr=%08x\n", r);
|
|
if (SUCCEEDED(r))
|
|
{
|
|
/* opened storage still has the stream */
|
|
r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
|
|
ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
|
|
if (SUCCEEDED(r)) IStream_Release(stm);
|
|
|
|
IStorage_Release(stg2);
|
|
}
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_toplevel_stat(void)
|
|
{
|
|
IStorage *stg = NULL;
|
|
HRESULT r;
|
|
STATSTG stat;
|
|
char prev_dir[MAX_PATH];
|
|
char temp[MAX_PATH];
|
|
char full_path[MAX_PATH];
|
|
LPSTR rel_pathA;
|
|
WCHAR rel_path[MAX_PATH];
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
|
|
ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
|
|
ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
|
|
wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
|
|
IStorage_Release( stg );
|
|
|
|
r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
|
|
|
|
r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
|
|
ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
|
|
ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
|
|
wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
|
|
IStorage_Release( stg );
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* Stat always returns the full path, even for files opened with a relative path. */
|
|
GetCurrentDirectoryA(MAX_PATH, prev_dir);
|
|
|
|
GetTempPathA(MAX_PATH, temp);
|
|
|
|
SetCurrentDirectoryA(temp);
|
|
|
|
GetFullPathNameA(filenameA, MAX_PATH, full_path, &rel_pathA);
|
|
MultiByteToWideChar(CP_ACP, 0, rel_pathA, -1, rel_path, MAX_PATH);
|
|
|
|
r = StgCreateDocfile( rel_path, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
|
|
ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
|
|
ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
|
|
wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
|
|
IStorage_Release( stg );
|
|
|
|
r = StgOpenStorage( rel_path, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
|
|
ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
|
|
|
|
r = IStorage_Stat( stg, &stat, STATFLAG_DEFAULT );
|
|
ok(r==S_OK, "Storage_Stat failed with error 0x%08x\n", r);
|
|
ok(!strcmp_ww(stat.pwcsName, filename), "expected %s, got %s\n",
|
|
wine_dbgstr_w(filename), wine_dbgstr_w(stat.pwcsName));
|
|
CoTaskMemFree(stat.pwcsName);
|
|
|
|
IStorage_Release( stg );
|
|
|
|
SetCurrentDirectoryA(prev_dir);
|
|
|
|
DeleteFileA(filenameA);
|
|
}
|
|
|
|
static void test_substorage_enum(void)
|
|
{
|
|
IStorage *stg, *stg2;
|
|
IEnumSTATSTG *ee;
|
|
HRESULT r;
|
|
ULONG ref;
|
|
static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a substorage */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* create an enumelements */
|
|
r = IStorage_EnumElements(stg2, 0, NULL, 0, &ee);
|
|
ok(r==S_OK, "IStorage->EnumElements failed, hr=%08x\n", r);
|
|
|
|
/* release the substorage */
|
|
ref = IStorage_Release(stg2);
|
|
todo_wine ok(ref==0, "storage not released\n");
|
|
|
|
/* reopening fails, because the substorage is really still open */
|
|
r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStorage failed, hr=%08x\n", r);
|
|
|
|
/* destroying the storage invalidates the enumerator */
|
|
r = IStorage_DestroyElement(stg, stgname);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
r = IEnumSTATSTG_Reset(ee);
|
|
ok(r==STG_E_REVERTED, "IEnumSTATSTG->Reset failed, hr=%08x\n", r);
|
|
|
|
IEnumSTATSTG_Release(ee);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_copyto_locking(void)
|
|
{
|
|
IStorage *stg, *stg2, *stg3, *stg4;
|
|
IStream *stm;
|
|
HRESULT r;
|
|
static const WCHAR stgname[] = { 'S','T','G','1',0 };
|
|
static const WCHAR stgname2[] = { 'S','T','G','2',0 };
|
|
static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a substorage */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* create another substorage */
|
|
r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* add a stream, and leave it open */
|
|
r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
|
|
ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
|
|
|
|
/* Try to copy the storage while the stream is open */
|
|
r = IStorage_CopyTo(stg2, 0, NULL, NULL, stg3);
|
|
ok(r==S_OK, "IStorage->CopyTo failed, hr=%08x\n", r);
|
|
|
|
IStream_Release(stm);
|
|
|
|
/* create a substorage */
|
|
r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg4);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* Try to copy the storage while the substorage is open */
|
|
r = IStorage_CopyTo(stg2, 0, NULL, NULL, stg3);
|
|
ok(r==S_OK, "IStorage->CopyTo failed, hr=%08x\n", r);
|
|
|
|
IStorage_Release(stg4);
|
|
IStorage_Release(stg3);
|
|
IStorage_Release(stg2);
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_copyto_recursive(void)
|
|
{
|
|
IStorage *stg, *stg2, *stg3, *stg4;
|
|
HRESULT r;
|
|
static const WCHAR stgname[] = { 'S','T','G','1',0 };
|
|
static const WCHAR stgname2[] = { 'S','T','G','2',0 };
|
|
|
|
DeleteFileA(filenameA);
|
|
|
|
/* create the file */
|
|
r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
|
|
STGM_READWRITE, 0, &stg);
|
|
ok(r==S_OK, "StgCreateDocfile failed\n");
|
|
|
|
/* create a substorage */
|
|
r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* copy the parent to the child */
|
|
r = IStorage_CopyTo(stg, 0, NULL, NULL, stg2);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->CopyTo failed, hr=%08x\n", r);
|
|
|
|
/* create a transacted substorage */
|
|
r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg3);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* copy the parent to the transacted child */
|
|
r = IStorage_CopyTo(stg, 0, NULL, NULL, stg2);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->CopyTo failed, hr=%08x\n", r);
|
|
|
|
/* create a transacted subsubstorage */
|
|
r = IStorage_CreateStorage(stg3, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg4);
|
|
ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
|
|
|
|
/* copy the parent to the transacted child of the transacted child */
|
|
r = IStorage_CopyTo(stg, 0, NULL, NULL, stg4);
|
|
ok(r==STG_E_ACCESSDENIED, "IStorage->CopyTo failed, hr=%08x\n", r);
|
|
|
|
/* copy the parent but exclude storage objects */
|
|
r = IStorage_CopyTo(stg, 1, &IID_IStorage, NULL, stg4);
|
|
ok(r==S_OK, "IStorage->CopyTo failed, hr=%08x\n", r);
|
|
|
|
IStorage_Release(stg4);
|
|
IStorage_Release(stg3);
|
|
IStorage_Release(stg2);
|
|
IStorage_Release(stg);
|
|
|
|
r = DeleteFileA(filenameA);
|
|
ok( r == TRUE, "deleted file\n");
|
|
}
|
|
|
|
static void test_hglobal_storage_creation(void)
|
|
{
|
|
ILockBytes *ilb = NULL;
|
|
IStorage *stg = NULL;
|
|
HRESULT r;
|
|
STATSTG stat;
|
|
char junk[512];
|
|
ULARGE_INTEGER offset;
|
|
|
|
r = CreateILockBytesOnHGlobal(NULL, TRUE, &ilb);
|
|
ok(r == S_OK, "CreateILockBytesOnHGlobal failed, hr=%x\n", r);
|
|
|
|
offset.QuadPart = 0;
|
|
memset(junk, 0xaa, 512);
|
|
r = ILockBytes_WriteAt(ilb, offset, junk, 512, NULL);
|
|
ok(r == S_OK, "ILockBytes_WriteAt failed, hr=%x\n", r);
|
|
|
|
offset.QuadPart = 2000;
|
|
r = ILockBytes_WriteAt(ilb, offset, junk, 512, NULL);
|
|
ok(r == S_OK, "ILockBytes_WriteAt failed, hr=%x\n", r);
|
|
|
|
r = StgCreateDocfileOnILockBytes(ilb, STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stg);
|
|
ok(r == S_OK, "StgCreateDocfileOnILockBytes failed, hr=%x\n", r);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
r = StgOpenStorageOnILockBytes(ilb, NULL, STGM_READ|STGM_SHARE_EXCLUSIVE,
|
|
NULL, 0, &stg);
|
|
ok(r == S_OK, "StgOpenStorageOnILockBytes failed, hr=%x\n", r);
|
|
|
|
if (SUCCEEDED(r))
|
|
{
|
|
r = IStorage_Stat(stg, &stat, STATFLAG_NONAME);
|
|
ok(r == S_OK, "StgOpenStorageOnILockBytes failed, hr=%x\n", r);
|
|
ok(IsEqualCLSID(&stat.clsid, &GUID_NULL), "unexpected CLSID value\n");
|
|
|
|
IStorage_Release(stg);
|
|
}
|
|
|
|
r = ILockBytes_Stat(ilb, &stat, STATFLAG_NONAME);
|
|
ok(r == S_OK, "ILockBytes_Stat failed, hr=%x\n", r);
|
|
ok(stat.cbSize.u.LowPart < 2512, "expected truncated size, got %d\n", stat.cbSize.u.LowPart);
|
|
|
|
ILockBytes_Release(ilb);
|
|
}
|
|
|
|
static void test_convert(void)
|
|
{
|
|
static const WCHAR filename[] = {'s','t','o','r','a','g','e','.','s','t','g',0};
|
|
IStorage *stg;
|
|
HRESULT hr;
|
|
|
|
hr = GetConvertStg(NULL);
|
|
ok(hr == E_INVALIDARG, "got 0x%08x\n", hr);
|
|
|
|
hr = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
|
|
ok(hr == S_OK, "StgCreateDocfile failed\n");
|
|
hr = GetConvertStg(stg);
|
|
ok(hr == STG_E_FILENOTFOUND, "got 0x%08x\n", hr);
|
|
hr = SetConvertStg(stg, TRUE);
|
|
ok(hr == S_OK, "got 0x%08x\n", hr);
|
|
hr = SetConvertStg(stg, TRUE);
|
|
ok(hr == S_OK, "got 0x%08x\n", hr);
|
|
hr = GetConvertStg(stg);
|
|
ok(hr == S_OK, "got 0x%08x\n", hr);
|
|
hr = SetConvertStg(stg, FALSE);
|
|
ok(hr == S_OK, "got 0x%08x\n", hr);
|
|
hr = GetConvertStg(stg);
|
|
ok(hr == S_FALSE, "got 0x%08x\n", hr);
|
|
|
|
IStorage_Release(stg);
|
|
|
|
DeleteFileW(filename);
|
|
}
|
|
|
|
START_TEST(storage32)
|
|
{
|
|
CHAR temp[MAX_PATH];
|
|
|
|
GetTempPathA(MAX_PATH, temp);
|
|
if(!GetTempFileNameA(temp, "stg", 0, filenameA))
|
|
{
|
|
win_skip("Could not create temp file, %u\n", GetLastError());
|
|
return;
|
|
}
|
|
MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
|
|
DeleteFileA(filenameA);
|
|
|
|
test_hglobal_storage_stat();
|
|
test_create_storage_modes();
|
|
test_stgcreatestorageex();
|
|
test_storage_stream();
|
|
test_open_storage();
|
|
test_storage_suminfo();
|
|
test_storage_refcount();
|
|
test_streamenum();
|
|
test_transact();
|
|
test_substorage_share();
|
|
test_revert();
|
|
test_parent_free();
|
|
test_nonroot_transacted();
|
|
test_ReadClassStm();
|
|
test_access();
|
|
test_writeclassstg();
|
|
test_readonly();
|
|
test_simple();
|
|
test_fmtusertypestg();
|
|
test_references();
|
|
test_copyto();
|
|
test_copyto_snbexclusions();
|
|
test_copyto_iidexclusions_storage();
|
|
test_copyto_iidexclusions_stream();
|
|
test_rename();
|
|
test_toplevel_stat();
|
|
test_substorage_enum();
|
|
test_copyto_locking();
|
|
test_copyto_recursive();
|
|
test_hglobal_storage_creation();
|
|
test_convert();
|
|
}
|