2 * Unit tests for OLE storage
4 * Copyright (c) 2004 Mike McCormack
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
21 #define WIN32_NO_STATUS
23 #define COM_NO_WINDOWS_H
28 #define NONAMELESSUNION
29 #define NONAMELESSSTRUCT
31 //#include <windows.h>
32 #include <wine/test.h>
38 DEFINE_GUID( test_stg_cls
, 0x88888888, 0x0425, 0x0000, 0,0,0,0,0,0,0,0);
40 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
42 static CHAR filenameA
[MAX_PATH
];
43 static WCHAR filename
[MAX_PATH
];
45 static const char file1_nameA
[] = {'c','o','p','y','t','e','s','t','A',0};
46 static const WCHAR file1_name
[] = {'c','o','p','y','t','e','s','t','A',0};
47 static const char file2_nameA
[] = {'c','o','p','y','t','e','s','t','B',0};
48 static const WCHAR file2_name
[] = {'c','o','p','y','t','e','s','t','B',0};
49 static const WCHAR stgA_name
[] = {'S','t','o','r','a','g','e','A',0};
50 static const WCHAR stgB_name
[] = {'S','t','o','r','a','g','e','B',0};
51 static const WCHAR strmA_name
[] = {'S','t','r','e','a','m','A',0};
52 static const WCHAR strmB_name
[] = {'S','t','r','e','a','m','B',0};
53 static const WCHAR strmC_name
[] = {'S','t','r','e','a','m','C',0};
55 /* Win9x and WinMe don't have lstrcmpW */
56 static int strcmp_ww(LPCWSTR strw1
, LPCWSTR strw2
)
58 CHAR stra1
[512], stra2
[512];
59 WideCharToMultiByte(CP_ACP
, 0, strw1
, -1, stra1
, sizeof(stra1
), NULL
, NULL
);
60 WideCharToMultiByte(CP_ACP
, 0, strw2
, -1, stra2
, sizeof(stra2
), NULL
, NULL
);
61 return lstrcmpA(stra1
, stra2
);
64 static void test_hglobal_storage_stat(void)
66 ILockBytes
*ilb
= NULL
;
72 r
= CreateILockBytesOnHGlobal( NULL
, TRUE
, &ilb
);
73 ok( r
== S_OK
, "CreateILockBytesOnHGlobal failed\n");
75 r
= StgIsStorageILockBytes( ilb
);
76 ok( r
== S_FALSE
, "StgIsStorageILockBytes should have failed\n");
78 mode
= STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
;/*0x1012*/
79 r
= StgCreateDocfileOnILockBytes( ilb
, mode
, 0, &stg
);
80 ok( r
== S_OK
, "StgCreateDocfileOnILockBytes failed\n");
82 r
= WriteClassStg( stg
, &test_stg_cls
);
83 ok( r
== S_OK
, "WriteClassStg failed\n");
85 r
= StgIsStorageILockBytes( ilb
);
86 ok( r
== S_OK
, "StgIsStorageILockBytes failed\n");
88 memset( &stat
, 0, sizeof stat
);
89 r
= IStorage_Stat( stg
, &stat
, 0 );
91 ok( stat
.pwcsName
== NULL
, "storage name not null\n");
92 ok( stat
.type
== 1, "type is wrong\n");
93 ok( stat
.grfMode
== 0x12, "grf mode is incorrect\n");
94 ok( !memcmp(&stat
.clsid
, &test_stg_cls
, sizeof test_stg_cls
), "CLSID is wrong\n");
96 refcount
= IStorage_Release( stg
);
97 ok( refcount
== 0, "IStorage refcount is wrong\n");
98 refcount
= ILockBytes_Release( ilb
);
99 ok( refcount
== 0, "ILockBytes refcount is wrong\n");
102 static void test_create_storage_modes(void)
104 IStorage
*stg
= NULL
;
107 DeleteFileA(filenameA
);
109 /* test with some invalid parameters */
110 r
= StgCreateDocfile( NULL
, 0, 0, &stg
);
111 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
112 r
= StgCreateDocfile( filename
, 0, 0, &stg
);
113 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
114 r
= StgCreateDocfile( filename
, STGM_CREATE
, 0, &stg
);
115 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
116 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_READWRITE
, 0, &stg
);
117 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
118 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
, 0, &stg
);
119 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
120 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, NULL
);
121 ok(r
==STG_E_INVALIDPOINTER
, "StgCreateDocfile succeeded\n");
122 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 1, &stg
);
123 ok(r
==STG_E_INVALIDPARAMETER
, "StgCreateDocfile succeeded\n");
124 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, 0, &stg
);
125 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
126 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, &stg
);
127 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
128 r
= StgCreateDocfile( filename
, STGM_PRIORITY
, 0, &stg
);
129 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
131 /* StgCreateDocfile seems to be very particular about the flags it accepts */
132 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| STGM_WRITE
, 0, &stg
);
133 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
134 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 8, 0, &stg
);
135 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
136 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x80, 0, &stg
);
137 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
138 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x800, 0, &stg
);
139 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
140 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x8000, 0, &stg
);
141 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
142 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x80000, 0, &stg
);
143 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
144 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x800000, 0, &stg
);
145 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
146 ok(stg
== NULL
, "stg was set\n");
148 /* check what happens if the file already exists (which is how it's meant to be used) */
149 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
150 ok(r
==S_OK
, "StgCreateDocfile failed\n");
151 r
= IStorage_Release(stg
);
152 ok(r
== 0, "storage not released\n");
153 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
154 ok(r
==STG_E_FILEALREADYEXISTS
, "StgCreateDocfile wrong error\n"); /* FAILIFTHERE is default */
155 r
= StgCreateDocfile( filename
, STGM_READ
, 0, &stg
);
156 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n"); /* need at least readmode and sharemode */
157 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
, 0, &stg
);
158 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
159 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_WRITE
, 0, &stg
);
160 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
161 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
, 0, &stg
);
162 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
163 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
| STGM_TRANSACTED
, 0, &stg
);
164 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
165 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
| STGM_READWRITE
, 0, &stg
);
166 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
167 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
| STGM_WRITE
, 0, &stg
);
168 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
169 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_WRITE
| STGM_WRITE
, 0, &stg
);
170 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
171 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_WRITE
| STGM_READ
, 0, &stg
);
172 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile wrong error\n");
173 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
| STGM_SHARE_DENY_WRITE
| STGM_READ
, 0, &stg
);
174 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile wrong error\n");
175 ok(DeleteFileA(filenameA
), "failed to delete file\n");
177 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
178 ok(r
==S_OK
, "StgCreateDocfile failed\n");
179 r
= IStorage_Release(stg
);
180 ok(r
== 0, "storage not released\n");
181 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
|STGM_FAILIFTHERE
, 0, &stg
);
182 ok(r
==STG_E_FILEALREADYEXISTS
, "StgCreateDocfile wrong error\n");
183 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_WRITE
, 0, &stg
);
184 ok(r
==STG_E_FILEALREADYEXISTS
, "StgCreateDocfile wrong error\n");
186 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, 0, &stg
);
187 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
188 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
189 ok(r
==S_OK
, "StgCreateDocfile failed\n");
190 r
= IStorage_Release(stg
);
191 ok(r
== 0, "storage not released\n");
192 ok(DeleteFileA(filenameA
), "failed to delete file\n");
194 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
195 ok(r
==S_OK
, "StgCreateDocfile failed\n");
196 r
= IStorage_Release(stg
);
197 ok(r
== 0, "storage not released\n");
198 ok(DeleteFileA(filenameA
), "failed to delete file\n");
200 /* test the way excel uses StgCreateDocFile */
201 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
|STGM_CREATE
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
, 0, &stg
);
202 ok(r
==S_OK
, "StgCreateDocfile the excel way failed\n");
205 r
= IStorage_Release(stg
);
206 ok(r
== 0, "storage not released\n");
207 ok(DeleteFileA(filenameA
), "failed to delete file\n");
210 /* and the way windows media uses it ... */
211 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_DENY_NONE
| STGM_READWRITE
| STGM_TRANSACTED
, 0, &stg
);
212 ok(r
==S_OK
, "StgCreateDocfile the windows media way failed\n");
215 r
= IStorage_Release(stg
);
216 ok(r
== 0, "storage not released\n");
217 ok(DeleteFileA(filenameA
), "failed to delete file\n");
220 /* looks like we need STGM_TRANSACTED or STGM_CREATE */
221 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
, 0, &stg
);
222 ok(r
==S_OK
, "StgCreateDocfile the excel way failed\n");
225 r
= IStorage_Release(stg
);
226 ok(r
== 0, "storage not released\n");
227 ok(DeleteFileA(filenameA
), "failed to delete file\n");
230 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
|STGM_CREATE
|STGM_SHARE_DENY_WRITE
|STGM_WRITE
, 0, &stg
);
231 ok(r
==S_OK
, "StgCreateDocfile the excel way failed\n");
234 r
= IStorage_Release(stg
);
235 ok(r
== 0, "storage not released\n");
236 ok(DeleteFileA(filenameA
), "failed to delete file\n");
239 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
240 ok(r
==S_OK
, "StgCreateDocfile the powerpoint way failed\n");
243 r
= IStorage_Release(stg
);
244 ok(r
== 0, "storage not released\n");
245 ok(DeleteFileA(filenameA
), "failed to delete file\n");
248 /* test the way msi uses StgCreateDocfile */
249 r
= StgCreateDocfile( filename
, STGM_DIRECT
| STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stg
);
250 ok(r
==S_OK
, "StgCreateDocFile failed\n");
251 r
= IStorage_Release(stg
);
252 ok(r
== 0, "storage not released\n");
253 ok(DeleteFileA(filenameA
), "failed to delete file\n");
256 static void test_stgcreatestorageex(void)
258 HRESULT (WINAPI
*pStgCreateStorageEx
)(const WCHAR
* pwcsName
, DWORD grfMode
, DWORD stgfmt
, DWORD grfAttrs
, STGOPTIONS
* pStgOptions
, void* reserved
, REFIID riid
, void** ppObjectOpen
);
259 HMODULE hOle32
= GetModuleHandleA("ole32");
260 IStorage
*stg
= NULL
;
261 STGOPTIONS stgoptions
= {1, 0, 4096};
264 pStgCreateStorageEx
= (void *) GetProcAddress(hOle32
, "StgCreateStorageEx");
265 if (!pStgCreateStorageEx
)
267 win_skip("skipping test on NT4\n");
271 DeleteFileA(filenameA
);
273 /* Verify that StgCreateStorageEx can accept an options param */
274 r
= pStgCreateStorageEx( filename
,
275 STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
,
282 ok(r
==S_OK
|| r
==STG_E_UNIMPLEMENTEDFUNCTION
, "StgCreateStorageEx with options failed\n");
283 if (r
==STG_E_UNIMPLEMENTEDFUNCTION
)
285 /* We're on win98 which means all bets are off. Let's get out of here. */
286 win_skip("skipping test on win9x\n");
290 r
= IStorage_Release(stg
);
291 ok(r
== 0, "storage not released\n");
292 ok(DeleteFileA(filenameA
), "failed to delete file\n");
294 /* Verify that StgCreateStorageEx can accept a NULL pStgOptions */
295 r
= pStgCreateStorageEx( filename
,
296 STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
,
303 ok(r
==S_OK
, "StgCreateStorageEx with NULL options failed\n");
304 r
= IStorage_Release(stg
);
305 ok(r
== 0, "storage not released\n");
306 ok(DeleteFileA(filenameA
), "failed to delete file\n");
309 static void test_storage_stream(void)
311 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
312 static const WCHAR longname
[] = {
313 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
314 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
316 IStorage
*stg
= NULL
;
319 IStream
*stm2
= NULL
;
323 unsigned char buffer
[0x100];
326 DeleteFileA(filenameA
);
328 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
329 ok(r
==S_OK
, "StgCreateDocfile failed\n");
331 /* try create some invalid streams */
332 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 1, 0, &stm
);
333 ok(r
==STG_E_INVALIDPARAMETER
, "IStorage->CreateStream wrong error\n");
334 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 1, &stm
);
335 ok(r
==STG_E_INVALIDPARAMETER
, "IStorage->CreateStream wrong error\n");
336 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, NULL
);
337 ok(r
==STG_E_INVALIDPOINTER
, "IStorage->CreateStream wrong error\n");
338 r
= IStorage_CreateStream(stg
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
339 ok(r
==STG_E_INVALIDNAME
, "IStorage->CreateStream wrong error\n");
340 r
= IStorage_CreateStream(stg
, longname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
341 ok(r
==STG_E_INVALIDNAME
|| broken(r
==S_OK
) /* nt4 */,
342 "IStorage->CreateStream wrong error, got %d GetLastError()=%d\n", r
, GetLastError());
343 r
= IStorage_CreateStream(stg
, stmname
, STGM_READWRITE
, 0, 0, &stm
);
344 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
345 r
= IStorage_CreateStream(stg
, stmname
, STGM_READ
, 0, 0, &stm
);
346 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
347 r
= IStorage_CreateStream(stg
, stmname
, STGM_WRITE
, 0, 0, &stm
);
348 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
349 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_DENY_NONE
| STGM_READWRITE
, 0, 0, &stm
);
350 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
351 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_DENY_NONE
| STGM_READ
, 0, 0, &stm
);
352 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
354 /* now really create a stream and delete it */
355 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
356 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
358 /* test for support interfaces */
359 r
= IStream_QueryInterface(stm
, &IID_IPersist
, (void**)&unk
);
360 ok(r
==E_NOINTERFACE
, "got 0x%08x\n", r
);
361 r
= IStream_QueryInterface(stm
, &IID_IPersistStream
, (void**)&unk
);
362 ok(r
==E_NOINTERFACE
, "got 0x%08x\n", r
);
364 r
= IStream_Release(stm
);
365 ok(r
== 0, "wrong ref count\n");
366 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
367 ok(r
==STG_E_FILEALREADYEXISTS
, "IStorage->CreateStream failed\n");
368 r
= IStorage_DestroyElement(stg
,stmname
);
369 ok(r
==S_OK
, "IStorage->DestroyElement failed\n");
371 /* create a stream and write to it */
372 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
373 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
375 r
= IStream_Clone(stm
, &stm2
);
376 ok(r
==S_OK
, "failed to clone stream\n");
378 r
= IStream_Write(stm
, NULL
, 0, NULL
);
379 ok(r
==STG_E_INVALIDPOINTER
, "IStream->Write wrong error\n");
380 r
= IStream_Write(stm
, "Hello\n", 0, NULL
);
381 ok(r
==S_OK
, "failed to write stream\n");
382 r
= IStream_Write(stm
, "Hello\n", 0, &count
);
383 ok(r
==S_OK
, "failed to write stream\n");
384 r
= IStream_Write(stm
, "Hello\n", 6, &count
);
385 ok(r
==S_OK
, "failed to write stream\n");
386 r
= IStream_Commit(stm
, STGC_DEFAULT
);
387 ok(r
==S_OK
, "failed to commit stream\n");
388 r
= IStream_Commit(stm
, STGC_DEFAULT
);
389 ok(r
==S_OK
, "failed to commit stream\n");
391 /* Read past the end of the stream. */
393 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
394 ok(r
==S_OK
, "failed to seek stream\n");
395 ok(p
.QuadPart
== 3, "at wrong place\n");
396 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
397 ok(r
==S_OK
, "failed to read\n");
398 ok(count
== 3, "read bytes past end of stream\n");
400 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
401 ok(r
==S_OK
, "failed to seek stream\n");
402 ok(p
.QuadPart
== 10, "at wrong place\n");
403 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
404 ok(r
==S_OK
, "failed to read\n");
405 ok(count
== 0, "read bytes past end of stream\n");
406 pos
.QuadPart
= 10000;
407 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
408 ok(r
==S_OK
, "failed to seek stream\n");
409 ok(p
.QuadPart
== 10000, "at wrong place\n");
410 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
411 ok(r
==S_OK
, "failed to read\n");
412 ok(count
== 0, "read bytes past end of stream\n");
414 /* Convert to a big block stream, and read past the end. */
416 r
= IStream_SetSize(stm
,p
);
417 ok(r
==S_OK
, "failed to set pos\n");
419 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
420 ok(r
==S_OK
, "failed to seek stream\n");
421 ok(p
.QuadPart
== 4997, "at wrong place\n");
422 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
423 ok(r
==S_OK
, "failed to read\n");
424 ok(count
== 3, "read bytes past end of stream\n");
426 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
427 ok(r
==S_OK
, "failed to seek stream\n");
428 ok(p
.QuadPart
== 5001, "at wrong place\n");
429 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
430 ok(r
==S_OK
, "failed to read\n");
431 ok(count
== 0, "read bytes past end of stream\n");
432 pos
.QuadPart
= 10000;
433 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
434 ok(r
==S_OK
, "failed to seek stream\n");
435 ok(p
.QuadPart
== 10000, "at wrong place\n");
436 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
437 ok(r
==S_OK
, "failed to read\n");
438 ok(count
== 0, "read bytes past end of stream\n");
440 /* seek round a bit, reset the stream size */
442 r
= IStream_Seek(stm
, pos
, 3, &p
);
443 ok(r
==STG_E_INVALIDFUNCTION
, "IStream->Seek returned wrong error\n");
444 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, NULL
);
445 ok(r
==S_OK
, "failed to seek stream\n");
446 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
447 ok(r
==S_OK
, "failed to seek stream\n");
448 r
= IStream_SetSize(stm
,p
);
449 ok(r
==S_OK
, "failed to set pos\n");
451 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
452 ok(r
==S_OK
, "failed to seek stream\n");
453 ok(p
.QuadPart
== 10, "at wrong place\n");
454 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
455 ok(r
==S_OK
, "failed to set pos\n");
456 ok(count
== 0, "read bytes from empty stream\n");
457 pos
.QuadPart
= 10000;
458 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
459 ok(r
==S_OK
, "failed to seek stream\n");
460 ok(p
.QuadPart
== 10000, "at wrong place\n");
461 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
462 ok(r
==S_OK
, "failed to set pos\n");
463 ok(count
== 0, "read bytes from empty stream\n");
465 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_END
, &p
);
466 ok(r
==S_OK
, "failed to seek stream\n");
467 ok(p
.QuadPart
== 0, "at wrong place\n");
468 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
469 ok(r
==S_OK
, "failed to set pos\n");
470 ok(count
== 0, "read bytes from empty stream\n");
473 r
= IStream_Release(stm2
);
474 ok(r
== 0, "wrong ref count\n");
476 /* create a stream and write to it */
477 r
= IStorage_CreateStream(stg
, stmname
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm2
);
478 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
480 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
481 ok(r
==STG_E_REVERTED
, "overwritten stream should return STG_E_REVERTED instead of 0x%08x\n", r
);
483 r
= IStream_Release(stm2
);
484 ok(r
== 0, "wrong ref count\n");
485 r
= IStream_Release(stm
);
486 ok(r
== 0, "wrong ref count\n");
488 r
= IStorage_Release(stg
);
489 ok(r
== 0, "wrong ref count\n");
491 /* try create some invalid streams */
494 r
= StgOpenStorage(filename
, NULL
, STGM_READ
| STGM_SHARE_DENY_WRITE
, NULL
, 0, &stg
);
495 ok(r
== S_OK
, "should succeed\n");
498 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stm
);
499 ok(r
== STG_E_INVALIDFLAG
, "IStorage->OpenStream should return STG_E_INVALIDFLAG instead of 0x%08x\n", r
);
500 IStorage_Release(stg
);
503 r
= DeleteFileA(filenameA
);
504 ok(r
, "file should exist\n");
507 static BOOL
touch_file(LPCSTR filename
)
511 file
= CreateFileA(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
512 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
513 if (file
==INVALID_HANDLE_VALUE
)
519 static BOOL
is_zero_length(LPCSTR filename
)
524 file
= CreateFileA(filename
, GENERIC_READ
, 0, NULL
,
525 OPEN_EXISTING
, 0, NULL
);
526 if (file
==INVALID_HANDLE_VALUE
)
528 len
= GetFileSize(file
, NULL
);
533 static BOOL
is_existing_file(LPCSTR filename
)
537 file
= CreateFileA(filename
, GENERIC_READ
, 0, NULL
,
538 OPEN_EXISTING
, 0, NULL
);
539 if (file
==INVALID_HANDLE_VALUE
)
545 static void test_open_storage(void)
547 static const WCHAR szNonExist
[] = { 'n','o','n','e','x','i','s','t',0 };
548 IStorage
*stg
= NULL
, *stg2
= NULL
;
552 /* try opening a zero length file - it should stay zero length */
553 DeleteFileA(filenameA
);
554 touch_file(filenameA
);
555 stgm
= STGM_NOSCRATCH
| STGM_TRANSACTED
| STGM_SHARE_DENY_WRITE
| STGM_READWRITE
;
556 r
= StgOpenStorage( filename
, NULL
, stgm
, NULL
, 0, &stg
);
557 ok(r
==STG_E_FILEALREADYEXISTS
, "StgOpenStorage didn't fail\n");
559 stgm
= STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
;
560 r
= StgOpenStorage( filename
, NULL
, stgm
, NULL
, 0, &stg
);
561 ok(r
==STG_E_FILEALREADYEXISTS
, "StgOpenStorage didn't fail\n");
562 ok(is_zero_length(filenameA
), "file length changed\n");
564 DeleteFileA(filenameA
);
566 /* try opening a nonexistent file - it should not create it */
567 stgm
= STGM_DIRECT
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
;
568 r
= StgOpenStorage( filename
, NULL
, stgm
, NULL
, 0, &stg
);
569 ok(r
!=S_OK
, "StgOpenStorage failed: 0x%08x\n", r
);
570 if (r
==S_OK
) IStorage_Release(stg
);
571 ok(!is_existing_file(filenameA
), "StgOpenStorage should not create a file\n");
572 DeleteFileA(filenameA
);
574 /* create the file */
575 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
576 ok(r
==S_OK
, "StgCreateDocfile failed\n");
577 IStorage_Release(stg
);
579 r
= StgOpenStorage( filename
, NULL
, 0, NULL
, 0, &stg
);
580 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage wrong error\n");
581 r
= StgOpenStorage( NULL
, NULL
, STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg
);
582 ok(r
==STG_E_INVALIDNAME
, "StgOpenStorage wrong error\n");
583 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, NULL
);
584 ok(r
==STG_E_INVALIDPOINTER
, "StgOpenStorage wrong error\n");
585 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 1, &stg
);
586 ok(r
==STG_E_INVALIDPARAMETER
, "StgOpenStorage wrong error\n");
587 r
= StgOpenStorage( szNonExist
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
588 ok(r
==STG_E_FILENOTFOUND
, "StgOpenStorage failed\n");
589 r
= StgOpenStorage( filename
, NULL
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
590 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
591 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_NONE
| STGM_READ
, NULL
, 0, &stg
);
592 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
593 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_READ
| STGM_READ
, NULL
, 0, &stg
);
594 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
595 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, NULL
, 0, &stg
);
596 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
598 /* open it for real */
599 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_NONE
| STGM_READ
| STGM_TRANSACTED
, NULL
, 0, &stg
); /* XLViewer 97/2000 */
600 ok(r
==S_OK
, "StgOpenStorage failed\n");
603 r
= IStorage_Release(stg
);
604 ok(r
== 0, "wrong ref count\n");
607 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_WRITE
| STGM_READ
, NULL
, 0, &stg
);
608 ok(r
==S_OK
, "StgOpenStorage failed\n");
611 r
= IStorage_Release(stg
);
612 ok(r
== 0, "wrong ref count\n");
615 /* test the way word opens its custom dictionary */
616 r
= StgOpenStorage( filename
, NULL
, STGM_NOSCRATCH
| STGM_TRANSACTED
|
617 STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, NULL
, 0, &stg
);
618 ok(r
==S_OK
, "StgOpenStorage failed\n");
621 r
= IStorage_Release(stg
);
622 ok(r
== 0, "wrong ref count\n");
625 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
626 ok(r
==S_OK
, "StgOpenStorage failed\n");
627 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg2
);
628 ok(r
==STG_E_SHAREVIOLATION
, "StgOpenStorage failed\n");
631 r
= IStorage_Release(stg
);
632 ok(r
== 0, "wrong ref count\n");
635 /* now try write to a storage file we opened read-only */
636 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
637 ok(r
==S_OK
, "StgOpenStorage failed\n");
640 static const WCHAR stmname
[] = { 'w','i','n','e','t','e','s','t',0};
642 IStorage
*stg2
= NULL
;
644 r
= IStorage_CreateStream( stg
, stmname
, STGM_WRITE
| STGM_SHARE_EXCLUSIVE
,
646 ok(r
== STG_E_ACCESSDENIED
, "CreateStream should fail\n");
647 r
= IStorage_CreateStorage( stg
, stmname
, STGM_WRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
648 ok(r
== STG_E_ACCESSDENIED
, "CreateStream should fail\n");
650 r
= IStorage_Release(stg
);
651 ok(r
== 0, "wrong ref count\n");
654 /* open like visio 2003 */
656 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_DENY_NONE
, NULL
, 0, &stg
);
657 ok(r
== S_OK
, "should succeed\n");
659 IStorage_Release(stg
);
661 /* test other sharing modes with STGM_PRIORITY */
663 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg
);
664 ok(r
== S_OK
, "should succeed\n");
666 IStorage_Release(stg
);
669 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_DENY_WRITE
, NULL
, 0, &stg
);
670 ok(r
== S_OK
, "should succeed\n");
672 IStorage_Release(stg
);
675 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_DENY_READ
, NULL
, 0, &stg
);
676 ok(r
== S_OK
, "should succeed\n");
678 IStorage_Release(stg
);
680 /* open like Project 2003 */
682 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
, NULL
, 0, &stg
);
683 ok(r
== S_OK
, "should succeed\n");
684 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
, NULL
, 0, &stg2
);
685 ok(r
== S_OK
, "should succeed\n");
687 IStorage_Release(stg2
);
689 IStorage_Release(stg
);
692 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_READWRITE
, NULL
, 0, &stg
);
693 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
695 r
= StgOpenStorage( filename
, NULL
, STGM_TRANSACTED
| STGM_PRIORITY
, NULL
, 0, &stg
);
696 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
698 r
= StgOpenStorage( filename
, NULL
, STGM_SIMPLE
| STGM_PRIORITY
, NULL
, 0, &stg
);
699 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
701 r
= StgOpenStorage( filename
, NULL
, STGM_DELETEONRELEASE
| STGM_PRIORITY
, NULL
, 0, &stg
);
702 ok(r
== STG_E_INVALIDFUNCTION
, "should fail\n");
704 r
= StgOpenStorage( filename
, NULL
, STGM_NOSCRATCH
| STGM_PRIORITY
, NULL
, 0, &stg
);
705 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
707 r
= StgOpenStorage( filename
, NULL
, STGM_NOSNAPSHOT
| STGM_PRIORITY
, NULL
, 0, &stg
);
708 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
710 r
= DeleteFileA(filenameA
);
711 ok(r
, "file didn't exist\n");
714 static void test_storage_suminfo(void)
716 IStorage
*stg
= NULL
;
717 IPropertySetStorage
*propset
= NULL
;
718 IPropertyStorage
*ps
= NULL
;
721 DeleteFileA(filenameA
);
723 /* create the file */
724 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
725 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
726 ok(r
==S_OK
, "StgCreateDocfile failed\n");
728 r
= IStorage_QueryInterface( stg
, &IID_IPropertySetStorage
, (LPVOID
) &propset
);
729 ok(r
== S_OK
, "query interface failed\n");
732 r
= IPropertySetStorage_Delete( propset
, &FMTID_SummaryInformation
);
733 ok(r
== STG_E_FILENOTFOUND
, "deleted property set storage\n");
735 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
736 STGM_READ
| STGM_SHARE_EXCLUSIVE
, &ps
);
737 ok(r
== STG_E_FILENOTFOUND
, "opened property set storage\n");
739 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
740 STGM_READ
| STGM_SHARE_EXCLUSIVE
, &ps
);
741 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
743 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
745 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
747 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0, 0, &ps
);
748 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
750 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
751 STGM_WRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
752 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
754 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
755 STGM_CREATE
|STGM_WRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
756 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
758 /* now try really creating a property set */
759 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
760 STGM_CREATE
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
761 ok(r
== S_OK
, "failed to create property set storage\n");
764 IPropertyStorage_Release(ps
);
766 /* now try creating the same thing again */
767 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
768 STGM_CREATE
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
769 ok(r
== S_OK
, "failed to create property set storage\n");
771 IPropertyStorage_Release(ps
);
773 /* should be able to open it */
774 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
775 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
776 ok(r
== S_OK
, "open failed\n");
778 IPropertyStorage_Release(ps
);
781 r
= IPropertySetStorage_Delete( propset
, &FMTID_SummaryInformation
);
782 ok(r
== S_OK
, "failed to delete property set storage\n");
784 /* try opening with an invalid FMTID */
785 r
= IPropertySetStorage_Open( propset
, NULL
,
786 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
787 ok(r
== E_INVALIDARG
, "open succeeded\n");
789 IPropertyStorage_Release(ps
);
792 r
= IPropertySetStorage_Open( propset
, &IID_IStorage
,
793 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
794 ok(r
== STG_E_FILENOTFOUND
, "open succeeded\n");
796 IPropertyStorage_Release(ps
);
799 /* try some invalid flags */
800 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
801 STGM_CREATE
| STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
802 ok(r
== STG_E_INVALIDFLAG
, "open succeeded\n");
804 IPropertyStorage_Release(ps
);
806 /* after deleting it, it should be gone */
807 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
808 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
809 ok(r
== STG_E_FILENOTFOUND
, "open failed\n");
811 IPropertyStorage_Release(ps
);
813 r
= IPropertySetStorage_Release( propset
);
814 ok(r
== 1, "ref count wrong\n");
816 r
= IStorage_Release(stg
);
817 ok(r
== 0, "ref count wrong\n");
819 DeleteFileA(filenameA
);
822 static void test_storage_refcount(void)
824 IStorage
*stg
= NULL
;
825 IStorage
*stgprio
= NULL
;
828 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
834 DeleteFileA(filenameA
);
836 /* create the file */
837 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
838 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
839 ok(r
==S_OK
, "StgCreateDocfile failed\n");
841 r
= WriteClassStg( stg
, &test_stg_cls
);
842 ok( r
== S_OK
, "WriteClassStg failed\n");
844 r
= IStorage_Commit( stg
, STGC_DEFAULT
);
845 ok( r
== S_OK
, "IStorage_Commit failed\n");
847 /* now create a stream */
848 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
849 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
851 r
= IStorage_Release( stg
);
852 ok (r
== 0, "storage not released\n");
855 r
= IStream_Seek( stm
, pos
, 0, &upos
);
856 ok (r
== STG_E_REVERTED
, "seek should fail\n");
858 r
= IStream_Stat( stm
, &stat
, STATFLAG_DEFAULT
);
859 ok (r
== STG_E_REVERTED
, "stat should fail\n");
861 r
= IStream_Write( stm
, "Test string", strlen("Test string"), NULL
);
862 ok (r
== STG_E_REVERTED
, "IStream_Write should return STG_E_REVERTED instead of 0x%08x\n", r
);
864 r
= IStream_Read( stm
, buffer
, sizeof(buffer
), NULL
);
865 ok (r
== STG_E_REVERTED
, "IStream_Read should return STG_E_REVERTED instead of 0x%08x\n", r
);
867 r
= IStream_Release(stm
);
868 ok (r
== 0, "stream not released\n");
870 /* tests that STGM_PRIORITY doesn't prevent readwrite access from other
871 * StgOpenStorage calls in transacted mode */
872 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
, NULL
, 0, &stgprio
);
873 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
875 /* non-transacted mode read/write fails */
876 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg
);
877 ok(r
==STG_E_LOCKVIOLATION
, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08x\n", r
);
879 /* non-transacted mode read-only succeeds */
880 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_WRITE
|STGM_READ
, NULL
, 0, &stg
);
881 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
882 IStorage_Release(stg
);
884 r
= StgOpenStorage( filename
, NULL
, STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
, NULL
, 0, &stg
);
885 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
888 static const WCHAR stgname
[] = { ' ',' ',' ','2','9',0 };
889 static const WCHAR stgname2
[] = { 'C','V','_','i','e','w',0 };
890 static const WCHAR stmname2
[] = { 'V','a','r','2','D','a','t','a',0 };
895 r
= IStorage_Stat( stg
, &statstg
, STATFLAG_NONAME
);
896 ok(r
== S_OK
, "Stat should have succeeded instead of returning 0x%08x\n", r
);
897 ok(statstg
.type
== STGTY_STORAGE
, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg
.type
);
898 ok(U(statstg
.cbSize
).LowPart
== 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg
.cbSize
).LowPart
);
899 ok(U(statstg
.cbSize
).HighPart
== 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg
.cbSize
).HighPart
);
900 ok(statstg
.grfMode
== (STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
),
901 "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg
.grfMode
);
902 ok(statstg
.grfLocksSupported
== 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg
.grfLocksSupported
);
903 ok(IsEqualCLSID(&statstg
.clsid
, &test_stg_cls
), "Statstg clsid is not test_stg_cls\n");
904 ok(statstg
.grfStateBits
== 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg
.grfStateBits
);
905 ok(statstg
.reserved
== 0, "Statstg reserved should have been 0 instead of %d\n", statstg
.reserved
);
907 r
= IStorage_CreateStorage( stg
, stgname
, STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
908 ok(r
== S_OK
, "CreateStorage should have succeeded instead of returning 0x%08x\n", r
);
910 r
= IStorage_Stat( stg2
, &statstg
, STATFLAG_DEFAULT
);
911 ok(r
== S_OK
, "Stat should have succeeded instead of returning 0x%08x\n", r
);
912 ok(!memcmp(statstg
.pwcsName
, stgname
, sizeof(stgname
)),
913 "Statstg pwcsName should have been the name the storage was created with\n");
914 ok(statstg
.type
== STGTY_STORAGE
, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg
.type
);
915 ok(U(statstg
.cbSize
).LowPart
== 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg
.cbSize
).LowPart
);
916 ok(U(statstg
.cbSize
).HighPart
== 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg
.cbSize
).HighPart
);
917 ok(statstg
.grfMode
== STGM_SHARE_EXCLUSIVE
,
918 "Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%x\n", statstg
.grfMode
);
919 ok(statstg
.grfLocksSupported
== 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg
.grfLocksSupported
);
920 ok(IsEqualCLSID(&statstg
.clsid
, &CLSID_NULL
), "Statstg clsid is not CLSID_NULL\n");
921 ok(statstg
.grfStateBits
== 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg
.grfStateBits
);
922 ok(statstg
.reserved
== 0, "Statstg reserved should have been 0 instead of %d\n", statstg
.reserved
);
923 CoTaskMemFree(statstg
.pwcsName
);
925 r
= IStorage_CreateStorage( stg2
, stgname2
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, 0, &stg3
);
926 ok(r
== STG_E_ACCESSDENIED
, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r
);
928 r
= IStorage_CreateStream( stg2
, stmname2
, STGM_CREATE
|STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
929 ok(r
== STG_E_ACCESSDENIED
, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r
);
931 IStorage_Release(stg2
);
933 r
= IStorage_Release(stg
);
934 ok(r
== 0, "wrong ref count\n");
937 /* Multiple STGM_PRIORITY opens are possible. */
938 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
, NULL
, 0, &stg
);
939 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
942 r
= IStorage_Release(stg
);
943 ok(r
== 0, "wrong ref count\n");
946 r
= StgOpenStorage( NULL
, stgprio
, STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
, NULL
, 0, &stg
);
947 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
950 static const WCHAR stgname
[] = { ' ',' ',' ','2','9',0 };
954 r
= IStorage_Stat( stg
, &statstg
, STATFLAG_NONAME
);
955 ok(r
== S_OK
, "Stat should have succeeded instead of returning 0x%08x\n", r
);
956 ok(statstg
.type
== STGTY_STORAGE
, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg
.type
);
957 ok(U(statstg
.cbSize
).LowPart
== 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg
.cbSize
).LowPart
);
958 ok(U(statstg
.cbSize
).HighPart
== 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg
.cbSize
).HighPart
);
959 ok(statstg
.grfMode
== (STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
),
960 "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg
.grfMode
);
961 ok(statstg
.grfLocksSupported
== 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg
.grfLocksSupported
);
962 ok(IsEqualCLSID(&statstg
.clsid
, &test_stg_cls
), "Statstg clsid is not test_stg_cls\n");
963 ok(statstg
.grfStateBits
== 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg
.grfStateBits
);
964 ok(statstg
.reserved
== 0, "Statstg reserved should have been 0 instead of %d\n", statstg
.reserved
);
966 r
= IStorage_CreateStorage( stg
, stgname
, STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
967 ok(r
== S_OK
, "CreateStorage should have succeeded instead of returning 0x%08x\n", r
);
969 IStorage_Release(stg2
);
971 r
= IStorage_Commit( stg
, 0 );
972 ok(r
== S_OK
, "Commit should have succeeded instead of returning 0x%08x\n", r
);
974 r
= IStorage_Release(stg
);
975 ok(r
== 0, "wrong ref count\n");
977 /* IStorage_Release(stgprio) not necessary because StgOpenStorage released it. */
979 DeleteFileA(filenameA
);
982 static void test_writeclassstg(void)
984 IStorage
*stg
= NULL
;
988 DeleteFileA(filenameA
);
990 /* create the file */
991 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
992 STGM_READWRITE
, 0, &stg
);
993 ok(r
==S_OK
, "StgCreateDocfile failed\n");
995 r
= ReadClassStg( NULL
, NULL
);
996 ok(r
== E_INVALIDARG
, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r
);
998 r
= ReadClassStg( stg
, NULL
);
999 ok(r
== E_INVALIDARG
, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r
);
1001 temp_cls
.Data1
= 0xdeadbeef;
1002 r
= ReadClassStg( stg
, &temp_cls
);
1003 ok(r
== S_OK
, "ReadClassStg failed with 0x%08X\n", r
);
1005 ok(IsEqualCLSID(&temp_cls
, &CLSID_NULL
), "ReadClassStg returned wrong clsid\n");
1007 r
= WriteClassStg( NULL
, NULL
);
1008 ok(r
== E_INVALIDARG
, "WriteClassStg should return E_INVALIDARG instead of 0x%08X\n", r
);
1010 r
= WriteClassStg( stg
, NULL
);
1011 ok(r
== STG_E_INVALIDPOINTER
, "WriteClassStg should return STG_E_INVALIDPOINTER instead of 0x%08X\n", r
);
1013 r
= WriteClassStg( stg
, &test_stg_cls
);
1014 ok( r
== S_OK
, "WriteClassStg failed with 0x%08X\n", r
);
1016 r
= ReadClassStg( stg
, &temp_cls
);
1017 ok( r
== S_OK
, "ReadClassStg failed with 0x%08X\n", r
);
1018 ok(IsEqualCLSID(&temp_cls
, &test_stg_cls
), "ReadClassStg returned wrong clsid\n");
1020 r
= IStorage_Release( stg
);
1021 ok (r
== 0, "storage not released\n");
1023 DeleteFileA(filenameA
);
1026 static void test_streamenum(void)
1028 IStorage
*stg
= NULL
;
1030 IStream
*stm
= NULL
;
1031 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1032 static const WCHAR stmname2
[] = { 'A','B','C','D','E','F','G','H','I',0 };
1033 static const WCHAR stmname3
[] = { 'A','B','C','D','E','F','G','H','I','J',0 };
1035 IEnumSTATSTG
*ee
= NULL
;
1038 DeleteFileA(filenameA
);
1040 /* create the file */
1041 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1042 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1043 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1045 r
= WriteClassStg( stg
, &test_stg_cls
);
1046 ok( r
== S_OK
, "WriteClassStg failed\n");
1048 r
= IStorage_Commit( stg
, STGC_DEFAULT
);
1049 ok( r
== S_OK
, "IStorage_Commit failed\n");
1051 /* now create a stream */
1052 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1053 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1055 r
= IStream_Release(stm
);
1057 /* first enum ... should be 1 stream */
1058 r
= IStorage_EnumElements(stg
, 0, NULL
, 0, &ee
);
1059 ok(r
==S_OK
, "IStorage->EnumElements failed\n");
1062 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1063 ok(r
==S_OK
, "IEnumSTATSTG->Next failed\n");
1064 ok(count
== 1, "count wrong\n");
1067 CoTaskMemFree(stat
.pwcsName
);
1069 r
= IEnumSTATSTG_Release(ee
);
1070 ok(r
==S_OK
, "EnumSTATSTG_Release failed with error 0x%08x\n", r
);
1072 /* second enum... destroy the stream before reading */
1073 r
= IStorage_EnumElements(stg
, 0, NULL
, 0, &ee
);
1074 ok(r
==S_OK
, "IStorage->EnumElements failed\n");
1076 r
= IStorage_DestroyElement(stg
, stmname
);
1077 ok(r
==S_OK
, "IStorage->DestroyElement failed\n");
1080 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1081 ok(r
==S_FALSE
, "IEnumSTATSTG->Next failed\n");
1082 ok(count
== 0, "count wrong\n");
1084 /* reset and try again */
1085 r
= IEnumSTATSTG_Reset(ee
);
1086 ok(r
==S_OK
, "IEnumSTATSTG->Reset failed\n");
1089 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1090 ok(r
==S_FALSE
, "IEnumSTATSTG->Next failed\n");
1091 ok(count
== 0, "count wrong\n");
1093 /* add a stream before reading */
1094 r
= IEnumSTATSTG_Reset(ee
);
1095 ok(r
==S_OK
, "IEnumSTATSTG->Reset failed\n");
1097 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1098 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1100 r
= IStream_Release(stm
);
1101 ok(r
==S_OK
, "Stream_Release failed with error 0x%08x\n", r
);
1104 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1105 ok(r
==S_OK
, "IEnumSTATSTG->Next failed\n");
1106 ok(count
== 1, "count wrong\n");
1110 ok(lstrcmpiW(stat
.pwcsName
, stmname
) == 0, "expected CONTENTS, got %s\n", wine_dbgstr_w(stat
.pwcsName
));
1111 CoTaskMemFree(stat
.pwcsName
);
1114 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1115 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1117 r
= IStream_Release(stm
);
1118 ok(r
==S_OK
, "Stream_Release failed with error 0x%08x\n", r
);
1121 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1122 ok(r
==S_OK
, "IEnumSTATSTG->Next failed\n");
1123 ok(count
== 1, "count wrong\n");
1127 ok(lstrcmpiW(stat
.pwcsName
, stmname2
) == 0, "expected ABCDEFGHI, got %s\n", wine_dbgstr_w(stat
.pwcsName
));
1128 CoTaskMemFree(stat
.pwcsName
);
1131 /* delete previous and next stream after reading */
1132 r
= IStorage_CreateStream(stg
, stmname3
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1133 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1135 r
= IStream_Release(stm
);
1136 ok(r
==S_OK
, "Stream_Release failed with error 0x%08x\n", r
);
1138 r
= IEnumSTATSTG_Reset(ee
);
1139 ok(r
==S_OK
, "IEnumSTATSTG->Reset failed\n");
1142 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1143 ok(r
==S_OK
, "IEnumSTATSTG->Next failed\n");
1144 ok(count
== 1, "count wrong\n");
1148 ok(lstrcmpiW(stat
.pwcsName
, stmname
) == 0, "expected CONTENTS, got %s\n", wine_dbgstr_w(stat
.pwcsName
));
1149 CoTaskMemFree(stat
.pwcsName
);
1152 r
= IStorage_DestroyElement(stg
, stmname
);
1153 ok(r
==S_OK
, "IStorage->DestroyElement failed\n");
1155 r
= IStorage_DestroyElement(stg
, stmname2
);
1156 ok(r
==S_OK
, "IStorage->DestroyElement failed\n");
1159 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1160 ok(r
==S_OK
, "IEnumSTATSTG->Next failed\n");
1161 ok(count
== 1, "count wrong\n");
1165 ok(lstrcmpiW(stat
.pwcsName
, stmname3
) == 0, "expected ABCDEFGHIJ, got %s\n", wine_dbgstr_w(stat
.pwcsName
));
1166 CoTaskMemFree(stat
.pwcsName
);
1169 r
= IStorage_Release( stg
);
1170 todo_wine
ok (r
== 0, "storage not released\n");
1172 /* enumerator is still valid and working after the storage is released */
1173 r
= IEnumSTATSTG_Reset(ee
);
1174 ok(r
==S_OK
, "IEnumSTATSTG->Reset failed\n");
1177 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
1178 ok(r
==S_OK
, "IEnumSTATSTG->Next failed\n");
1179 ok(count
== 1, "count wrong\n");
1183 ok(lstrcmpiW(stat
.pwcsName
, stmname3
) == 0, "expected ABCDEFGHIJ, got %s\n", wine_dbgstr_w(stat
.pwcsName
));
1184 CoTaskMemFree(stat
.pwcsName
);
1187 /* the storage is left open until the enumerator is freed */
1188 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
|
1189 STGM_READWRITE
|STGM_TRANSACTED
, NULL
, 0, &stg
);
1190 ok(r
==STG_E_SHAREVIOLATION
||
1191 r
==STG_E_LOCKVIOLATION
, /* XP-SP2/W2K3-SP1 and below */
1192 "StgCreateDocfile failed, res=%x\n", r
);
1194 r
= IEnumSTATSTG_Release(ee
);
1195 ok (r
== 0, "enum not released\n");
1197 DeleteFileA(filenameA
);
1200 static void test_transact(void)
1202 IStorage
*stg
= NULL
, *stg2
= NULL
, *stg3
= NULL
;
1204 IStream
*stm
= NULL
;
1205 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1206 static const WCHAR stmname2
[] = { 'F','O','O',0 };
1207 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1208 static const WCHAR stgname2
[] = { 'T','E','M','P','S','T','G',0 };
1210 DeleteFileA(filenameA
);
1212 /* create the file */
1213 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1214 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1215 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1217 /* commit a new stream and storage */
1218 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1219 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1221 r
= IStream_Write(stm
, "this is stream 1\n", 16, NULL
);
1222 ok(r
==S_OK
, "IStream->Write failed\n");
1224 IStream_Release(stm
);
1226 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1227 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1231 /* Create two substorages but only commit one */
1232 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1233 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1236 IStorage_Release(stg3
);
1238 r
= IStorage_Commit(stg
, 0);
1239 ok(r
==S_OK
, "IStorage->Commit failed\n");
1241 r
= IStorage_CreateStorage(stg2
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1242 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1245 IStorage_Release(stg3
);
1247 IStorage_Release(stg2
);
1250 /* now create a stream and storage, but don't commit them */
1252 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1253 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1255 r
= IStream_Write(stm
, "this is stream 2\n", 16, NULL
);
1256 ok(r
==S_OK
, "IStream->Write failed\n");
1258 /* IStream::Commit does nothing for OLE storage streams */
1259 r
= IStream_Commit(stm
, STGC_ONLYIFCURRENT
| STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE
);
1260 ok(r
==S_OK
, "IStream->Commit failed\n");
1262 r
= IStorage_CreateStorage(stg
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1263 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1266 IStorage_Release(stg2
);
1268 IStream_Release(stm
);
1270 IStorage_Release(stg
);
1274 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_NONE
| STGM_READ
| STGM_TRANSACTED
, NULL
, 0, &stg
);
1275 ok(r
==S_OK
, "StgOpenStorage failed\n");
1280 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_DENY_NONE
|STGM_READ
, 0, &stm
);
1281 ok(r
==STG_E_INVALIDFLAG
, "IStorage->OpenStream failed %08x\n", r
);
1283 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_DELETEONRELEASE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1284 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
1286 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1287 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
1289 r
= IStorage_OpenStorage(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1290 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
1292 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1293 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1295 IStream_Release(stm
);
1297 r
= IStorage_OpenStorage(stg
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1298 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1300 IStorage_Release(stg2
);
1302 r
= IStorage_OpenStorage(stg
, stmname2
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1303 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
1305 r
= IStorage_OpenStream(stg
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1306 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1308 IStream_Release(stm
);
1310 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1311 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1314 r
= IStorage_OpenStorage(stg2
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1315 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1317 IStorage_Release(stg3
);
1319 r
= IStorage_OpenStorage(stg2
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1320 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1322 IStorage_Release(stg3
);
1324 IStorage_Release(stg2
);
1327 IStorage_Release(stg
);
1329 r
= DeleteFileA(filenameA
);
1330 ok( r
== TRUE
, "deleted file\n");
1333 static void test_substorage_share(void)
1335 IStorage
*stg
, *stg2
, *stg3
;
1336 IStream
*stm
, *stm2
;
1338 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1339 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1340 static const WCHAR othername
[] = { 'N','E','W','N','A','M','E',0 };
1342 DeleteFileA(filenameA
);
1344 /* create the file */
1345 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1346 STGM_READWRITE
, 0, &stg
);
1347 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1349 /* create a read/write storage and try to open it again */
1350 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1351 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1355 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1356 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStorage should fail %08x\n", r
);
1359 IStorage_Release(stg3
);
1361 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READ
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1362 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStorage should fail %08x\n", r
);
1365 IStorage_Release(stg3
);
1367 /* cannot rename the storage while it's open */
1368 r
= IStorage_RenameElement(stg
, stgname
, othername
);
1369 ok(r
==STG_E_ACCESSDENIED
, "IStorage->RenameElement should fail %08x\n", r
);
1370 if (SUCCEEDED(r
)) IStorage_RenameElement(stg
, othername
, stgname
);
1372 /* destroying an object while it's open invalidates it */
1373 r
= IStorage_DestroyElement(stg
, stgname
);
1374 ok(r
==S_OK
, "IStorage->DestroyElement failed, hr=%08x\n", r
);
1376 r
= IStorage_CreateStream(stg2
, stmname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
1377 ok(r
==STG_E_REVERTED
, "IStorage->CreateStream failed, hr=%08x\n", r
);
1380 IStream_Release(stm
);
1382 IStorage_Release(stg2
);
1385 /* create a read/write stream and try to open it again */
1386 r
= IStorage_CreateStream(stg
, stmname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
1387 ok(r
==S_OK
, "IStorage->CreateStream failed, hr=%08x\n", r
);
1391 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm2
);
1392 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStream should fail %08x\n", r
);
1395 IStream_Release(stm2
);
1397 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_READ
| STGM_SHARE_EXCLUSIVE
, 0, &stm2
);
1398 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStream should fail %08x\n", r
);
1401 IStream_Release(stm2
);
1403 /* cannot rename the stream while it's open */
1404 r
= IStorage_RenameElement(stg
, stmname
, othername
);
1405 ok(r
==STG_E_ACCESSDENIED
, "IStorage->RenameElement should fail %08x\n", r
);
1406 if (SUCCEEDED(r
)) IStorage_RenameElement(stg
, othername
, stmname
);
1408 /* destroying an object while it's open invalidates it */
1409 r
= IStorage_DestroyElement(stg
, stmname
);
1410 ok(r
==S_OK
, "IStorage->DestroyElement failed, hr=%08x\n", r
);
1412 r
= IStream_Write(stm
, "this shouldn't work\n", 20, NULL
);
1413 ok(r
==STG_E_REVERTED
, "IStream_Write should fail %08x\n", r
);
1415 IStream_Release(stm
);
1418 IStorage_Release(stg
);
1420 r
= DeleteFileA(filenameA
);
1421 ok( r
== TRUE
, "deleted file\n");
1424 static void test_revert(void)
1426 IStorage
*stg
= NULL
, *stg2
= NULL
, *stg3
= NULL
;
1428 IStream
*stm
= NULL
, *stm2
= NULL
;
1429 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1430 static const WCHAR stmname2
[] = { 'F','O','O',0 };
1431 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1432 static const WCHAR stgname2
[] = { 'T','E','M','P','S','T','G',0 };
1435 DeleteFileA(filenameA
);
1437 /* create the file */
1438 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1439 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1440 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1442 /* commit a new stream and storage */
1443 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1444 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1446 r
= IStream_Write(stm
, "this is stream 1\n", 16, NULL
);
1447 ok(r
==S_OK
, "IStream->Write failed\n");
1449 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1450 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1454 /* Create two substorages but only commit one */
1455 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1456 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1459 IStorage_Release(stg3
);
1461 r
= IStorage_Commit(stg
, 0);
1462 ok(r
==S_OK
, "IStorage->Commit failed\n");
1464 r
= IStorage_CreateStorage(stg2
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1465 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1468 IStorage_Release(stg3
);
1471 /* now create a stream and storage, then revert */
1472 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm2
);
1473 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1475 r
= IStream_Write(stm2
, "this is stream 2\n", 16, NULL
);
1476 ok(r
==S_OK
, "IStream->Write failed\n");
1478 r
= IStorage_CreateStorage(stg
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1479 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1481 r
= IStorage_Revert(stg
);
1482 ok(r
==S_OK
, "Storage_Revert failed with error 0x%08x\n", r
);
1484 /* all open objects become invalid */
1485 r
= IStream_Write(stm
, "this shouldn't work\n", 20, NULL
);
1486 ok(r
==STG_E_REVERTED
, "IStream_Write should fail %08x\n", r
);
1488 r
= IStream_Write(stm2
, "this shouldn't work\n", 20, NULL
);
1489 ok(r
==STG_E_REVERTED
, "IStream_Write should fail %08x\n", r
);
1491 r
= IStorage_Stat(stg2
, &statstg
, STATFLAG_NONAME
);
1492 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1494 r
= IStorage_Stat(stg3
, &statstg
, STATFLAG_NONAME
);
1495 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1497 IStream_Release(stm
);
1498 IStream_Release(stm2
);
1499 IStorage_Release(stg2
);
1500 IStorage_Release(stg3
);
1502 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_DENY_NONE
|STGM_READ
, 0, &stm
);
1503 ok(r
==STG_E_INVALIDFLAG
, "IStorage->OpenStream failed %08x\n", r
);
1505 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_DELETEONRELEASE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1506 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
1508 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1509 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
1511 r
= IStorage_OpenStorage(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1512 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
1514 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1515 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1517 IStream_Release(stm
);
1519 r
= IStorage_OpenStorage(stg
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1520 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1522 IStorage_Release(stg2
);
1524 r
= IStorage_OpenStorage(stg
, stmname2
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1525 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
1527 r
= IStorage_OpenStream(stg
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1528 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1530 IStream_Release(stm
);
1532 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1533 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1536 r
= IStorage_OpenStorage(stg2
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1537 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1539 IStorage_Release(stg3
);
1541 r
= IStorage_OpenStorage(stg2
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1542 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1544 IStorage_Release(stg3
);
1546 IStorage_Release(stg2
);
1549 IStorage_Release(stg
);
1551 r
= DeleteFileA(filenameA
);
1552 ok( r
== TRUE
, "deleted file\n");
1554 /* Revert only invalidates objects in transacted mode */
1555 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1556 STGM_READWRITE
, 0, &stg
);
1557 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1559 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1560 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1562 r
= IStorage_Revert(stg
);
1563 ok(r
==S_OK
, "IStorage->Revert failed %08x\n", r
);
1565 r
= IStream_Write(stm
, "this works\n", 11, NULL
);
1566 ok(r
==S_OK
, "IStream_Write should succeed %08x\n", r
);
1568 IStream_Release(stm
);
1569 IStorage_Release(stg
);
1571 r
= DeleteFileA(filenameA
);
1572 ok( r
== TRUE
, "deleted file\n");
1575 static void test_parent_free(void)
1577 IStorage
*stg
= NULL
, *stg2
= NULL
, *stg3
= NULL
;
1579 IStream
*stm
= NULL
;
1580 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1581 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1585 DeleteFileA(filenameA
);
1587 /* create the file */
1588 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1589 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1590 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1592 /* create a new storage */
1593 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1594 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1598 /* now create a stream inside the new storage */
1599 r
= IStorage_CreateStream(stg2
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1600 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1604 /* create a storage inside the new storage */
1605 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stg3
);
1606 ok(r
==S_OK
, "IStorage->CreateStorage failed\n");
1609 /* free the parent */
1610 ref
= IStorage_Release(stg2
);
1611 ok(ref
== 0, "IStorage still has %u references\n", ref
);
1613 /* child objects are invalid */
1616 r
= IStream_Write(stm
, "this should fail\n", 17, NULL
);
1617 ok(r
==STG_E_REVERTED
, "IStream->Write should fail, hr=%x\n", r
);
1619 IStream_Release(stm
);
1621 r
= IStorage_Stat(stg3
, &statstg
, STATFLAG_NONAME
);
1622 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1624 r
= IStorage_SetStateBits(stg3
, 1, 1);
1625 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1627 IStorage_Release(stg3
);
1631 IStorage_Release(stg
);
1633 r
= DeleteFileA(filenameA
);
1634 ok( r
== TRUE
, "deleted file\n");
1637 static void test_nonroot_transacted(void)
1639 IStorage
*stg
= NULL
, *stg2
= NULL
, *stg3
= NULL
;
1641 IStream
*stm
= NULL
;
1642 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1643 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1644 static const WCHAR stmname2
[] = { 'F','O','O',0 };
1646 DeleteFileA(filenameA
);
1648 /* create a transacted file */
1649 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1650 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1651 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1653 /* create a transacted substorage */
1654 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, 0, &stg2
);
1655 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1659 /* create and commit stmname */
1660 r
= IStorage_CreateStream(stg2
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1661 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1663 IStream_Release(stm
);
1665 IStorage_Commit(stg2
, 0);
1667 /* create and revert stmname2 */
1668 r
= IStorage_CreateStream(stg2
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1669 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1671 IStream_Release(stm
);
1673 IStorage_Revert(stg2
);
1675 /* check that Commit and Revert really worked */
1676 r
= IStorage_OpenStream(stg2
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1677 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1679 IStream_Release(stm
);
1681 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1682 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1684 IStream_Release(stm
);
1686 IStorage_Release(stg2
);
1689 /* create a read-only transacted substorage */
1690 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READ
| STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, NULL
, 0, &stg2
);
1691 ok(r
==S_OK
, "IStorage->OpenStorage failed, hr=%08x\n", r
);
1695 /* The storage can be modified. */
1696 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1697 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1699 IStorage_Release(stg3
);
1701 /* But changes cannot be committed. */
1702 r
= IStorage_Commit(stg2
, 0);
1703 ok(r
==STG_E_ACCESSDENIED
, "IStorage->Commit should fail, hr=%08x\n", r
);
1705 IStorage_Release(stg2
);
1708 IStorage_Release(stg
);
1710 /* create a non-transacted file */
1711 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1712 STGM_READWRITE
, 0, &stg
);
1713 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1715 /* create a transacted substorage */
1716 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, 0, &stg2
);
1717 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1721 /* create and commit stmname */
1722 r
= IStorage_CreateStream(stg2
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1723 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1725 IStream_Release(stm
);
1727 IStorage_Commit(stg2
, 0);
1729 /* create and revert stmname2 */
1730 r
= IStorage_CreateStream(stg2
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1731 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1733 IStream_Release(stm
);
1735 IStorage_Revert(stg2
);
1737 /* check that Commit and Revert really worked */
1738 r
= IStorage_OpenStream(stg2
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1739 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1741 IStream_Release(stm
);
1743 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1744 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1746 IStream_Release(stm
);
1748 IStorage_Release(stg2
);
1751 IStorage_Release(stg
);
1753 r
= DeleteFileA(filenameA
);
1754 ok( r
== TRUE
, "deleted file\n");
1757 static void test_ReadClassStm(void)
1762 static const LARGE_INTEGER llZero
;
1764 hr
= ReadClassStm(NULL
, &clsid
);
1765 ok(hr
== E_INVALIDARG
, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
1767 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1768 ok_ole_success(hr
, "CreateStreamOnHGlobal");
1769 hr
= WriteClassStm(pStream
, &test_stg_cls
);
1770 ok_ole_success(hr
, "WriteClassStm");
1772 hr
= ReadClassStm(pStream
, NULL
);
1773 ok(hr
== E_INVALIDARG
, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
1775 /* test not rewound stream */
1776 hr
= ReadClassStm(pStream
, &clsid
);
1777 ok(hr
== STG_E_READFAULT
, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr
);
1778 ok(IsEqualCLSID(&clsid
, &CLSID_NULL
), "clsid should have been zeroed\n");
1780 hr
= IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
1781 ok_ole_success(hr
, "IStream_Seek");
1782 hr
= ReadClassStm(pStream
, &clsid
);
1783 ok_ole_success(hr
, "ReadClassStm");
1784 ok(IsEqualCLSID(&clsid
, &test_stg_cls
), "clsid should have been set to CLSID_WineTest\n");
1786 IStream_Release(pStream
);
1796 static const struct access_res create
[16] =
1798 { TRUE
, ERROR_SUCCESS
, TRUE
},
1799 { TRUE
, ERROR_SUCCESS
, TRUE
},
1800 { TRUE
, ERROR_SUCCESS
, FALSE
},
1801 { TRUE
, ERROR_SUCCESS
, FALSE
},
1802 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1803 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1804 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1805 { TRUE
, ERROR_SUCCESS
, FALSE
},
1806 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1807 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1808 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1809 { TRUE
, ERROR_SUCCESS
, TRUE
},
1810 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1811 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1812 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1813 { TRUE
, ERROR_SUCCESS
, TRUE
}
1816 static const struct access_res create_commit
[16] =
1818 { TRUE
, ERROR_SUCCESS
, TRUE
},
1819 { TRUE
, ERROR_SUCCESS
, TRUE
},
1820 { TRUE
, ERROR_SUCCESS
, FALSE
},
1821 { TRUE
, ERROR_SUCCESS
, FALSE
},
1822 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1823 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1824 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1825 { TRUE
, ERROR_SUCCESS
, FALSE
},
1826 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1827 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1828 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1829 { TRUE
, ERROR_SUCCESS
, TRUE
},
1830 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1831 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1832 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1833 { TRUE
, ERROR_SUCCESS
, TRUE
}
1836 static const struct access_res create_close
[16] =
1838 { TRUE
, ERROR_SUCCESS
, FALSE
},
1839 { TRUE
, ERROR_SUCCESS
, FALSE
},
1840 { TRUE
, ERROR_SUCCESS
, FALSE
},
1841 { TRUE
, ERROR_SUCCESS
, FALSE
},
1842 { TRUE
, ERROR_SUCCESS
, FALSE
},
1843 { TRUE
, ERROR_SUCCESS
, FALSE
},
1844 { TRUE
, ERROR_SUCCESS
, FALSE
},
1845 { TRUE
, ERROR_SUCCESS
, FALSE
},
1846 { TRUE
, ERROR_SUCCESS
, FALSE
},
1847 { TRUE
, ERROR_SUCCESS
, FALSE
},
1848 { TRUE
, ERROR_SUCCESS
, FALSE
},
1849 { TRUE
, ERROR_SUCCESS
, FALSE
},
1850 { TRUE
, ERROR_SUCCESS
, FALSE
},
1851 { TRUE
, ERROR_SUCCESS
, FALSE
},
1852 { TRUE
, ERROR_SUCCESS
, FALSE
},
1853 { TRUE
, ERROR_SUCCESS
}
1856 static const DWORD access_modes
[4] = {
1860 GENERIC_READ
| GENERIC_WRITE
1863 static const DWORD share_modes
[4] = {
1867 FILE_SHARE_READ
| FILE_SHARE_WRITE
1870 static void _test_file_access(LPCSTR file
, const struct access_res
*ares
, DWORD line
)
1874 for (i
= 0; i
< sizeof(access_modes
)/sizeof(access_modes
[0]); i
++)
1876 for (j
= 0; j
< sizeof(share_modes
)/sizeof(share_modes
[0]); j
++)
1881 if (ares
[idx
].ignore
)
1884 SetLastError(0xdeadbeef);
1885 hfile
= CreateFileA(file
, access_modes
[i
], share_modes
[j
], NULL
, OPEN_EXISTING
,
1886 FILE_ATTRIBUTE_NORMAL
, 0);
1887 lasterr
= GetLastError();
1889 ok((hfile
!= INVALID_HANDLE_VALUE
) == ares
[idx
].gothandle
,
1890 "(%d, handle, %d): Expected %d, got %d\n",
1891 line
, idx
, ares
[idx
].gothandle
,
1892 (hfile
!= INVALID_HANDLE_VALUE
));
1894 ok(lasterr
== ares
[idx
].lasterr
||
1895 broken(lasterr
== 0xdeadbeef) /* win9x */,
1896 "(%d, lasterr, %d): Expected %d, got %d\n",
1897 line
, idx
, ares
[idx
].lasterr
, lasterr
);
1905 #define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
1907 static void test_access(void)
1909 static const WCHAR fileW
[] = {'w','i','n','e','t','e','s','t',0};
1910 static const char fileA
[] = "winetest";
1914 /* STGM_TRANSACTED */
1915 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1916 STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, &stg
);
1917 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1919 test_file_access(fileA
, create
);
1921 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1922 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1924 test_file_access(fileA
, create_commit
);
1926 IStorage_Release(stg
);
1928 test_file_access(fileA
, create_close
);
1933 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1934 STGM_SHARE_EXCLUSIVE
| STGM_DIRECT
, 0, &stg
);
1935 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1937 test_file_access(fileA
, create
);
1939 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1940 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1942 test_file_access(fileA
, create_commit
);
1944 IStorage_Release(stg
);
1946 test_file_access(fileA
, create_close
);
1950 /* STGM_SHARE_DENY_NONE */
1951 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1952 STGM_SHARE_DENY_NONE
| STGM_TRANSACTED
, 0, &stg
);
1953 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1955 test_file_access(fileA
, create
);
1957 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1958 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1960 test_file_access(fileA
, create_commit
);
1962 IStorage_Release(stg
);
1964 test_file_access(fileA
, create_close
);
1968 /* STGM_SHARE_DENY_READ */
1969 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1970 STGM_SHARE_DENY_READ
| STGM_TRANSACTED
, 0, &stg
);
1971 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1973 test_file_access(fileA
, create
);
1975 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1976 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1978 test_file_access(fileA
, create_commit
);
1980 IStorage_Release(stg
);
1982 test_file_access(fileA
, create_close
);
1986 /* STGM_SHARE_DENY_WRITE */
1987 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1988 STGM_SHARE_DENY_WRITE
| STGM_TRANSACTED
, 0, &stg
);
1989 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1991 test_file_access(fileA
, create
);
1993 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1994 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1996 test_file_access(fileA
, create_commit
);
1998 IStorage_Release(stg
);
2000 test_file_access(fileA
, create_close
);
2004 /* STGM_DIRECT_SWMR | STGM_READ | STGM_SHARE_DENY_NONE - reader mode for direct SWMR mode */
2005 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
| STGM_SHARE_DENY_WRITE
| STGM_TRANSACTED
, 0, &stg
);
2006 ok(hr
== S_OK
, "got %08x\n", hr
);
2007 IStorage_Release(stg
);
2009 hr
= StgOpenStorage(fileW
, NULL
, STGM_DIRECT_SWMR
| STGM_READ
| STGM_SHARE_DENY_NONE
, NULL
, 0, &stg
);
2010 ok(hr
== S_OK
|| broken(hr
== STG_E_INVALIDFLAG
), "got %08x\n", hr
);
2014 test_file_access(fileA
, create
);
2016 IStorage_Release(stg
);
2017 test_file_access(fileA
, create_close
);
2022 static void test_readonly(void)
2024 IStorage
*stg
, *stg2
, *stg3
;
2027 static const WCHAR fileW
[] = {'w','i','n','e','t','e','s','t',0};
2028 static const WCHAR storageW
[] = {'s','t','o','r','a','g','e',0};
2029 static const WCHAR streamW
[] = {'s','t','r','e','a','m',0};
2031 hr
= StgCreateDocfile( fileW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
2032 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2035 hr
= IStorage_CreateStorage( stg
, storageW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stg2
);
2036 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2039 hr
= IStorage_CreateStream( stg2
, streamW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stream
);
2040 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2042 IStream_Release(stream
);
2043 IStorage_Release(stg2
);
2045 IStorage_Release(stg
);
2048 /* re-open read only */
2049 hr
= StgOpenStorage( fileW
, NULL
, STGM_TRANSACTED
| STGM_SHARE_DENY_NONE
| STGM_READ
, NULL
, 0, &stg
);
2050 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2053 hr
= IStorage_OpenStorage( stg
, storageW
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg2
);
2054 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2057 /* CreateStream on read-only storage, name exists */
2058 hr
= IStorage_CreateStream( stg2
, streamW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stream
);
2059 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
2061 IStream_Release(stream
);
2063 /* CreateStream on read-only storage, name does not exist */
2064 hr
= IStorage_CreateStream( stg2
, storageW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stream
);
2065 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
2067 IStream_Release(stream
);
2069 /* CreateStorage on read-only storage, name exists */
2070 hr
= IStorage_CreateStorage( stg2
, streamW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stg3
);
2071 ok(hr
== STG_E_FILEALREADYEXISTS
, "should fail, res=%x\n", hr
);
2073 IStorage_Release(stg3
);
2075 /* CreateStorage on read-only storage, name does not exist */
2076 hr
= IStorage_CreateStorage( stg2
, storageW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stg3
);
2077 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
2079 IStorage_Release(stg3
);
2081 /* DestroyElement on read-only storage, name exists */
2082 hr
= IStorage_DestroyElement( stg2
, streamW
);
2083 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
2085 /* DestroyElement on read-only storage, name does not exist */
2086 hr
= IStorage_DestroyElement( stg2
, storageW
);
2087 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
2089 IStorage_Release(stg2
);
2092 IStorage_Release(stg
);
2095 DeleteFileA("winetest");
2098 static void test_simple(void)
2100 /* Tests for STGM_SIMPLE mode */
2102 IStorage
*stg
, *stg2
;
2105 static const WCHAR stgname
[] = { 'S','t','g',0 };
2106 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
2107 static const WCHAR stmname2
[] = { 'S','m','a','l','l',0 };
2109 ULARGE_INTEGER upos
;
2113 DeleteFileA(filenameA
);
2115 r
= StgCreateDocfile( filename
, STGM_SIMPLE
| STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
2116 ok(r
== S_OK
, "got %08x\n", r
);
2118 r
= IStorage_CreateStorage(stg
, stgname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stg2
);
2119 ok(r
== STG_E_INVALIDFUNCTION
, "got %08x\n", r
);
2120 if (SUCCEEDED(r
)) IStorage_Release(stg2
);
2122 r
= IStorage_CreateStream(stg
, stmname
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
2123 ok(r
== STG_E_INVALIDFLAG
, "got %08x\n", r
);
2124 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
2125 ok(r
== S_OK
, "got %08x\n", r
);
2127 upos
.QuadPart
= 6000;
2128 r
= IStream_SetSize(stm
, upos
);
2129 ok(r
== S_OK
, "got %08x\n", r
);
2131 r
= IStream_Write(stm
, "foo", 3, &count
);
2132 ok(r
== S_OK
, "got %08x\n", r
);
2133 ok(count
== 3, "got %d\n", count
);
2136 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_CUR
, &upos
);
2137 ok(r
== S_OK
, "got %08x\n", r
);
2138 ok(upos
.QuadPart
== 3, "got %d\n", upos
.u
.LowPart
);
2140 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
2142 broken(r
== STG_E_INVALIDFUNCTION
), /* NT4 and below */
2145 ok(stat
.cbSize
.QuadPart
== 3, "got %d\n", stat
.cbSize
.u
.LowPart
);
2148 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &upos
);
2149 ok(r
== S_OK
, "got %08x\n", r
);
2150 ok(upos
.QuadPart
== 1, "got %d\n", upos
.u
.LowPart
);
2152 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
2154 broken(r
== STG_E_INVALIDFUNCTION
), /* NT4 and below */
2157 ok(stat
.cbSize
.QuadPart
== 1, "got %d\n", stat
.cbSize
.u
.LowPart
);
2159 IStream_Release(stm
);
2161 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
2162 ok(r
== S_OK
, "got %08x\n", r
);
2164 upos
.QuadPart
= 100;
2165 r
= IStream_SetSize(stm
, upos
);
2166 ok(r
== S_OK
, "got %08x\n", r
);
2168 r
= IStream_Write(stm
, "foo", 3, &count
);
2169 ok(r
== S_OK
, "got %08x\n", r
);
2170 ok(count
== 3, "got %d\n", count
);
2172 IStream_Release(stm
);
2174 IStorage_Commit(stg
, STGC_DEFAULT
);
2175 IStorage_Release(stg
);
2177 r
= StgOpenStorage( filename
, NULL
, STGM_SIMPLE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, NULL
, 0, &stg
);
2178 if (r
== STG_E_INVALIDFLAG
)
2180 win_skip("Flag combination is not supported on NT4 and below\n");
2181 DeleteFileA(filenameA
);
2184 ok(r
== S_OK
, "got %08x\n", r
);
2186 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, NULL
, 0, &stg2
);
2187 ok(r
== STG_E_INVALIDFUNCTION
, "got %08x\n", r
);
2188 if (SUCCEEDED(r
)) IStorage_Release(stg2
);
2190 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stm
);
2191 ok(r
== S_OK
, "got %08x\n", r
);
2193 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
2194 ok(r
== S_OK
, "got %08x\n", r
);
2195 ok(stat
.cbSize
.QuadPart
== 6000, "got %d\n", stat
.cbSize
.u
.LowPart
);
2197 IStream_Release(stm
);
2199 r
= IStorage_OpenStream(stg
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stm
);
2200 ok(r
== S_OK
, "got %08x\n", r
);
2202 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
2203 ok(r
== S_OK
, "got %08x\n", r
);
2204 ok(stat
.cbSize
.QuadPart
== 4096, "got %d\n", stat
.cbSize
.u
.LowPart
);
2206 IStream_Release(stm
);
2209 IStorage_Release(stg
);
2211 DeleteFileA(filenameA
);
2214 static void test_fmtusertypestg(void)
2219 static const char fileA
[] = {'f','m','t','t','e','s','t',0};
2220 static const WCHAR fileW
[] = {'f','m','t','t','e','s','t',0};
2221 static WCHAR userTypeW
[] = {'S','t','g','U','s','r','T','y','p','e',0};
2222 static const WCHAR strmNameW
[] = {1,'C','o','m','p','O','b','j',0};
2224 hr
= StgCreateDocfile( fileW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
2225 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2229 /* try to write the stream */
2230 hr
= WriteFmtUserTypeStg(stg
, 0, userTypeW
);
2231 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2233 /* check that the stream was created */
2234 hr
= IStorage_EnumElements(stg
, 0, NULL
, 0, &stat
);
2235 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2241 while ((hr
= IEnumSTATSTG_Next(stat
, 1, &statstg
, &got
)) == S_OK
&& got
== 1)
2243 if (strcmp_ww(statstg
.pwcsName
, strmNameW
) == 0)
2246 ok(0, "found unexpected stream or storage\n");
2247 CoTaskMemFree(statstg
.pwcsName
);
2249 ok(found
== TRUE
, "expected storage to contain stream \\0001CompObj\n");
2250 IEnumSTATSTG_Release(stat
);
2253 /* re-write the stream */
2254 hr
= WriteFmtUserTypeStg(stg
, 0, userTypeW
);
2255 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2257 /* check that the stream is still there */
2258 hr
= IStorage_EnumElements(stg
, 0, NULL
, 0, &stat
);
2259 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
2265 while ((hr
= IEnumSTATSTG_Next(stat
, 1, &statstg
, &got
)) == S_OK
&& got
== 1)
2267 if (strcmp_ww(statstg
.pwcsName
, strmNameW
) == 0)
2270 ok(0, "found unexpected stream or storage\n");
2271 CoTaskMemFree(statstg
.pwcsName
);
2273 ok(found
== TRUE
, "expected storage to contain stream \\0001CompObj\n");
2274 IEnumSTATSTG_Release(stat
);
2277 IStorage_Release(stg
);
2278 DeleteFileA( fileA
);
2282 static void test_references(void)
2284 IStorage
*stg
,*stg2
;
2287 static const WCHAR StorName
[] = { 'D','a','t','a','S','p','a','c','e','I','n','f','o',0 };
2289 DeleteFileA(filenameA
);
2291 hr
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
2292 ok(hr
==S_OK
, "StgCreateDocfile failed\n");
2296 IStorage_Release(stg
);
2298 hr
= StgOpenStorage( filename
, NULL
, STGM_TRANSACTED
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, NULL
, 0, &stg
);
2299 ok(hr
==S_OK
, "StgOpenStorage failed (result=%x)\n",hr
);
2303 hr
= IStorage_CreateStorage(stg
,StorName
,STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
,0,0,&stg2
);
2304 ok(hr
== S_OK
, "IStorage_CreateStorage failed (result=%x)\n",hr
);
2308 c1
= IStorage_AddRef(stg
);
2309 ok(c1
== 2, "creating internal storage added references to ancestor\n");
2310 c1
= IStorage_AddRef(stg
);
2311 IStorage_Release(stg2
);
2312 c2
= IStorage_AddRef(stg
) - 1;
2313 ok(c1
== c2
, "releasing internal storage removed references to ancestor\n");
2315 c1
= IStorage_Release(stg
);
2316 while ( c1
) c1
= IStorage_Release(stg
);
2320 DeleteFileA(filenameA
);
2325 * | `StreamA: "StreamA"
2327 * | `StreamB: "StreamB"
2328 * `StreamC: "StreamC"
2330 static HRESULT
create_test_file(IStorage
*dest
)
2332 IStorage
*stgA
= NULL
, *stgB
= NULL
;
2333 IStream
*strmA
= NULL
, *strmB
= NULL
, *strmC
= NULL
;
2334 const ULONG strmA_name_size
= lstrlenW(strmA_name
) * sizeof(WCHAR
);
2335 const ULONG strmB_name_size
= lstrlenW(strmB_name
) * sizeof(WCHAR
);
2336 const ULONG strmC_name_size
= lstrlenW(strmC_name
) * sizeof(WCHAR
);
2340 hr
= IStorage_CreateStorage(dest
, stgA_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stgA
);
2341 ok(hr
== S_OK
, "IStorage_CreateStorage failed: 0x%08x\n", hr
);
2345 hr
= IStorage_CreateStream(stgA
, strmA_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &strmA
);
2346 ok(hr
== S_OK
, "IStorage_CreateStream failed: 0x%08x\n", hr
);
2350 hr
= IStream_Write(strmA
, strmA_name
, strmA_name_size
, &bytes
);
2351 ok(hr
== S_OK
&& bytes
== strmA_name_size
, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr
, bytes
, strmA_name_size
);
2353 hr
= IStorage_CreateStorage(dest
, stgB_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stgB
);
2354 ok(hr
== S_OK
, "IStorage_CreateStorage failed: 0x%08x\n", hr
);
2358 hr
= IStorage_CreateStream(stgB
, strmB_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &strmB
);
2359 ok(hr
== S_OK
, "IStorage_CreateStream failed: 0x%08x\n", hr
);
2363 hr
= IStream_Write(strmB
, strmB_name
, strmB_name_size
, &bytes
);
2364 ok(hr
== S_OK
&& bytes
== strmB_name_size
, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr
, bytes
, strmB_name_size
);
2366 hr
= IStorage_CreateStream(dest
, strmC_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &strmC
);
2367 ok(hr
== S_OK
, "IStorage_CreateStream failed: 0x%08x\n", hr
);
2371 hr
= IStream_Write(strmC
, strmC_name
, strmC_name_size
, &bytes
);
2372 ok(hr
== S_OK
&& bytes
== strmC_name_size
, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr
, bytes
, strmC_name_size
);
2376 IStream_Release(strmC
);
2378 IStream_Release(strmB
);
2380 IStorage_Release(stgB
);
2382 IStream_Release(strmA
);
2384 IStorage_Release(stgA
);
2389 static void test_copyto(void)
2391 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2396 /* create & populate file1 */
2397 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2398 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2402 hr
= create_test_file(file1
);
2407 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2408 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2412 /* copy file1 into file2 */
2413 hr
= IStorage_CopyTo(file1
, 0, NULL
, NULL
, NULL
);
2414 ok(hr
== STG_E_INVALIDPOINTER
, "CopyTo should give STG_E_INVALIDPONITER, gave: 0x%08x\n", hr
);
2416 hr
= IStorage_CopyTo(file1
, 0, NULL
, NULL
, file2
);
2417 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2421 /* verify that all of file1 was copied */
2422 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2423 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2424 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2427 hr
= IStorage_OpenStream(stg_tmp
, strmA_name
, NULL
,
2428 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2429 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2432 memset(buf
, 0, sizeof(buf
));
2433 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2434 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2436 ok(strcmp_ww(buf
, strmA_name
) == 0,
2437 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmA_name
), wine_dbgstr_w(buf
));
2439 IStream_Release(strm_tmp
);
2442 IStorage_Release(stg_tmp
);
2445 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2446 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2447 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2450 hr
= IStorage_OpenStream(stg_tmp
, strmB_name
, NULL
,
2451 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2452 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2455 memset(buf
, 0, sizeof(buf
));
2456 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2457 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2459 ok(strcmp_ww(buf
, strmB_name
) == 0,
2460 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name
), wine_dbgstr_w(buf
));
2462 IStream_Release(strm_tmp
);
2465 IStorage_Release(stg_tmp
);
2468 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2469 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2470 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2473 memset(buf
, 0, sizeof(buf
));
2474 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2475 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2477 ok(strcmp_ww(buf
, strmC_name
) == 0,
2478 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name
), wine_dbgstr_w(buf
));
2480 IStream_Release(strm_tmp
);
2485 IStorage_Release(file1
);
2487 IStorage_Release(file2
);
2489 DeleteFileA(file1_nameA
);
2490 DeleteFileA(file2_nameA
);
2493 static void test_copyto_snbexclusions(void)
2495 static const WCHAR
*snb_exclude
[] = {stgA_name
, strmB_name
, strmC_name
, 0};
2497 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2502 /* create & populate file1 */
2503 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2504 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2508 hr
= create_test_file(file1
);
2513 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2514 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2518 /* copy file1 to file2 with name exclusions */
2519 hr
= IStorage_CopyTo(file1
, 0, NULL
, (SNB
)snb_exclude
, file2
);
2520 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2524 /* verify that file1 copied over, respecting exclusions */
2525 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2526 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2527 ok(hr
== STG_E_FILENOTFOUND
, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2529 IStorage_Release(stg_tmp
);
2531 hr
= IStorage_OpenStream(file2
, strmA_name
, NULL
,
2532 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2533 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2535 IStream_Release(strm_tmp
);
2537 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2538 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2539 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2542 hr
= IStorage_OpenStream(stg_tmp
, strmB_name
, NULL
,
2543 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2544 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2547 memset(buf
, 0, sizeof(buf
));
2548 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2549 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2551 ok(strcmp_ww(buf
, strmB_name
) == 0,
2552 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name
), wine_dbgstr_w(buf
));
2554 IStream_Release(strm_tmp
);
2557 IStorage_Release(stg_tmp
);
2560 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2561 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2562 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2564 IStream_Release(strm_tmp
);
2568 IStorage_Release(file1
);
2570 IStorage_Release(file2
);
2572 DeleteFileA(file1_nameA
);
2573 DeleteFileA(file2_nameA
);
2576 static void test_copyto_iidexclusions_storage(void)
2578 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2583 /* create & populate file1 */
2584 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2585 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2589 hr
= create_test_file(file1
);
2594 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2595 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2599 /* copy file1 to file2 with iid exclusions */
2600 hr
= IStorage_CopyTo(file1
, 1, &IID_IStorage
, NULL
, file2
);
2601 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2605 /* verify that file1 copied over, respecting exclusions */
2606 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2607 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2608 ok(hr
== STG_E_FILENOTFOUND
, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2610 IStorage_Release(stg_tmp
);
2612 hr
= IStorage_OpenStream(file2
, strmA_name
, NULL
,
2613 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2614 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2616 IStream_Release(strm_tmp
);
2618 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2619 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2620 ok(hr
== STG_E_FILENOTFOUND
, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2622 IStorage_Release(stg_tmp
);
2624 hr
= IStorage_OpenStream(file2
, strmB_name
, NULL
,
2625 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2626 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2628 IStream_Release(strm_tmp
);
2630 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2631 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2632 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2635 memset(buf
, 0, sizeof(buf
));
2636 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2637 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2639 ok(strcmp_ww(buf
, strmC_name
) == 0,
2640 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name
), wine_dbgstr_w(buf
));
2642 IStream_Release(strm_tmp
);
2647 IStorage_Release(file1
);
2649 IStorage_Release(file2
);
2651 DeleteFileA(file1_nameA
);
2652 DeleteFileA(file2_nameA
);
2655 static void test_copyto_iidexclusions_stream(void)
2657 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2661 /* create & populate file1 */
2662 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2663 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2667 hr
= create_test_file(file1
);
2672 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2673 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2677 /* copy file1 to file2 with iid exclusions */
2678 hr
= IStorage_CopyTo(file1
, 1, &IID_IStream
, NULL
, file2
);
2679 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2683 /* verify that file1 copied over, respecting exclusions */
2684 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2685 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2686 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2689 hr
= IStorage_OpenStream(stg_tmp
, strmA_name
, NULL
,
2690 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2691 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2693 IStream_Release(strm_tmp
);
2695 IStorage_Release(stg_tmp
);
2698 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2699 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2700 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2703 hr
= IStorage_OpenStream(stg_tmp
, strmB_name
, NULL
,
2704 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2705 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2707 IStream_Release(strm_tmp
);
2709 IStorage_Release(stg_tmp
);
2712 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2713 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2714 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2716 IStream_Release(strm_tmp
);
2720 IStorage_Release(file1
);
2722 IStorage_Release(file2
);
2724 DeleteFileA(file1_nameA
);
2725 DeleteFileA(file2_nameA
);
2728 static void test_rename(void)
2730 IStorage
*stg
, *stg2
;
2733 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
2734 static const WCHAR stgname2
[] = { 'S','T','G',0 };
2735 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
2736 static const WCHAR stmname2
[] = { 'E','N','T','S',0 };
2738 DeleteFileA(filenameA
);
2740 /* create the file */
2741 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
2742 STGM_READWRITE
, 0, &stg
);
2743 ok(r
==S_OK
, "StgCreateDocfile failed\n");
2745 /* create a substorage */
2746 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
2747 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2749 /* create a stream in the substorage */
2750 r
= IStorage_CreateStream(stg2
, stmname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
2751 ok(r
==S_OK
, "IStorage->CreateStream failed, hr=%08x\n", r
);
2752 IStream_Release(stm
);
2754 /* rename the stream */
2755 r
= IStorage_RenameElement(stg2
, stmname
, stmname2
);
2756 ok(r
==S_OK
, "IStorage->RenameElement failed, hr=%08x\n", r
);
2758 /* cannot open stream with old name */
2759 r
= IStorage_OpenStream(stg2
, stmname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
2760 ok(r
==STG_E_FILENOTFOUND
, "IStorage_OpenStream should fail, hr=%08x\n", r
);
2761 if (SUCCEEDED(r
)) IStream_Release(stm
);
2763 /* can open stream with new name */
2764 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
2765 ok(r
==S_OK
, "IStorage_OpenStream failed, hr=%08x\n", r
);
2766 if (SUCCEEDED(r
)) IStream_Release(stm
);
2768 IStorage_Release(stg2
);
2770 /* rename the storage */
2771 IStorage_RenameElement(stg
, stgname
, stgname2
);
2773 /* cannot open storage with old name */
2774 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg2
);
2775 ok(r
==STG_E_FILENOTFOUND
, "IStorage_OpenStream should fail, hr=%08x\n", r
);
2776 if (SUCCEEDED(r
)) IStorage_Release(stg2
);
2778 /* can open storage with new name */
2779 r
= IStorage_OpenStorage(stg
, stgname2
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg2
);
2780 ok(r
==S_OK
, "IStorage_OpenStream should fail, hr=%08x\n", r
);
2783 /* opened storage still has the stream */
2784 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
2785 ok(r
==S_OK
, "IStorage_OpenStream failed, hr=%08x\n", r
);
2786 if (SUCCEEDED(r
)) IStream_Release(stm
);
2788 IStorage_Release(stg2
);
2791 IStorage_Release(stg
);
2793 r
= DeleteFileA(filenameA
);
2794 ok( r
== TRUE
, "deleted file\n");
2797 static void test_toplevel_stat(void)
2799 IStorage
*stg
= NULL
;
2802 char prev_dir
[MAX_PATH
];
2803 char temp
[MAX_PATH
];
2804 char full_path
[MAX_PATH
];
2806 WCHAR rel_path
[MAX_PATH
];
2808 DeleteFileA(filenameA
);
2810 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
2811 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
2812 ok(r
==S_OK
, "StgCreateDocfile failed\n");
2814 r
= IStorage_Stat( stg
, &stat
, STATFLAG_DEFAULT
);
2815 ok(r
==S_OK
, "Storage_Stat failed with error 0x%08x\n", r
);
2816 ok(!strcmp_ww(stat
.pwcsName
, filename
), "expected %s, got %s\n",
2817 wine_dbgstr_w(filename
), wine_dbgstr_w(stat
.pwcsName
));
2818 CoTaskMemFree(stat
.pwcsName
);
2820 IStorage_Release( stg
);
2822 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg
);
2823 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
2825 r
= IStorage_Stat( stg
, &stat
, STATFLAG_DEFAULT
);
2826 ok(r
==S_OK
, "Storage_Stat failed with error 0x%08x\n", r
);
2827 ok(!strcmp_ww(stat
.pwcsName
, filename
), "expected %s, got %s\n",
2828 wine_dbgstr_w(filename
), wine_dbgstr_w(stat
.pwcsName
));
2829 CoTaskMemFree(stat
.pwcsName
);
2831 IStorage_Release( stg
);
2833 DeleteFileA(filenameA
);
2835 /* Stat always returns the full path, even for files opened with a relative path. */
2836 GetCurrentDirectoryA(MAX_PATH
, prev_dir
);
2838 GetTempPathA(MAX_PATH
, temp
);
2840 SetCurrentDirectoryA(temp
);
2842 GetFullPathNameA(filenameA
, MAX_PATH
, full_path
, &rel_pathA
);
2843 MultiByteToWideChar(CP_ACP
, 0, rel_pathA
, -1, rel_path
, MAX_PATH
);
2845 r
= StgCreateDocfile( rel_path
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
2846 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
2847 ok(r
==S_OK
, "StgCreateDocfile failed\n");
2849 r
= IStorage_Stat( stg
, &stat
, STATFLAG_DEFAULT
);
2850 ok(r
==S_OK
, "Storage_Stat failed with error 0x%08x\n", r
);
2851 ok(!strcmp_ww(stat
.pwcsName
, filename
), "expected %s, got %s\n",
2852 wine_dbgstr_w(filename
), wine_dbgstr_w(stat
.pwcsName
));
2853 CoTaskMemFree(stat
.pwcsName
);
2855 IStorage_Release( stg
);
2857 r
= StgOpenStorage( rel_path
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg
);
2858 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
2860 r
= IStorage_Stat( stg
, &stat
, STATFLAG_DEFAULT
);
2861 ok(r
==S_OK
, "Storage_Stat failed with error 0x%08x\n", r
);
2862 ok(!strcmp_ww(stat
.pwcsName
, filename
), "expected %s, got %s\n",
2863 wine_dbgstr_w(filename
), wine_dbgstr_w(stat
.pwcsName
));
2864 CoTaskMemFree(stat
.pwcsName
);
2866 IStorage_Release( stg
);
2868 SetCurrentDirectoryA(prev_dir
);
2870 DeleteFileA(filenameA
);
2873 static void test_substorage_enum(void)
2875 IStorage
*stg
, *stg2
;
2879 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
2881 DeleteFileA(filenameA
);
2883 /* create the file */
2884 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
2885 STGM_READWRITE
, 0, &stg
);
2886 ok(r
==S_OK
, "StgCreateDocfile failed\n");
2888 /* create a substorage */
2889 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
2890 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2892 /* create an enumelements */
2893 r
= IStorage_EnumElements(stg2
, 0, NULL
, 0, &ee
);
2894 ok(r
==S_OK
, "IStorage->EnumElements failed, hr=%08x\n", r
);
2896 /* release the substorage */
2897 ref
= IStorage_Release(stg2
);
2898 todo_wine
ok(ref
==0, "storage not released\n");
2900 /* reopening fails, because the substorage is really still open */
2901 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
2902 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStorage failed, hr=%08x\n", r
);
2904 /* destroying the storage invalidates the enumerator */
2905 r
= IStorage_DestroyElement(stg
, stgname
);
2906 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2908 r
= IEnumSTATSTG_Reset(ee
);
2909 ok(r
==STG_E_REVERTED
, "IEnumSTATSTG->Reset failed, hr=%08x\n", r
);
2911 IEnumSTATSTG_Release(ee
);
2913 IStorage_Release(stg
);
2915 r
= DeleteFileA(filenameA
);
2916 ok( r
== TRUE
, "deleted file\n");
2919 static void test_copyto_locking(void)
2921 IStorage
*stg
, *stg2
, *stg3
, *stg4
;
2924 static const WCHAR stgname
[] = { 'S','T','G','1',0 };
2925 static const WCHAR stgname2
[] = { 'S','T','G','2',0 };
2926 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
2928 DeleteFileA(filenameA
);
2930 /* create the file */
2931 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
2932 STGM_READWRITE
, 0, &stg
);
2933 ok(r
==S_OK
, "StgCreateDocfile failed\n");
2935 /* create a substorage */
2936 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
2937 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2939 /* create another substorage */
2940 r
= IStorage_CreateStorage(stg
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
2941 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2943 /* add a stream, and leave it open */
2944 r
= IStorage_CreateStream(stg2
, stmname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
2945 ok(r
==S_OK
, "IStorage->CreateStream failed, hr=%08x\n", r
);
2947 /* Try to copy the storage while the stream is open */
2948 r
= IStorage_CopyTo(stg2
, 0, NULL
, NULL
, stg3
);
2949 ok(r
==S_OK
, "IStorage->CopyTo failed, hr=%08x\n", r
);
2951 IStream_Release(stm
);
2953 /* create a substorage */
2954 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg4
);
2955 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2957 /* Try to copy the storage while the substorage is open */
2958 r
= IStorage_CopyTo(stg2
, 0, NULL
, NULL
, stg3
);
2959 ok(r
==S_OK
, "IStorage->CopyTo failed, hr=%08x\n", r
);
2961 IStorage_Release(stg4
);
2962 IStorage_Release(stg3
);
2963 IStorage_Release(stg2
);
2964 IStorage_Release(stg
);
2966 r
= DeleteFileA(filenameA
);
2967 ok( r
== TRUE
, "deleted file\n");
2970 static void test_copyto_recursive(void)
2972 IStorage
*stg
, *stg2
, *stg3
, *stg4
;
2974 static const WCHAR stgname
[] = { 'S','T','G','1',0 };
2975 static const WCHAR stgname2
[] = { 'S','T','G','2',0 };
2977 DeleteFileA(filenameA
);
2979 /* create the file */
2980 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
2981 STGM_READWRITE
, 0, &stg
);
2982 ok(r
==S_OK
, "StgCreateDocfile failed\n");
2984 /* create a substorage */
2985 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
2986 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2988 /* copy the parent to the child */
2989 r
= IStorage_CopyTo(stg
, 0, NULL
, NULL
, stg2
);
2990 ok(r
==STG_E_ACCESSDENIED
, "IStorage->CopyTo failed, hr=%08x\n", r
);
2992 /* create a transacted substorage */
2993 r
= IStorage_CreateStorage(stg
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, 0, &stg3
);
2994 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2996 /* copy the parent to the transacted child */
2997 r
= IStorage_CopyTo(stg
, 0, NULL
, NULL
, stg2
);
2998 ok(r
==STG_E_ACCESSDENIED
, "IStorage->CopyTo failed, hr=%08x\n", r
);
3000 /* create a transacted subsubstorage */
3001 r
= IStorage_CreateStorage(stg3
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, 0, &stg4
);
3002 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
3004 /* copy the parent to the transacted child of the transacted child */
3005 r
= IStorage_CopyTo(stg
, 0, NULL
, NULL
, stg4
);
3006 ok(r
==STG_E_ACCESSDENIED
, "IStorage->CopyTo failed, hr=%08x\n", r
);
3008 /* copy the parent but exclude storage objects */
3009 r
= IStorage_CopyTo(stg
, 1, &IID_IStorage
, NULL
, stg4
);
3010 ok(r
==S_OK
, "IStorage->CopyTo failed, hr=%08x\n", r
);
3012 IStorage_Release(stg4
);
3013 IStorage_Release(stg3
);
3014 IStorage_Release(stg2
);
3015 IStorage_Release(stg
);
3017 r
= DeleteFileA(filenameA
);
3018 ok( r
== TRUE
, "deleted file\n");
3021 static void test_hglobal_storage_creation(void)
3023 ILockBytes
*ilb
= NULL
;
3024 IStorage
*stg
= NULL
;
3028 ULARGE_INTEGER offset
;
3030 r
= CreateILockBytesOnHGlobal(NULL
, TRUE
, &ilb
);
3031 ok(r
== S_OK
, "CreateILockBytesOnHGlobal failed, hr=%x\n", r
);
3033 offset
.QuadPart
= 0;
3034 memset(junk
, 0xaa, 512);
3035 r
= ILockBytes_WriteAt(ilb
, offset
, junk
, 512, NULL
);
3036 ok(r
== S_OK
, "ILockBytes_WriteAt failed, hr=%x\n", r
);
3038 offset
.QuadPart
= 2000;
3039 r
= ILockBytes_WriteAt(ilb
, offset
, junk
, 512, NULL
);
3040 ok(r
== S_OK
, "ILockBytes_WriteAt failed, hr=%x\n", r
);
3042 r
= StgCreateDocfileOnILockBytes(ilb
, STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stg
);
3043 ok(r
== S_OK
, "StgCreateDocfileOnILockBytes failed, hr=%x\n", r
);
3045 IStorage_Release(stg
);
3047 r
= StgOpenStorageOnILockBytes(ilb
, NULL
, STGM_READ
|STGM_SHARE_EXCLUSIVE
,
3049 ok(r
== S_OK
, "StgOpenStorageOnILockBytes failed, hr=%x\n", r
);
3053 r
= IStorage_Stat(stg
, &stat
, STATFLAG_NONAME
);
3054 ok(r
== S_OK
, "StgOpenStorageOnILockBytes failed, hr=%x\n", r
);
3055 ok(IsEqualCLSID(&stat
.clsid
, &GUID_NULL
), "unexpected CLSID value\n");
3057 IStorage_Release(stg
);
3060 r
= ILockBytes_Stat(ilb
, &stat
, STATFLAG_NONAME
);
3061 ok(r
== S_OK
, "ILockBytes_Stat failed, hr=%x\n", r
);
3062 ok(stat
.cbSize
.u
.LowPart
< 2512, "expected truncated size, got %d\n", stat
.cbSize
.u
.LowPart
);
3064 ILockBytes_Release(ilb
);
3067 static void test_convert(void)
3069 static const WCHAR filename
[] = {'s','t','o','r','a','g','e','.','s','t','g',0};
3073 hr
= GetConvertStg(NULL
);
3074 ok(hr
== E_INVALIDARG
, "got 0x%08x\n", hr
);
3076 hr
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
3077 ok(hr
== S_OK
, "StgCreateDocfile failed\n");
3078 hr
= GetConvertStg(stg
);
3079 ok(hr
== STG_E_FILENOTFOUND
, "got 0x%08x\n", hr
);
3080 hr
= SetConvertStg(stg
, TRUE
);
3081 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
3082 hr
= SetConvertStg(stg
, TRUE
);
3083 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
3084 hr
= GetConvertStg(stg
);
3085 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
3086 hr
= SetConvertStg(stg
, FALSE
);
3087 ok(hr
== S_OK
, "got 0x%08x\n", hr
);
3088 hr
= GetConvertStg(stg
);
3089 ok(hr
== S_FALSE
, "got 0x%08x\n", hr
);
3091 IStorage_Release(stg
);
3093 DeleteFileW(filename
);
3096 static void test_direct_swmr(void)
3098 static const WCHAR fileW
[] = {'w','i','n','e','t','e','s','t',0};
3099 IDirectWriterLock
*dwlock
;
3104 /* it's possible to create in writer mode */
3105 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
| STGM_SHARE_DENY_WRITE
| STGM_DIRECT_SWMR
, 0, &stg
);
3107 ok(hr
== S_OK
, "got %08x\n", hr
);
3109 IStorage_Release(stg
);
3113 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
| STGM_SHARE_DENY_WRITE
| STGM_TRANSACTED
, 0, &stg
);
3114 ok(hr
== S_OK
, "got %08x\n", hr
);
3115 IStorage_Release(stg
);
3118 hr
= StgOpenStorage(fileW
, NULL
, STGM_DIRECT_SWMR
| STGM_READ
| STGM_SHARE_DENY_NONE
, NULL
, 0, &stg
);
3119 ok(hr
== S_OK
|| broken(hr
== STG_E_INVALIDFLAG
), "got %08x\n", hr
);
3122 hr
= IStorage_QueryInterface(stg
, &IID_IDirectWriterLock
, (void**)&dwlock
);
3123 ok(hr
== E_NOINTERFACE
, "got %08x\n", hr
);
3124 IStorage_Release(stg
);
3128 hr
= StgOpenStorage(fileW
, NULL
, STGM_DIRECT_SWMR
| STGM_READWRITE
| STGM_SHARE_DENY_WRITE
, NULL
, 0, &stg
);
3129 ok(hr
== S_OK
, "got %08x\n", hr
);
3132 ref
= IStorage_AddRef(stg
);
3133 IStorage_Release(stg
);
3135 hr
= IStorage_QueryInterface(stg
, &IID_IDirectWriterLock
, (void**)&dwlock
);
3136 ok(hr
== S_OK
, "got %08x\n", hr
);
3138 ref2
= IStorage_AddRef(stg
);
3139 IStorage_Release(stg
);
3140 ok(ref2
== ref
+ 1, "got %u\n", ref2
);
3142 IDirectWriterLock_Release(dwlock
);
3143 IStorage_Release(stg
);
3155 const int *locked_bytes
;
3156 const int *fail_ranges
;
3160 static const int priority_locked_bytes
[] = { 0x58, 0x81, 0x93, -1 };
3161 static const int rwex_locked_bytes
[] = { 0x93, 0xa7, 0xbb, 0xcf, -1 };
3162 static const int rw_locked_bytes
[] = { 0x93, 0xa7, -1 };
3163 static const int nosn_locked_bytes
[] = { 0x6c, 0x93, 0xa7, 0xcf, -1 };
3164 static const int rwdw_locked_bytes
[] = { 0x93, 0xa7, 0xcf, -1 };
3165 static const int wodw_locked_bytes
[] = { 0xa7, 0xcf, -1 };
3166 static const int tr_locked_bytes
[] = { 0x93, -1 };
3167 static const int no_locked_bytes
[] = { -1 };
3168 static const int roex_locked_bytes
[] = { 0x93, 0xbb, 0xcf, -1 };
3170 static const int rwex_fail_ranges
[] = { 0x93,0xe3, -1 };
3171 static const int rw_fail_ranges
[] = { 0xbb,0xe3, -1 };
3172 static const int rwdw_fail_ranges
[] = { 0xa7,0xe3, -1 };
3173 static const int dw_fail_ranges
[] = { 0xa7,0xcf, -1 };
3174 static const int tr_fail_ranges
[] = { 0xbb,0xcf, -1 };
3175 static const int pr_fail_ranges
[] = { 0x80,0x81, 0xbb,0xcf, -1 };
3176 static const int roex_fail_ranges
[] = { 0x0,-1 };
3178 static const struct lock_test lock_tests
[] = {
3179 { STGM_PRIORITY
, FALSE
, GENERIC_READ
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, priority_locked_bytes
, pr_fail_ranges
, FALSE
},
3180 { STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, TRUE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, rwex_locked_bytes
, 0, FALSE
},
3181 { STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
|STGM_TRANSACTED
, TRUE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, rwex_locked_bytes
, 0, FALSE
},
3182 { STGM_CREATE
|STGM_READWRITE
|STGM_TRANSACTED
, TRUE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, rw_locked_bytes
, 0, FALSE
},
3183 { STGM_CREATE
|STGM_READWRITE
|STGM_SHARE_DENY_WRITE
|STGM_TRANSACTED
, TRUE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, rwdw_locked_bytes
, 0, FALSE
},
3184 { STGM_CREATE
|STGM_WRITE
|STGM_SHARE_DENY_WRITE
|STGM_TRANSACTED
, TRUE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, wodw_locked_bytes
, 0, FALSE
},
3185 { STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, FALSE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, rwex_locked_bytes
, rwex_fail_ranges
, FALSE
},
3186 { STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
|STGM_TRANSACTED
, FALSE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, rwex_locked_bytes
, rwex_fail_ranges
, FALSE
},
3187 { STGM_READWRITE
|STGM_TRANSACTED
, FALSE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, rw_locked_bytes
, rw_fail_ranges
, FALSE
},
3188 { STGM_READWRITE
|STGM_TRANSACTED
|STGM_NOSNAPSHOT
, FALSE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, nosn_locked_bytes
, rwdw_fail_ranges
, FALSE
},
3189 { STGM_READWRITE
|STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
, FALSE
, GENERIC_READ
|GENERIC_WRITE
, FILE_SHARE_READ
, rwdw_locked_bytes
, rwdw_fail_ranges
, FALSE
},
3190 { STGM_READ
|STGM_SHARE_DENY_WRITE
, FALSE
, GENERIC_READ
, FILE_SHARE_READ
, no_locked_bytes
, dw_fail_ranges
, TRUE
},
3191 { STGM_READ
|STGM_TRANSACTED
, FALSE
, GENERIC_READ
, FILE_SHARE_READ
|FILE_SHARE_WRITE
, tr_locked_bytes
, tr_fail_ranges
, FALSE
},
3192 { STGM_READ
|STGM_SHARE_EXCLUSIVE
, FALSE
, GENERIC_READ
, FILE_SHARE_READ
, roex_locked_bytes
, roex_fail_ranges
, TRUE
},
3193 { STGM_READ
|STGM_SHARE_EXCLUSIVE
|STGM_TRANSACTED
, FALSE
, GENERIC_READ
, FILE_SHARE_READ
, roex_locked_bytes
, roex_fail_ranges
, TRUE
},
3196 static BOOL
can_open(LPCWSTR filename
, DWORD access
, DWORD sharing
)
3200 hfile
= CreateFileW(filename
, access
, sharing
, NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3202 if (hfile
== INVALID_HANDLE_VALUE
)
3209 static void check_sharing(LPCWSTR filename
, const struct lock_test
*current
,
3210 DWORD access
, DWORD sharing
, const char *desc
, DWORD
*open_mode
, BOOL
*any_failure
)
3212 if (can_open(filename
, access
, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
))
3214 *open_mode
= access
;
3215 if (!current
->todo
|| (current
->sharing
& sharing
))
3216 ok(current
->sharing
& sharing
||
3217 broken(!(current
->sharing
& sharing
) && access
== GENERIC_WRITE
&& (current
->stg_mode
& 0xf) != STGM_READ
) /* win2k */,
3218 "file with mode %x should not be openable with %s permission\n", current
->stg_mode
, desc
);
3221 todo_wine
ok(current
->sharing
& sharing
||
3222 broken(!(current
->sharing
& sharing
) && access
== GENERIC_WRITE
&& (current
->stg_mode
& 0xf) != STGM_READ
) /* win2k */,
3223 "file with mode %x should not be openable with %s permission\n", current
->stg_mode
, desc
);
3224 *any_failure
= TRUE
;
3229 if (!current
->todo
|| !(current
->sharing
& sharing
))
3230 ok(!(current
->sharing
& sharing
), "file with mode %x should be openable with %s permission\n", current
->stg_mode
, desc
);
3233 todo_wine
ok(!(current
->sharing
& sharing
), "file with mode %x should be openable with %s permission\n", current
->stg_mode
, desc
);
3234 *any_failure
= TRUE
;
3239 static void check_access(LPCWSTR filename
, const struct lock_test
*current
,
3240 DWORD access
, DWORD sharing
, const char *desc
, DWORD open_mode
, BOOL
*any_failure
)
3242 if (can_open(filename
, open_mode
, (FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
) & ~sharing
))
3244 if (!current
->todo
|| !(current
->access
& access
))
3245 ok(!(current
->access
& access
), "file with mode %x should not be openable without %s sharing\n", current
->stg_mode
, desc
);
3248 todo_wine
ok(!(current
->access
& access
), "file with mode %x should not be openable without %s sharing\n", current
->stg_mode
, desc
);
3249 *any_failure
= TRUE
;
3254 if (!current
->todo
|| (current
->access
& access
))
3255 ok(current
->access
& access
, "file with mode %x should be openable without %s sharing\n", current
->stg_mode
, desc
);
3258 todo_wine
ok(current
->access
& access
, "file with mode %x should be openable without %s sharing\n", current
->stg_mode
, desc
);
3259 *any_failure
= TRUE
;
3264 static void test_locking(void)
3266 static const WCHAR filename
[] = {'w','i','n','e','t','e','s','t',0};
3271 for (i
=0; i
<sizeof(lock_tests
)/sizeof(lock_tests
[0]); i
++)
3273 const struct lock_test
*current
= &lock_tests
[i
];
3274 BOOL any_failure
= FALSE
;
3275 DWORD open_mode
= 0;
3277 if (current
->create
)
3279 hr
= StgCreateDocfile(filename
, current
->stg_mode
, 0, &stg
);
3280 ok(SUCCEEDED(hr
), "StgCreateDocfile with mode %x failed with hr %x\n", current
->stg_mode
, hr
);
3281 if (FAILED(hr
)) continue;
3285 hr
= StgCreateDocfile(filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
3286 ok(SUCCEEDED(hr
), "StgCreateDocfile failed with hr %x\n", hr
);
3287 if (FAILED(hr
)) continue;
3288 IStorage_Release(stg
);
3290 hr
= StgOpenStorage(filename
, NULL
, current
->stg_mode
, NULL
, 0, &stg
);
3291 ok(SUCCEEDED(hr
), "StgOpenStorage with mode %x failed with hr %x\n", current
->stg_mode
, hr
);
3294 DeleteFileW(filename
);
3299 check_sharing(filename
, current
, GENERIC_READ
, FILE_SHARE_READ
, "READ", &open_mode
, &any_failure
);
3300 check_sharing(filename
, current
, GENERIC_WRITE
, FILE_SHARE_WRITE
, "WRITE", &open_mode
, &any_failure
);
3301 check_sharing(filename
, current
, DELETE
, FILE_SHARE_DELETE
, "DELETE", &open_mode
, &any_failure
);
3306 BOOL locked
, expect_locked
;
3308 const int* next_lock
= current
->locked_bytes
;
3310 check_access(filename
, current
, GENERIC_READ
, FILE_SHARE_READ
, "READ", open_mode
, &any_failure
);
3311 check_access(filename
, current
, GENERIC_WRITE
, FILE_SHARE_WRITE
, "WRITE", open_mode
, &any_failure
);
3312 check_access(filename
, current
, DELETE
, FILE_SHARE_DELETE
, "DELETE", open_mode
, &any_failure
);
3314 hfile
= CreateFileW(filename
, open_mode
, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
, NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3315 ok(hfile
!= INVALID_HANDLE_VALUE
, "couldn't open file with mode %x\n", current
->stg_mode
);
3317 ol
.u
.s
.OffsetHigh
= 0;
3320 for (ol
.u
.s
.Offset
= 0x7fffff00; ol
.u
.s
.Offset
!= 0x80000000; ol
.u
.s
.Offset
++)
3322 if (LockFileEx(hfile
, LOCKFILE_EXCLUSIVE_LOCK
|LOCKFILE_FAIL_IMMEDIATELY
, 0, 1, 0, &ol
))
3326 ok(!LockFileEx(hfile
, LOCKFILE_FAIL_IMMEDIATELY
, 0, 1, 0, &ol
), "shared locks should not be used\n");
3330 UnlockFileEx(hfile
, 0, 1, 0, &ol
);
3332 if ((ol
.u
.s
.Offset
&0xff) == *next_lock
)
3334 expect_locked
= TRUE
;
3338 expect_locked
= FALSE
;
3340 if (!current
->todo
|| locked
== expect_locked
)
3341 ok(locked
== expect_locked
, "byte %x of file with mode %x is %slocked but should %sbe\n",
3342 ol
.u
.s
.Offset
, current
->stg_mode
, locked
?"":"not ", expect_locked
?"":"not ");
3346 todo_wine
ok(locked
== expect_locked
, "byte %x of file with mode %x is %slocked but should %sbe\n",
3347 ol
.u
.s
.Offset
, current
->stg_mode
, locked
?"":"not ", expect_locked
?"":"not ");
3354 IStorage_Release( stg
);
3356 if (!current
->create
)
3359 BOOL failed
, expect_failed
=FALSE
;
3361 const int* next_range
= current
->fail_ranges
;
3363 hfile
= CreateFileW(filename
, open_mode
, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
, NULL
, OPEN_EXISTING
, FILE_ATTRIBUTE_NORMAL
, NULL
);
3364 ok(hfile
!= INVALID_HANDLE_VALUE
, "couldn't open file with mode %x\n", current
->stg_mode
);
3366 ol
.u
.s
.OffsetHigh
= 0;
3369 for (ol
.u
.s
.Offset
= 0x7fffff00; ol
.u
.s
.Offset
!= 0x80000000; ol
.u
.s
.Offset
++)
3371 if (ol
.u
.s
.Offset
== 0x7fffff92 ||
3372 (ol
.u
.s
.Offset
== 0x7fffff80 && current
->stg_mode
== (STGM_TRANSACTED
|STGM_READWRITE
)) ||
3373 (ol
.u
.s
.Offset
== 0x7fffff80 && current
->stg_mode
== (STGM_TRANSACTED
|STGM_READ
)))
3374 continue; /* This makes opens hang */
3376 LockFileEx(hfile
, LOCKFILE_EXCLUSIVE_LOCK
, 0, 1, 0, &ol
);
3378 hr
= StgOpenStorage(filename
, NULL
, current
->stg_mode
, NULL
, 0, &stg
);
3379 ok(hr
== S_OK
|| hr
== STG_E_LOCKVIOLATION
|| hr
== STG_E_SHAREVIOLATION
, "failed with unexpected hr %x\n", hr
);
3380 if (SUCCEEDED(hr
)) IStorage_Release(stg
);
3382 UnlockFileEx(hfile
, 0, 1, 0, &ol
);
3384 failed
= FAILED(hr
);
3386 if (!expect_failed
&& (ol
.u
.s
.Offset
&0xff) == next_range
[0])
3388 expect_failed
= TRUE
;
3390 else if (expect_failed
&& (ol
.u
.s
.Offset
&0xff) == next_range
[1])
3392 expect_failed
= FALSE
;
3396 if (!current
->todo
|| failed
== expect_failed
)
3397 ok(failed
== expect_failed
, "open with byte %x locked, mode %x %s but should %s\n",
3398 ol
.u
.s
.Offset
, current
->stg_mode
, failed
?"failed":"succeeded", expect_failed
?"fail":"succeed");
3402 todo_wine
ok(failed
== expect_failed
, "open with byte %x locked, mode %x %s but should %s\n",
3403 ol
.u
.s
.Offset
, current
->stg_mode
, failed
?"failed":"succeeded", expect_failed
?"fail":"succeed");
3410 DeleteFileW(filename
);
3412 if (current
->todo
&& !any_failure
)
3413 todo_wine
ok(1, "tests succeeded for mode %x\n", current
->stg_mode
);
3417 static void test_transacted_shared(void)
3419 IStorage
*stg
= NULL
;
3420 IStorage
*stgrw
= NULL
;
3422 IStream
*stm
= NULL
;
3423 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
3425 ULARGE_INTEGER upos
;
3429 DeleteFileA(filenameA
);
3431 /* create a new transacted storage with a stream */
3432 r
= StgCreateDocfile(filename
, STGM_CREATE
|
3433 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
3434 ok(r
==S_OK
, "StgCreateDocfile failed %x\n", r
);
3436 r
= WriteClassStg(stg
, &test_stg_cls
);
3437 ok(r
== S_OK
, "WriteClassStg failed %x\n", r
);
3439 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
3440 ok(r
==S_OK
, "IStorage->CreateStream failed %x\n", r
);
3443 r
= IStream_Seek(stm
, pos
, 0, &upos
);
3444 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3446 r
= IStream_Write(stm
, "aaa", 3, NULL
);
3447 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3449 r
= IStorage_Commit(stg
, STGC_ONLYIFCURRENT
);
3450 ok(r
==S_OK
, "IStorage->Commit failed %x\n", r
);
3452 /* open a second transacted read/write storage */
3453 r
= StgOpenStorage(filename
, NULL
, STGM_READWRITE
| STGM_TRANSACTED
| STGM_SHARE_DENY_NONE
, NULL
, 0, &stgrw
);
3454 ok(r
==S_OK
, "StgOpenStorage failed %x\n", r
);
3456 /* update stream on the first storage and commit */
3458 r
= IStream_Seek(stm
, pos
, 0, &upos
);
3459 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3461 r
= IStream_Write(stm
, "ccc", 3, NULL
);
3462 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3464 r
= IStorage_Commit(stg
, STGC_ONLYIFCURRENT
);
3465 ok(r
==S_OK
, "IStorage->Commit failed %x\n", r
);
3467 /* update again without committing */
3469 r
= IStream_Seek(stm
, pos
, 0, &upos
);
3470 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3472 r
= IStream_Write(stm
, "ddd", 3, NULL
);
3473 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3475 IStream_Release(stm
);
3477 /* we can still read the old content from the second storage */
3478 r
= IStorage_OpenStream(stgrw
, stmname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
3479 ok(r
==S_OK
, "IStorage->OpenStream failed %x\n", r
);
3482 r
= IStream_Seek(stm
, pos
, 0, &upos
);
3483 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3485 r
= IStream_Read(stm
, buffer
, sizeof(buffer
), &bytesread
);
3486 ok(r
==S_OK
, "IStream->Read failed %x\n", r
);
3487 ok(bytesread
== 3, "read wrong number of bytes %i\n", bytesread
);
3488 ok(memcmp(buffer
, "aaa", 3) == 0, "wrong data\n");
3490 /* and overwrite the data */
3492 r
= IStream_Seek(stm
, pos
, 0, &upos
);
3493 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3495 r
= IStream_Write(stm
, "bbb", 3, NULL
);
3496 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3498 IStream_Release(stm
);
3500 /* commit fails because we're out of date */
3501 r
= IStorage_Commit(stgrw
, STGC_ONLYIFCURRENT
);
3502 ok(r
==STG_E_NOTCURRENT
, "IStorage->Commit failed %x\n", r
);
3504 /* unless we force it */
3505 r
= IStorage_Commit(stgrw
, STGC_DEFAULT
);
3506 ok(r
==S_OK
, "IStorage->Commit failed %x\n", r
);
3508 /* reverting gets us back to the last commit from the same storage */
3509 r
= IStorage_Revert(stg
);
3510 ok(r
==S_OK
, "IStorage->Revert failed %x\n", r
);
3512 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
3513 ok(r
==S_OK
, "IStorage->CreateStream failed %x\n", r
);
3516 r
= IStream_Seek(stm
, pos
, 0, &upos
);
3517 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3519 r
= IStream_Read(stm
, buffer
, sizeof(buffer
), &bytesread
);
3520 ok(r
==S_OK
, "IStream->Read failed %x\n", r
);
3521 ok(bytesread
== 3, "read wrong number of bytes %i\n", bytesread
);
3522 ok(memcmp(buffer
, "ccc", 3) == 0, "wrong data\n");
3524 /* and committing fails forever */
3525 r
= IStorage_Commit(stg
, STGC_ONLYIFCURRENT
);
3526 ok(r
==STG_E_NOTCURRENT
, "IStorage->Commit failed %x\n", r
);
3528 IStream_Release(stm
);
3530 IStorage_Release(stg
);
3531 IStorage_Release(stgrw
);
3533 DeleteFileA(filenameA
);
3536 static void test_overwrite(void)
3538 IStorage
*stg
= NULL
;
3540 IStream
*stm
= NULL
;
3541 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
3542 static const WCHAR stmname2
[] = { 'C','O','N','T','E','N','T','2',0 };
3544 ULARGE_INTEGER upos
;
3546 DWORD orig_size
, new_size
;
3551 DeleteFileA(filenameA
);
3553 r
= StgCreateDocfile(filename
, STGM_CREATE
| STGM_READWRITE
| STGM_TRANSACTED
, 0, &stg
);
3554 ok(r
==S_OK
, "StgCreateDocfile failed %x\n", r
);
3556 r
= WriteClassStg(stg
, &test_stg_cls
);
3557 ok(r
== S_OK
, "WriteClassStg failed %x\n", r
);
3559 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
3560 ok(r
==S_OK
, "IStorage->CreateStream failed %x\n", r
);
3563 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &upos
);
3564 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3566 memset(buffer
, 'a', sizeof(buffer
));
3569 /* Write enough bytes to pass the minimum storage file size */
3570 r
= IStream_Write(stm
, buffer
, sizeof(buffer
), NULL
);
3571 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3574 r
= IStorage_Commit(stg
, STGC_DEFAULT
);
3575 ok(r
==S_OK
, "IStorage->Commit failed %x\n", r
);
3577 hfile
= CreateFileA(filenameA
, GENERIC_READ
, FILE_SHARE_READ
|FILE_SHARE_WRITE
|FILE_SHARE_DELETE
,
3578 NULL
, OPEN_EXISTING
, 0, NULL
);
3579 ok(hfile
!= NULL
, "couldn't open file %d\n", GetLastError());
3581 orig_size
= GetFileSize(hfile
, NULL
);
3584 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &upos
);
3585 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3587 r
= IStream_Write(stm
, "b", 1, NULL
);
3588 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3590 r
= IStorage_Commit(stg
, STGC_OVERWRITE
);
3591 ok(r
==S_OK
, "IStorage->Commit failed %x\n", r
);
3593 new_size
= GetFileSize(hfile
, NULL
);
3595 todo_wine
ok(new_size
== orig_size
, "file grew from %d bytes to %d\n", orig_size
, new_size
);
3597 IStream_Release(stm
);
3599 IStorage_RenameElement(stg
, stmname
, stmname2
);
3601 r
= IStorage_Commit(stg
, STGC_OVERWRITE
);
3602 ok(r
==S_OK
, "IStorage->Commit failed %x\n", r
);
3604 new_size
= GetFileSize(hfile
, NULL
);
3606 todo_wine
ok(new_size
== orig_size
, "file grew from %d bytes to %d\n", orig_size
, new_size
);
3608 IStorage_Release(stg
);
3610 r
= StgOpenStorage(filename
, NULL
, STGM_READWRITE
| STGM_TRANSACTED
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg
);
3611 ok(r
==S_OK
, "StgOpenStorage failed %x\n", r
);
3613 r
= IStorage_OpenStream(stg
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stm
);
3614 ok(r
==S_OK
, "IStorage->CreateStream failed %x\n", r
);
3616 r
= IStream_Read(stm
, buffer
, sizeof(buffer
), &bytesread
);
3617 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3618 ok(bytesread
== sizeof(buffer
), "only read %d bytes\n", bytesread
);
3619 ok(buffer
[0] == 'b', "unexpected data at byte 0\n");
3621 for (i
=1; i
<sizeof(buffer
); i
++)
3622 if (buffer
[i
] != 'a')
3624 ok(i
== sizeof(buffer
), "unexpected data at byte %i\n", i
);
3627 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &upos
);
3628 ok(r
==S_OK
, "IStream->Seek failed %x\n", r
);
3630 r
= IStream_Write(stm
, "c", 1, NULL
);
3631 ok(r
==S_OK
, "IStream->Write failed %x\n", r
);
3633 r
= IStorage_Commit(stg
, STGC_OVERWRITE
);
3634 ok(r
==S_OK
, "IStorage->Commit failed %x\n", r
);
3636 new_size
= GetFileSize(hfile
, NULL
);
3638 todo_wine
ok(new_size
== orig_size
, "file grew from %d bytes to %d\n", orig_size
, new_size
);
3640 IStream_Release(stm
);
3642 IStorage_Release(stg
);
3646 DeleteFileA(filenameA
);
3649 START_TEST(storage32
)
3651 CHAR temp
[MAX_PATH
];
3653 GetTempPathA(MAX_PATH
, temp
);
3654 if(!GetTempFileNameA(temp
, "stg", 0, filenameA
))
3656 win_skip("Could not create temp file, %u\n", GetLastError());
3659 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filename
, MAX_PATH
);
3660 DeleteFileA(filenameA
);
3662 test_hglobal_storage_stat();
3663 test_create_storage_modes();
3664 test_stgcreatestorageex();
3665 test_storage_stream();
3666 test_open_storage();
3667 test_storage_suminfo();
3668 test_storage_refcount();
3671 test_substorage_share();
3674 test_nonroot_transacted();
3675 test_ReadClassStm();
3677 test_writeclassstg();
3680 test_fmtusertypestg();
3683 test_copyto_snbexclusions();
3684 test_copyto_iidexclusions_storage();
3685 test_copyto_iidexclusions_stream();
3687 test_toplevel_stat();
3688 test_substorage_enum();
3689 test_copyto_locking();
3690 test_copyto_recursive();
3691 test_hglobal_storage_creation();
3695 test_transacted_shared();