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
26 #include "wine/test.h"
32 DEFINE_GUID( test_stg_cls
, 0x88888888, 0x0425, 0x0000, 0,0,0,0,0,0,0,0);
34 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
36 static CHAR filenameA
[MAX_PATH
];
37 static WCHAR filename
[MAX_PATH
];
39 static const WCHAR file1_name
[] = {'c','o','p','y','t','e','s','t','A',0};
40 static const WCHAR file2_name
[] = {'c','o','p','y','t','e','s','t','B',0};
41 static const WCHAR stgA_name
[] = {'S','t','o','r','a','g','e','A',0};
42 static const WCHAR stgB_name
[] = {'S','t','o','r','a','g','e','B',0};
43 static const WCHAR strmA_name
[] = {'S','t','r','e','a','m','A',0};
44 static const WCHAR strmB_name
[] = {'S','t','r','e','a','m','B',0};
45 static const WCHAR strmC_name
[] = {'S','t','r','e','a','m','C',0};
47 static void test_hglobal_storage_stat(void)
49 ILockBytes
*ilb
= NULL
;
55 r
= CreateILockBytesOnHGlobal( NULL
, TRUE
, &ilb
);
56 ok( r
== S_OK
, "CreateILockBytesOnHGlobal failed\n");
58 mode
= STGM_CREATE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
;/*0x1012*/
59 r
= StgCreateDocfileOnILockBytes( ilb
, mode
, 0, &stg
);
60 ok( r
== S_OK
, "StgCreateDocfileOnILockBytes failed\n");
62 r
= WriteClassStg( stg
, &test_stg_cls
);
63 ok( r
== S_OK
, "WriteClassStg failed\n");
65 memset( &stat
, 0, sizeof stat
);
66 r
= IStorage_Stat( stg
, &stat
, 0 );
68 ok( stat
.pwcsName
== NULL
, "storage name not null\n");
69 ok( stat
.type
== 1, "type is wrong\n");
70 ok( stat
.grfMode
== 0x12, "grf mode is incorrect\n");
71 ok( !memcmp(&stat
.clsid
, &test_stg_cls
, sizeof test_stg_cls
), "CLSID is wrong\n");
73 refcount
= IStorage_Release( stg
);
74 ok( refcount
== 0, "IStorage refcount is wrong\n");
75 refcount
= ILockBytes_Release( ilb
);
76 ok( refcount
== 0, "ILockBytes refcount is wrong\n");
79 static void test_create_storage_modes(void)
84 DeleteFileA(filenameA
);
86 /* test with some invalid parameters */
87 r
= StgCreateDocfile( NULL
, 0, 0, &stg
);
88 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
89 r
= StgCreateDocfile( filename
, 0, 0, &stg
);
90 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
91 r
= StgCreateDocfile( filename
, STGM_CREATE
, 0, &stg
);
92 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
93 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_READWRITE
, 0, &stg
);
94 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
95 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
, 0, &stg
);
96 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
97 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, NULL
);
98 ok(r
==STG_E_INVALIDPOINTER
, "StgCreateDocfile succeeded\n");
99 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 1, &stg
);
100 ok(r
==STG_E_INVALIDPARAMETER
, "StgCreateDocfile succeeded\n");
101 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, 0, &stg
);
102 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
103 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, &stg
);
104 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
105 r
= StgCreateDocfile( filename
, STGM_PRIORITY
, 0, &stg
);
106 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
108 /* StgCreateDocfile seems to be very particular about the flags it accepts */
109 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| STGM_WRITE
, 0, &stg
);
110 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
111 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 8, 0, &stg
);
112 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
113 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x80, 0, &stg
);
114 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
115 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x800, 0, &stg
);
116 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
117 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x8000, 0, &stg
);
118 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
119 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x80000, 0, &stg
);
120 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
121 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
| 0x800000, 0, &stg
);
122 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
123 ok(stg
== NULL
, "stg was set\n");
125 /* check what happens if the file already exists (which is how it's meant to be used) */
126 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
127 ok(r
==S_OK
, "StgCreateDocfile failed\n");
128 r
= IStorage_Release(stg
);
129 ok(r
== 0, "storage not released\n");
130 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
131 ok(r
==STG_E_FILEALREADYEXISTS
, "StgCreateDocfile wrong error\n"); /* FAILIFTHERE is default */
132 r
= StgCreateDocfile( filename
, STGM_READ
, 0, &stg
);
133 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n"); /* need at least readmode and sharemode */
134 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
, 0, &stg
);
135 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
136 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_WRITE
, 0, &stg
);
137 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
138 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
, 0, &stg
);
139 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
140 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
| STGM_TRANSACTED
, 0, &stg
);
141 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
142 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
| STGM_READWRITE
, 0, &stg
);
143 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
144 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_NONE
| STGM_WRITE
, 0, &stg
);
145 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
146 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_WRITE
| STGM_WRITE
, 0, &stg
);
147 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile failed\n");
148 r
= StgCreateDocfile( filename
, STGM_SHARE_DENY_WRITE
| STGM_READ
, 0, &stg
);
149 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile wrong error\n");
150 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
| STGM_SHARE_DENY_WRITE
| STGM_READ
, 0, &stg
);
151 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile wrong error\n");
152 ok(DeleteFileA(filenameA
), "failed to delete file\n");
154 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
155 ok(r
==S_OK
, "StgCreateDocfile failed\n");
156 r
= IStorage_Release(stg
);
157 ok(r
== 0, "storage not released\n");
158 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
|STGM_FAILIFTHERE
, 0, &stg
);
159 ok(r
==STG_E_FILEALREADYEXISTS
, "StgCreateDocfile wrong error\n");
160 r
= StgCreateDocfile( filename
, STGM_SHARE_EXCLUSIVE
| STGM_WRITE
, 0, &stg
);
161 ok(r
==STG_E_FILEALREADYEXISTS
, "StgCreateDocfile wrong error\n");
163 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, 0, &stg
);
164 ok(r
==STG_E_INVALIDFLAG
, "StgCreateDocfile succeeded\n");
165 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
166 ok(r
==S_OK
, "StgCreateDocfile failed\n");
167 r
= IStorage_Release(stg
);
168 ok(r
== 0, "storage not released\n");
169 ok(DeleteFileA(filenameA
), "failed to delete file\n");
171 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
172 ok(r
==S_OK
, "StgCreateDocfile failed\n");
173 r
= IStorage_Release(stg
);
174 ok(r
== 0, "storage not released\n");
175 ok(DeleteFileA(filenameA
), "failed to delete file\n");
177 /* test the way excel uses StgCreateDocFile */
178 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
|STGM_CREATE
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
, 0, &stg
);
179 ok(r
==S_OK
, "StgCreateDocfile the excel way failed\n");
182 r
= IStorage_Release(stg
);
183 ok(r
== 0, "storage not released\n");
184 ok(DeleteFileA(filenameA
), "failed to delete file\n");
187 /* and the way windows media uses it ... */
188 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_DENY_NONE
| STGM_READWRITE
| STGM_TRANSACTED
, 0, &stg
);
189 ok(r
==S_OK
, "StgCreateDocfile the windows media way failed\n");
192 r
= IStorage_Release(stg
);
193 ok(r
== 0, "storage not released\n");
194 ok(DeleteFileA(filenameA
), "failed to delete file\n");
197 /* looks like we need STGM_TRANSACTED or STGM_CREATE */
198 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
, 0, &stg
);
199 ok(r
==S_OK
, "StgCreateDocfile the excel way failed\n");
202 r
= IStorage_Release(stg
);
203 ok(r
== 0, "storage not released\n");
204 ok(DeleteFileA(filenameA
), "failed to delete file\n");
207 r
= StgCreateDocfile( filename
, STGM_TRANSACTED
|STGM_CREATE
|STGM_SHARE_DENY_WRITE
|STGM_WRITE
, 0, &stg
);
208 ok(r
==S_OK
, "StgCreateDocfile the excel way failed\n");
211 r
= IStorage_Release(stg
);
212 ok(r
== 0, "storage not released\n");
213 ok(DeleteFileA(filenameA
), "failed to delete file\n");
216 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
217 ok(r
==S_OK
, "StgCreateDocfile the powerpoint way failed\n");
220 r
= IStorage_Release(stg
);
221 ok(r
== 0, "storage not released\n");
222 ok(DeleteFileA(filenameA
), "failed to delete file\n");
225 /* test the way msi uses StgCreateDocfile */
226 r
= StgCreateDocfile( filename
, STGM_DIRECT
| STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stg
);
227 ok(r
==S_OK
, "StgCreateDocFile failed\n");
228 r
= IStorage_Release(stg
);
229 ok(r
== 0, "storage not released\n");
230 ok(DeleteFileA(filenameA
), "failed to delete file\n");
233 static void test_storage_stream(void)
235 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
236 static const WCHAR longname
[] = {
237 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
238 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
240 IStorage
*stg
= NULL
;
243 IStream
*stm2
= NULL
;
247 unsigned char buffer
[0x100];
249 DeleteFileA(filenameA
);
251 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
252 ok(r
==S_OK
, "StgCreateDocfile failed\n");
254 /* try create some invalid streams */
255 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 1, 0, &stm
);
256 ok(r
==STG_E_INVALIDPARAMETER
, "IStorage->CreateStream wrong error\n");
257 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 1, &stm
);
258 ok(r
==STG_E_INVALIDPARAMETER
, "IStorage->CreateStream wrong error\n");
259 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, NULL
);
260 ok(r
==STG_E_INVALIDPOINTER
, "IStorage->CreateStream wrong error\n");
261 r
= IStorage_CreateStream(stg
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
262 ok(r
==STG_E_INVALIDNAME
, "IStorage->CreateStream wrong error\n");
263 r
= IStorage_CreateStream(stg
, longname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
264 ok(r
==STG_E_INVALIDNAME
|| broken(r
==S_OK
) /* nt4 */,
265 "IStorage->CreateStream wrong error, got %d GetLastError()=%d\n", r
, GetLastError());
266 r
= IStorage_CreateStream(stg
, stmname
, STGM_READWRITE
, 0, 0, &stm
);
267 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
268 r
= IStorage_CreateStream(stg
, stmname
, STGM_READ
, 0, 0, &stm
);
269 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
270 r
= IStorage_CreateStream(stg
, stmname
, STGM_WRITE
, 0, 0, &stm
);
271 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
272 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_DENY_NONE
| STGM_READWRITE
, 0, 0, &stm
);
273 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
274 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_DENY_NONE
| STGM_READ
, 0, 0, &stm
);
275 ok(r
==STG_E_INVALIDFLAG
, "IStorage->CreateStream wrong error\n");
277 /* now really create a stream and delete it */
278 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
279 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
280 r
= IStream_Release(stm
);
281 ok(r
== 0, "wrong ref count\n");
282 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
283 ok(r
==STG_E_FILEALREADYEXISTS
, "IStorage->CreateStream failed\n");
284 r
= IStorage_DestroyElement(stg
,stmname
);
285 ok(r
==S_OK
, "IStorage->DestroyElement failed\n");
287 /* create a stream and write to it */
288 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
289 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
291 r
= IStream_Clone(stm
, &stm2
);
292 ok(r
==S_OK
, "failed to clone stream\n");
294 r
= IStream_Write(stm
, NULL
, 0, NULL
);
295 ok(r
==STG_E_INVALIDPOINTER
, "IStream->Write wrong error\n");
296 r
= IStream_Write(stm
, "Hello\n", 0, NULL
);
297 ok(r
==S_OK
, "failed to write stream\n");
298 r
= IStream_Write(stm
, "Hello\n", 0, &count
);
299 ok(r
==S_OK
, "failed to write stream\n");
300 r
= IStream_Write(stm
, "Hello\n", 6, &count
);
301 ok(r
==S_OK
, "failed to write stream\n");
302 r
= IStream_Commit(stm
, STGC_DEFAULT
);
303 ok(r
==S_OK
, "failed to commit stream\n");
304 r
= IStream_Commit(stm
, STGC_DEFAULT
);
305 ok(r
==S_OK
, "failed to commit stream\n");
307 /* seek round a bit, reset the stream size */
309 r
= IStream_Seek(stm
, pos
, 3, &p
);
310 ok(r
==STG_E_INVALIDFUNCTION
, "IStream->Seek returned wrong error\n");
311 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, NULL
);
312 ok(r
==S_OK
, "failed to seek stream\n");
313 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
314 ok(r
==S_OK
, "failed to seek stream\n");
315 r
= IStream_SetSize(stm
,p
);
316 ok(r
==S_OK
, "failed to set pos\n");
318 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
319 ok(r
==S_OK
, "failed to seek stream\n");
320 ok(p
.QuadPart
== 10, "at wrong place\n");
322 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_END
, &p
);
323 ok(r
==S_OK
, "failed to seek stream\n");
324 ok(p
.QuadPart
== 0, "at wrong place\n");
325 r
= IStream_Read(stm
, buffer
, sizeof buffer
, &count
);
326 ok(r
==S_OK
, "failed to set pos\n");
327 ok(count
== 0, "read bytes from empty stream\n");
330 r
= IStream_Release(stm2
);
331 ok(r
== 0, "wrong ref count\n");
333 /* create a stream and write to it */
334 r
= IStorage_CreateStream(stg
, stmname
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm2
);
335 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
337 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &p
);
338 ok(r
==STG_E_REVERTED
, "overwritten stream should return STG_E_REVERTED instead of 0x%08x\n", r
);
340 r
= IStream_Release(stm2
);
341 ok(r
== 0, "wrong ref count\n");
342 r
= IStream_Release(stm
);
343 ok(r
== 0, "wrong ref count\n");
345 r
= IStorage_Release(stg
);
346 ok(r
== 0, "wrong ref count\n");
347 r
= DeleteFileA(filenameA
);
348 ok(r
, "file should exist\n");
351 static BOOL
touch_file(LPCSTR filename
)
355 file
= CreateFileA(filename
, GENERIC_READ
|GENERIC_WRITE
, 0, NULL
,
356 CREATE_ALWAYS
, FILE_ATTRIBUTE_NORMAL
, NULL
);
357 if (file
==INVALID_HANDLE_VALUE
)
363 static BOOL
is_zero_length(LPCSTR filename
)
368 file
= CreateFileA(filename
, GENERIC_READ
, 0, NULL
,
369 OPEN_EXISTING
, 0, NULL
);
370 if (file
==INVALID_HANDLE_VALUE
)
372 len
= GetFileSize(file
, NULL
);
377 static BOOL
is_existing_file(LPCSTR filename
)
381 file
= CreateFileA(filename
, GENERIC_READ
, 0, NULL
,
382 OPEN_EXISTING
, 0, NULL
);
383 if (file
==INVALID_HANDLE_VALUE
)
389 static void test_open_storage(void)
391 static const WCHAR szNonExist
[] = { 'n','o','n','e','x','i','s','t',0 };
392 IStorage
*stg
= NULL
, *stg2
= NULL
;
396 /* try opening a zero length file - it should stay zero length */
397 DeleteFileA(filenameA
);
398 touch_file(filenameA
);
399 stgm
= STGM_NOSCRATCH
| STGM_TRANSACTED
| STGM_SHARE_DENY_WRITE
| STGM_READWRITE
;
400 r
= StgOpenStorage( filename
, NULL
, stgm
, NULL
, 0, &stg
);
401 ok(r
==STG_E_FILEALREADYEXISTS
, "StgOpenStorage didn't fail\n");
403 stgm
= STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
;
404 r
= StgOpenStorage( filename
, NULL
, stgm
, NULL
, 0, &stg
);
405 ok(r
==STG_E_FILEALREADYEXISTS
, "StgOpenStorage didn't fail\n");
406 ok(is_zero_length(filenameA
), "file length changed\n");
408 DeleteFileA(filenameA
);
410 /* try opening a nonexistent file - it should not create it */
411 stgm
= STGM_DIRECT
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
;
412 r
= StgOpenStorage( filename
, NULL
, stgm
, NULL
, 0, &stg
);
413 ok(r
!=S_OK
, "StgOpenStorage failed: 0x%08x\n", r
);
414 if (r
==S_OK
) IStorage_Release(stg
);
415 ok(!is_existing_file(filenameA
), "StgOpenStorage should not create a file\n");
416 DeleteFileA(filenameA
);
418 /* create the file */
419 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
420 ok(r
==S_OK
, "StgCreateDocfile failed\n");
421 IStorage_Release(stg
);
423 r
= StgOpenStorage( filename
, NULL
, 0, NULL
, 0, &stg
);
424 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage wrong error\n");
425 r
= StgOpenStorage( NULL
, NULL
, STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg
);
426 ok(r
==STG_E_INVALIDNAME
, "StgOpenStorage wrong error\n");
427 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, NULL
);
428 ok(r
==STG_E_INVALIDPOINTER
, "StgOpenStorage wrong error\n");
429 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 1, &stg
);
430 ok(r
==STG_E_INVALIDPARAMETER
, "StgOpenStorage wrong error\n");
431 r
= StgOpenStorage( szNonExist
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
432 ok(r
==STG_E_FILENOTFOUND
, "StgOpenStorage failed\n");
433 r
= StgOpenStorage( filename
, NULL
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
434 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
435 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_NONE
| STGM_READ
, NULL
, 0, &stg
);
436 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
437 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_READ
| STGM_READ
, NULL
, 0, &stg
);
438 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
439 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, NULL
, 0, &stg
);
440 ok(r
==STG_E_INVALIDFLAG
, "StgOpenStorage failed\n");
442 /* open it for real */
443 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_NONE
| STGM_READ
| STGM_TRANSACTED
, NULL
, 0, &stg
); /* XLViewer 97/2000 */
444 ok(r
==S_OK
, "StgOpenStorage failed\n");
447 r
= IStorage_Release(stg
);
448 ok(r
== 0, "wrong ref count\n");
451 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_WRITE
| STGM_READ
, NULL
, 0, &stg
);
452 ok(r
==S_OK
, "StgOpenStorage failed\n");
455 r
= IStorage_Release(stg
);
456 ok(r
== 0, "wrong ref count\n");
459 /* test the way word opens its custom dictionary */
460 r
= StgOpenStorage( filename
, NULL
, STGM_NOSCRATCH
| STGM_TRANSACTED
|
461 STGM_SHARE_DENY_WRITE
| STGM_READWRITE
, NULL
, 0, &stg
);
462 ok(r
==S_OK
, "StgOpenStorage failed\n");
465 r
= IStorage_Release(stg
);
466 ok(r
== 0, "wrong ref count\n");
469 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
470 ok(r
==S_OK
, "StgOpenStorage failed\n");
471 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg2
);
472 ok(r
==STG_E_SHAREVIOLATION
, "StgOpenStorage failed\n");
475 r
= IStorage_Release(stg
);
476 ok(r
== 0, "wrong ref count\n");
479 /* now try write to a storage file we opened read-only */
480 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg
);
481 ok(r
==S_OK
, "StgOpenStorage failed\n");
484 static const WCHAR stmname
[] = { 'w','i','n','e','t','e','s','t',0};
486 IStorage
*stg2
= NULL
;
488 r
= IStorage_CreateStream( stg
, stmname
, STGM_WRITE
| STGM_SHARE_EXCLUSIVE
,
490 ok(r
== STG_E_ACCESSDENIED
, "CreateStream should fail\n");
491 r
= IStorage_CreateStorage( stg
, stmname
, STGM_WRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
492 ok(r
== STG_E_ACCESSDENIED
, "CreateStream should fail\n");
494 r
= IStorage_Release(stg
);
495 ok(r
== 0, "wrong ref count\n");
498 /* open like visio 2003 */
500 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_DENY_NONE
, NULL
, 0, &stg
);
501 ok(r
== S_OK
, "should succeed\n");
503 IStorage_Release(stg
);
505 /* test other sharing modes with STGM_PRIORITY */
507 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg
);
508 ok(r
== S_OK
, "should succeed\n");
510 IStorage_Release(stg
);
513 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_DENY_WRITE
, NULL
, 0, &stg
);
514 ok(r
== S_OK
, "should succeed\n");
516 IStorage_Release(stg
);
519 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_SHARE_DENY_READ
, NULL
, 0, &stg
);
520 ok(r
== S_OK
, "should succeed\n");
522 IStorage_Release(stg
);
524 /* open like Project 2003 */
526 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
, NULL
, 0, &stg
);
527 ok(r
== S_OK
, "should succeed\n");
528 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
, NULL
, 0, &stg2
);
529 ok(r
== S_OK
, "should succeed\n");
531 IStorage_Release(stg2
);
533 IStorage_Release(stg
);
536 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
| STGM_READWRITE
, NULL
, 0, &stg
);
537 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
539 r
= StgOpenStorage( filename
, NULL
, STGM_TRANSACTED
| STGM_PRIORITY
, NULL
, 0, &stg
);
540 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
542 r
= StgOpenStorage( filename
, NULL
, STGM_SIMPLE
| STGM_PRIORITY
, NULL
, 0, &stg
);
543 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
545 r
= StgOpenStorage( filename
, NULL
, STGM_DELETEONRELEASE
| STGM_PRIORITY
, NULL
, 0, &stg
);
546 ok(r
== STG_E_INVALIDFUNCTION
, "should fail\n");
548 r
= StgOpenStorage( filename
, NULL
, STGM_NOSCRATCH
| STGM_PRIORITY
, NULL
, 0, &stg
);
549 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
551 r
= StgOpenStorage( filename
, NULL
, STGM_NOSNAPSHOT
| STGM_PRIORITY
, NULL
, 0, &stg
);
552 ok(r
== STG_E_INVALIDFLAG
, "should fail\n");
554 r
= DeleteFileA(filenameA
);
555 ok(r
, "file didn't exist\n");
558 static void test_storage_suminfo(void)
560 IStorage
*stg
= NULL
;
561 IPropertySetStorage
*propset
= NULL
;
562 IPropertyStorage
*ps
= NULL
;
565 DeleteFileA(filenameA
);
567 /* create the file */
568 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
569 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
570 ok(r
==S_OK
, "StgCreateDocfile failed\n");
572 r
= IStorage_QueryInterface( stg
, &IID_IPropertySetStorage
, (LPVOID
) &propset
);
573 ok(r
== S_OK
, "query interface failed\n");
576 r
= IPropertySetStorage_Delete( propset
, &FMTID_SummaryInformation
);
577 ok(r
== STG_E_FILENOTFOUND
, "deleted property set storage\n");
579 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
580 STGM_READ
| STGM_SHARE_EXCLUSIVE
, &ps
);
581 ok(r
== STG_E_FILENOTFOUND
, "opened property set storage\n");
583 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
584 STGM_READ
| STGM_SHARE_EXCLUSIVE
, &ps
);
585 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
587 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
589 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
591 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0, 0, &ps
);
592 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
594 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
595 STGM_WRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
596 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
598 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
599 STGM_CREATE
|STGM_WRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
600 ok(r
== STG_E_INVALIDFLAG
, "created property set storage\n");
602 /* now try really creating a property set */
603 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
604 STGM_CREATE
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
605 ok(r
== S_OK
, "failed to create property set storage\n");
608 IPropertyStorage_Release(ps
);
610 /* now try creating the same thing again */
611 r
= IPropertySetStorage_Create( propset
, &FMTID_SummaryInformation
, NULL
, 0,
612 STGM_CREATE
|STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
613 ok(r
== S_OK
, "failed to create property set storage\n");
615 IPropertyStorage_Release(ps
);
617 /* should be able to open it */
618 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
619 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
620 ok(r
== S_OK
, "open failed\n");
622 IPropertyStorage_Release(ps
);
625 r
= IPropertySetStorage_Delete( propset
, &FMTID_SummaryInformation
);
626 ok(r
== S_OK
, "failed to delete property set storage\n");
628 /* try opening with an invalid FMTID */
629 r
= IPropertySetStorage_Open( propset
, NULL
,
630 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
631 ok(r
== E_INVALIDARG
, "open succeeded\n");
633 IPropertyStorage_Release(ps
);
636 r
= IPropertySetStorage_Open( propset
, &IID_IStorage
,
637 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
638 ok(r
== STG_E_FILENOTFOUND
, "open succeeded\n");
640 IPropertyStorage_Release(ps
);
643 /* try some invalid flags */
644 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
645 STGM_CREATE
| STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
646 ok(r
== STG_E_INVALIDFLAG
, "open succeeded\n");
648 IPropertyStorage_Release(ps
);
650 /* after deleting it, it should be gone */
651 r
= IPropertySetStorage_Open( propset
, &FMTID_SummaryInformation
,
652 STGM_READWRITE
|STGM_SHARE_EXCLUSIVE
, &ps
);
653 ok(r
== STG_E_FILENOTFOUND
, "open failed\n");
655 IPropertyStorage_Release(ps
);
657 r
= IPropertySetStorage_Release( propset
);
658 ok(r
== 1, "ref count wrong\n");
660 r
= IStorage_Release(stg
);
661 ok(r
== 0, "ref count wrong\n");
663 DeleteFileA(filenameA
);
666 static void test_storage_refcount(void)
668 IStorage
*stg
= NULL
;
669 IStorage
*stgprio
= NULL
;
672 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
678 DeleteFileA(filenameA
);
680 /* create the file */
681 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
682 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
683 ok(r
==S_OK
, "StgCreateDocfile failed\n");
685 r
= WriteClassStg( stg
, &test_stg_cls
);
686 ok( r
== S_OK
, "WriteClassStg failed\n");
688 r
= IStorage_Commit( stg
, STGC_DEFAULT
);
689 ok( r
== S_OK
, "IStorage_Commit failed\n");
691 /* now create a stream */
692 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
693 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
695 r
= IStorage_Release( stg
);
696 ok (r
== 0, "storage not released\n");
699 r
= IStream_Seek( stm
, pos
, 0, &upos
);
700 ok (r
== STG_E_REVERTED
, "seek should fail\n");
702 r
= IStream_Stat( stm
, &stat
, STATFLAG_DEFAULT
);
703 ok (r
== STG_E_REVERTED
, "stat should fail\n");
705 r
= IStream_Write( stm
, "Test string", strlen("Test string"), NULL
);
706 ok (r
== STG_E_REVERTED
, "IStream_Write should return STG_E_REVERTED instead of 0x%08x\n", r
);
708 r
= IStream_Read( stm
, buffer
, sizeof(buffer
), NULL
);
709 ok (r
== STG_E_REVERTED
, "IStream_Read should return STG_E_REVERTED instead of 0x%08x\n", r
);
711 r
= IStream_Release(stm
);
712 ok (r
== 0, "stream not released\n");
714 /* tests that STGM_PRIORITY doesn't prevent readwrite access from other
715 * StgOpenStorage calls in transacted mode */
716 r
= StgOpenStorage( filename
, NULL
, STGM_PRIORITY
, NULL
, 0, &stgprio
);
717 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
720 /* non-transacted mode read/write fails */
721 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg
);
722 ok(r
==STG_E_LOCKVIOLATION
, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08x\n", r
);
725 /* non-transacted mode read-only succeeds */
726 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_WRITE
|STGM_READ
, NULL
, 0, &stg
);
727 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
728 IStorage_Release(stg
);
730 r
= StgOpenStorage( filename
, NULL
, STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
, NULL
, 0, &stg
);
731 ok(r
==S_OK
, "StgOpenStorage failed with error 0x%08x\n", r
);
734 static const WCHAR stgname
[] = { ' ',' ',' ','2','9',0 };
735 static const WCHAR stgname2
[] = { 'C','V','_','i','e','w',0 };
736 static const WCHAR stmname2
[] = { 'V','a','r','2','D','a','t','a',0 };
741 r
= IStorage_Stat( stg
, &statstg
, STATFLAG_NONAME
);
742 ok(r
== S_OK
, "Stat should have succeded instead of returning 0x%08x\n", r
);
743 ok(statstg
.type
== STGTY_STORAGE
, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg
.type
);
744 ok(U(statstg
.cbSize
).LowPart
== 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg
.cbSize
).LowPart
);
745 ok(U(statstg
.cbSize
).HighPart
== 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg
.cbSize
).HighPart
);
746 ok(statstg
.grfMode
== (STGM_TRANSACTED
|STGM_SHARE_DENY_WRITE
|STGM_READWRITE
),
747 "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg
.grfMode
);
748 ok(statstg
.grfLocksSupported
== 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg
.grfLocksSupported
);
749 ok(IsEqualCLSID(&statstg
.clsid
, &test_stg_cls
), "Statstg clsid is not test_stg_cls\n");
750 ok(statstg
.grfStateBits
== 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg
.grfStateBits
);
751 ok(statstg
.reserved
== 0, "Statstg reserved should have been 0 instead of %d\n", statstg
.reserved
);
753 r
= IStorage_CreateStorage( stg
, stgname
, STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
754 ok(r
== S_OK
, "CreateStorage should have succeeded instead of returning 0x%08x\n", r
);
756 r
= IStorage_Stat( stg2
, &statstg
, STATFLAG_DEFAULT
);
757 ok(r
== S_OK
, "Stat should have succeded instead of returning 0x%08x\n", r
);
758 ok(!memcmp(statstg
.pwcsName
, stgname
, sizeof(stgname
)),
759 "Statstg pwcsName should have been the name the storage was created with\n");
760 ok(statstg
.type
== STGTY_STORAGE
, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg
.type
);
761 ok(U(statstg
.cbSize
).LowPart
== 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg
.cbSize
).LowPart
);
762 ok(U(statstg
.cbSize
).HighPart
== 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg
.cbSize
).HighPart
);
763 ok(statstg
.grfMode
== STGM_SHARE_EXCLUSIVE
,
764 "Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%x\n", statstg
.grfMode
);
765 ok(statstg
.grfLocksSupported
== 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg
.grfLocksSupported
);
766 ok(IsEqualCLSID(&statstg
.clsid
, &CLSID_NULL
), "Statstg clsid is not CLSID_NULL\n");
767 ok(statstg
.grfStateBits
== 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg
.grfStateBits
);
768 ok(statstg
.reserved
== 0, "Statstg reserved should have been 0 instead of %d\n", statstg
.reserved
);
769 CoTaskMemFree(statstg
.pwcsName
);
771 r
= IStorage_CreateStorage( stg2
, stgname2
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, 0, &stg3
);
772 ok(r
== STG_E_ACCESSDENIED
, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r
);
774 r
= IStorage_CreateStream( stg2
, stmname2
, STGM_CREATE
|STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
775 ok(r
== STG_E_ACCESSDENIED
, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r
);
777 IStorage_Release(stg2
);
779 r
= IStorage_Release(stg
);
780 ok(r
== 0, "wrong ref count\n");
782 IStorage_Release(stgprio
);
784 DeleteFileA(filenameA
);
787 static void test_writeclassstg(void)
789 IStorage
*stg
= NULL
;
793 DeleteFileA(filenameA
);
795 /* create the file */
796 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
797 STGM_READWRITE
, 0, &stg
);
798 ok(r
==S_OK
, "StgCreateDocfile failed\n");
800 r
= ReadClassStg( NULL
, NULL
);
801 ok(r
== E_INVALIDARG
, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r
);
803 r
= ReadClassStg( stg
, NULL
);
804 ok(r
== E_INVALIDARG
, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r
);
806 temp_cls
.Data1
= 0xdeadbeef;
807 r
= ReadClassStg( stg
, &temp_cls
);
808 ok(r
== S_OK
, "ReadClassStg failed with 0x%08X\n", r
);
810 ok(IsEqualCLSID(&temp_cls
, &CLSID_NULL
), "ReadClassStg returned wrong clsid\n");
812 r
= WriteClassStg( NULL
, NULL
);
813 ok(r
== E_INVALIDARG
, "WriteClassStg should return E_INVALIDARG instead of 0x%08X\n", r
);
815 r
= WriteClassStg( stg
, NULL
);
816 ok(r
== STG_E_INVALIDPOINTER
, "WriteClassStg should return STG_E_INVALIDPOINTER instead of 0x%08X\n", r
);
818 r
= WriteClassStg( stg
, &test_stg_cls
);
819 ok( r
== S_OK
, "WriteClassStg failed with 0x%08X\n", r
);
821 r
= ReadClassStg( stg
, &temp_cls
);
822 ok( r
== S_OK
, "ReadClassStg failed with 0x%08X\n", r
);
823 ok(IsEqualCLSID(&temp_cls
, &test_stg_cls
), "ReadClassStg returned wrong clsid\n");
825 r
= IStorage_Release( stg
);
826 ok (r
== 0, "storage not released\n");
828 DeleteFileA(filenameA
);
831 static void test_streamenum(void)
833 IStorage
*stg
= NULL
;
836 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
838 IEnumSTATSTG
*ee
= NULL
;
841 DeleteFileA(filenameA
);
843 /* create the file */
844 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
845 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
846 ok(r
==S_OK
, "StgCreateDocfile failed\n");
848 r
= WriteClassStg( stg
, &test_stg_cls
);
849 ok( r
== S_OK
, "WriteClassStg failed\n");
851 r
= IStorage_Commit( stg
, STGC_DEFAULT
);
852 ok( r
== S_OK
, "IStorage_Commit failed\n");
854 /* now create a stream */
855 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
856 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
858 r
= IStream_Release(stm
);
860 /* first enum ... should be 1 stream */
861 r
= IStorage_EnumElements(stg
, 0, NULL
, 0, &ee
);
862 ok(r
==S_OK
, "IStorage->EnumElements failed\n");
865 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
866 ok(r
==S_OK
, "IEnumSTATSTG->Next failed\n");
867 ok(count
== 1, "count wrong\n");
869 r
= IEnumSTATSTG_Release(ee
);
871 /* second enum... destroy the stream before reading */
872 r
= IStorage_EnumElements(stg
, 0, NULL
, 0, &ee
);
873 ok(r
==S_OK
, "IStorage->EnumElements failed\n");
875 r
= IStorage_DestroyElement(stg
, stmname
);
876 ok(r
==S_OK
, "IStorage->EnumElements failed\n");
880 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
881 ok(r
==S_FALSE
, "IEnumSTATSTG->Next failed\n");
882 ok(count
== 0, "count wrong\n");
885 /* reset and try again */
886 r
= IEnumSTATSTG_Reset(ee
);
887 ok(r
==S_OK
, "IEnumSTATSTG->Reset failed\n");
890 r
= IEnumSTATSTG_Next(ee
, 1, &stat
, &count
);
891 ok(r
==S_FALSE
, "IEnumSTATSTG->Next failed\n");
892 ok(count
== 0, "count wrong\n");
894 r
= IEnumSTATSTG_Release(ee
);
895 ok (r
== 0, "enum not released\n");
897 r
= IStorage_Release( stg
);
898 ok (r
== 0, "storage not released\n");
900 DeleteFileA(filenameA
);
903 static void test_transact(void)
905 IStorage
*stg
= NULL
, *stg2
= NULL
, *stg3
= NULL
;
908 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
909 static const WCHAR stmname2
[] = { 'F','O','O',0 };
910 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
911 static const WCHAR stgname2
[] = { 'T','E','M','P','S','T','G',0 };
913 DeleteFileA(filenameA
);
915 /* create the file */
916 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
917 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
918 ok(r
==S_OK
, "StgCreateDocfile failed\n");
920 /* commit a new stream and storage */
921 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
922 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
924 r
= IStream_Write(stm
, "this is stream 1\n", 16, NULL
);
925 ok(r
==S_OK
, "IStream->Write failed\n");
927 IStream_Release(stm
);
929 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
930 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
934 /* Create two substorages but only commit one */
935 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
936 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
939 IStorage_Release(stg3
);
941 r
= IStorage_Commit(stg
, 0);
942 ok(r
==S_OK
, "IStorage->Commit failed\n");
944 r
= IStorage_CreateStorage(stg2
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
945 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
948 IStorage_Release(stg3
);
950 IStorage_Release(stg2
);
953 /* now create a stream and storage, but don't commit them */
955 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
956 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
958 r
= IStream_Write(stm
, "this is stream 2\n", 16, NULL
);
959 ok(r
==S_OK
, "IStream->Write failed\n");
961 /* IStream::Commit does nothing for OLE storage streams */
962 r
= IStream_Commit(stm
, STGC_ONLYIFCURRENT
| STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE
);
963 ok(r
==S_OK
, "IStream->Commit failed\n");
965 r
= IStorage_CreateStorage(stg
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
966 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
969 IStorage_Release(stg2
);
971 IStream_Release(stm
);
973 IStorage_Release(stg
);
977 r
= StgOpenStorage( filename
, NULL
, STGM_SHARE_DENY_NONE
| STGM_READ
| STGM_TRANSACTED
, NULL
, 0, &stg
);
978 ok(r
==S_OK
, "StgOpenStorage failed\n");
983 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_DENY_NONE
|STGM_READ
, 0, &stm
);
984 ok(r
==STG_E_INVALIDFLAG
, "IStorage->OpenStream failed %08x\n", r
);
986 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_DELETEONRELEASE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
987 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
989 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
990 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
992 r
= IStorage_OpenStorage(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
993 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
996 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
997 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1000 IStream_Release(stm
);
1003 r
= IStorage_OpenStorage(stg
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1004 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1007 IStorage_Release(stg2
);
1009 r
= IStorage_OpenStorage(stg
, stmname2
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1010 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
1012 r
= IStorage_OpenStream(stg
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1013 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1015 IStream_Release(stm
);
1017 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1018 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1021 r
= IStorage_OpenStorage(stg2
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1022 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1024 IStorage_Release(stg3
);
1026 r
= IStorage_OpenStorage(stg2
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1027 todo_wine
ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1029 IStorage_Release(stg3
);
1031 IStorage_Release(stg2
);
1034 IStorage_Release(stg
);
1036 r
= DeleteFileA(filenameA
);
1037 ok( r
== TRUE
, "deleted file\n");
1040 static void test_substorage_share(void)
1042 IStorage
*stg
, *stg2
, *stg3
;
1043 IStream
*stm
, *stm2
;
1045 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1046 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1047 static const WCHAR othername
[] = { 'N','E','W','N','A','M','E',0 };
1049 DeleteFileA(filenameA
);
1051 /* create the file */
1052 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1053 STGM_READWRITE
, 0, &stg
);
1054 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1056 /* create a read/write storage and try to open it again */
1057 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1058 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1062 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1063 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStorage should fail %08x\n", r
);
1066 IStorage_Release(stg3
);
1068 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READ
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1069 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStorage should fail %08x\n", r
);
1072 IStorage_Release(stg3
);
1074 /* cannot rename the storage while it's open */
1075 r
= IStorage_RenameElement(stg
, stgname
, othername
);
1076 ok(r
==STG_E_ACCESSDENIED
, "IStorage->RenameElement should fail %08x\n", r
);
1077 if (SUCCEEDED(r
)) IStorage_RenameElement(stg
, othername
, stgname
);
1079 /* destroying an object while it's open invalidates it */
1080 r
= IStorage_DestroyElement(stg
, stgname
);
1081 ok(r
==S_OK
, "IStorage->DestroyElement failed, hr=%08x\n", r
);
1083 r
= IStorage_CreateStream(stg2
, stmname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
1084 ok(r
==STG_E_REVERTED
, "IStorage->CreateStream failed, hr=%08x\n", r
);
1087 IStorage_Release(stm
);
1089 IStorage_Release(stg2
);
1092 /* create a read/write stream and try to open it again */
1093 r
= IStorage_CreateStream(stg
, stmname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
1094 ok(r
==S_OK
, "IStorage->CreateStream failed, hr=%08x\n", r
);
1098 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm2
);
1099 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStream should fail %08x\n", r
);
1102 IStorage_Release(stm2
);
1104 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_READ
| STGM_SHARE_EXCLUSIVE
, 0, &stm2
);
1105 ok(r
==STG_E_ACCESSDENIED
, "IStorage->OpenStream should fail %08x\n", r
);
1108 IStorage_Release(stm2
);
1110 /* cannot rename the stream while it's open */
1111 r
= IStorage_RenameElement(stg
, stmname
, othername
);
1112 ok(r
==STG_E_ACCESSDENIED
, "IStorage->RenameElement should fail %08x\n", r
);
1113 if (SUCCEEDED(r
)) IStorage_RenameElement(stg
, othername
, stmname
);
1115 /* destroying an object while it's open invalidates it */
1116 r
= IStorage_DestroyElement(stg
, stmname
);
1117 ok(r
==S_OK
, "IStorage->DestroyElement failed, hr=%08x\n", r
);
1119 r
= IStream_Write(stm
, "this shouldn't work\n", 20, NULL
);
1120 ok(r
==STG_E_REVERTED
, "IStream_Write should fail %08x\n", r
);
1122 IStorage_Release(stm
);
1125 IStorage_Release(stg
);
1127 r
= DeleteFileA(filenameA
);
1128 ok( r
== TRUE
, "deleted file\n");
1131 static void test_revert(void)
1133 IStorage
*stg
= NULL
, *stg2
= NULL
, *stg3
= NULL
;
1135 IStream
*stm
= NULL
, *stm2
= NULL
;
1136 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1137 static const WCHAR stmname2
[] = { 'F','O','O',0 };
1138 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1139 static const WCHAR stgname2
[] = { 'T','E','M','P','S','T','G',0 };
1142 DeleteFileA(filenameA
);
1144 /* create the file */
1145 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1146 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1147 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1149 /* commit a new stream and storage */
1150 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1151 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1153 r
= IStream_Write(stm
, "this is stream 1\n", 16, NULL
);
1154 ok(r
==S_OK
, "IStream->Write failed\n");
1156 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1157 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1161 /* Create two substorages but only commit one */
1162 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1163 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1166 IStorage_Release(stg3
);
1168 r
= IStorage_Commit(stg
, 0);
1169 ok(r
==S_OK
, "IStorage->Commit failed\n");
1171 r
= IStorage_CreateStorage(stg2
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1172 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1175 IStorage_Release(stg3
);
1178 /* now create a stream and storage, then revert */
1179 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm2
);
1180 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1182 r
= IStream_Write(stm2
, "this is stream 2\n", 16, NULL
);
1183 ok(r
==S_OK
, "IStream->Write failed\n");
1185 r
= IStorage_CreateStorage(stg
, stgname2
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg3
);
1186 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1188 r
= IStorage_Revert(stg
);
1190 /* all open objects become invalid */
1192 r
= IStream_Write(stm
, "this shouldn't work\n", 20, NULL
);
1193 ok(r
==STG_E_REVERTED
, "IStream_Write should fail %08x\n", r
);
1195 r
= IStream_Write(stm2
, "this shouldn't work\n", 20, NULL
);
1196 ok(r
==STG_E_REVERTED
, "IStream_Write should fail %08x\n", r
);
1198 r
= IStorage_Stat(stg2
, &statstg
, STATFLAG_NONAME
);
1199 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1201 r
= IStorage_Stat(stg3
, &statstg
, STATFLAG_NONAME
);
1202 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1205 IStream_Release(stm
);
1206 IStream_Release(stm2
);
1207 IStorage_Release(stg2
);
1208 IStorage_Release(stg3
);
1210 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_DENY_NONE
|STGM_READ
, 0, &stm
);
1211 ok(r
==STG_E_INVALIDFLAG
, "IStorage->OpenStream failed %08x\n", r
);
1213 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_DELETEONRELEASE
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1214 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
1216 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1217 ok(r
==STG_E_INVALIDFUNCTION
, "IStorage->OpenStream failed %08x\n", r
);
1219 r
= IStorage_OpenStorage(stg
, stmname
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1220 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
1223 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1224 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1227 IStream_Release(stm
);
1230 r
= IStorage_OpenStorage(stg
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1231 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1234 IStorage_Release(stg2
);
1236 r
= IStorage_OpenStorage(stg
, stmname2
, NULL
, STGM_TRANSACTED
|STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1237 ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream failed %08x\n", r
);
1239 r
= IStorage_OpenStream(stg
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1240 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1242 IStream_Release(stm
);
1244 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg2
);
1245 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1248 r
= IStorage_OpenStorage(stg2
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1249 ok(r
==S_OK
, "IStorage->OpenStorage should succeed %08x\n", r
);
1251 IStorage_Release(stg3
);
1253 r
= IStorage_OpenStorage(stg2
, stgname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, NULL
, 0, &stg3
);
1254 todo_wine
ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStorage should fail %08x\n", r
);
1256 IStorage_Release(stg3
);
1258 IStorage_Release(stg2
);
1261 IStorage_Release(stg
);
1263 r
= DeleteFileA(filenameA
);
1264 ok( r
== TRUE
, "deleted file\n");
1266 /* Revert only invalidates objects in transacted mode */
1267 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1268 STGM_READWRITE
, 0, &stg
);
1269 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1271 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1272 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1274 r
= IStorage_Revert(stg
);
1275 todo_wine
ok(r
==S_OK
, "IStorage->Revert failed %08x\n", r
);
1277 r
= IStream_Write(stm
, "this works\n", 11, NULL
);
1278 ok(r
==S_OK
, "IStream_Write should succeed %08x\n", r
);
1280 IStream_Release(stm
);
1281 IStream_Release(stg
);
1283 r
= DeleteFileA(filenameA
);
1284 ok( r
== TRUE
, "deleted file\n");
1287 static void test_parent_free(void)
1289 IStorage
*stg
= NULL
, *stg2
= NULL
, *stg3
= NULL
;
1291 IStream
*stm
= NULL
;
1292 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1293 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1297 DeleteFileA(filenameA
);
1299 /* create the file */
1300 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1301 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1302 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1304 /* create a new storage */
1305 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
1306 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1310 /* now create a stream inside the new storage */
1311 r
= IStorage_CreateStream(stg2
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1312 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1316 /* create a storage inside the new storage */
1317 r
= IStorage_CreateStorage(stg2
, stgname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stg3
);
1318 ok(r
==S_OK
, "IStorage->CreateStorage failed\n");
1321 /* free the parent */
1322 ref
= IStorage_Release(stg2
);
1323 ok(ref
== 0, "IStorage still has %u references\n", ref
);
1325 /* child objects are invalid */
1328 r
= IStream_Write(stm
, "this should fail\n", 17, NULL
);
1329 ok(r
==STG_E_REVERTED
, "IStream->Write sould fail, hr=%x\n", r
);
1331 IStream_Release(stm
);
1333 r
= IStorage_Stat(stg3
, &statstg
, STATFLAG_NONAME
);
1334 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1336 r
= IStorage_SetStateBits(stg3
, 1, 1);
1337 ok(r
==STG_E_REVERTED
, "IStorage_Stat should fail %08x\n", r
);
1339 IStorage_Release(stg3
);
1343 IStorage_Release(stg
);
1345 r
= DeleteFileA(filenameA
);
1346 ok( r
== TRUE
, "deleted file\n");
1349 static void test_nonroot_transacted(void)
1351 IStorage
*stg
= NULL
, *stg2
= NULL
;
1353 IStream
*stm
= NULL
;
1354 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
1355 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1356 static const WCHAR stmname2
[] = { 'F','O','O',0 };
1358 DeleteFileA(filenameA
);
1360 /* create a transacted file */
1361 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1362 STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1363 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1365 /* create a transacted substorage */
1366 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, 0, &stg2
);
1367 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1371 /* create and commit stmname */
1372 r
= IStorage_CreateStream(stg2
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1373 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1375 IStream_Release(stm
);
1377 IStorage_Commit(stg2
, 0);
1379 /* create and revert stmname2 */
1380 r
= IStorage_CreateStream(stg2
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1381 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1383 IStream_Release(stm
);
1385 IStorage_Revert(stg2
);
1387 /* check that Commit and Revert really worked */
1388 r
= IStorage_OpenStream(stg2
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1389 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1391 IStream_Release(stm
);
1393 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1394 todo_wine
ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1396 IStream_Release(stm
);
1398 IStorage_Release(stg2
);
1401 IStream_Release(stg
);
1403 /* create a non-transacted file */
1404 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
1405 STGM_READWRITE
, 0, &stg
);
1406 ok(r
==S_OK
, "StgCreateDocfile failed\n");
1408 /* create a transacted substorage */
1409 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, 0, &stg2
);
1410 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
1414 /* create and commit stmname */
1415 r
= IStorage_CreateStream(stg2
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1416 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1418 IStream_Release(stm
);
1420 IStorage_Commit(stg2
, 0);
1422 /* create and revert stmname2 */
1423 r
= IStorage_CreateStream(stg2
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1424 ok(r
==S_OK
, "IStorage->CreateStream failed\n");
1426 IStream_Release(stm
);
1428 IStorage_Revert(stg2
);
1430 /* check that Commit and Revert really worked */
1431 r
= IStorage_OpenStream(stg2
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1432 ok(r
==S_OK
, "IStorage->OpenStream should succeed %08x\n", r
);
1434 IStream_Release(stm
);
1436 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
|STGM_READWRITE
, 0, &stm
);
1437 todo_wine
ok(r
==STG_E_FILENOTFOUND
, "IStorage->OpenStream should fail %08x\n", r
);
1439 IStream_Release(stm
);
1441 IStorage_Release(stg2
);
1444 IStream_Release(stg
);
1446 r
= DeleteFileA(filenameA
);
1447 ok( r
== TRUE
, "deleted file\n");
1450 static void test_ReadClassStm(void)
1455 static const LARGE_INTEGER llZero
;
1457 hr
= ReadClassStm(NULL
, &clsid
);
1458 ok(hr
== E_INVALIDARG
, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
1460 hr
= CreateStreamOnHGlobal(NULL
, TRUE
, &pStream
);
1461 ok_ole_success(hr
, "CreateStreamOnHGlobal");
1462 hr
= WriteClassStm(pStream
, &test_stg_cls
);
1463 ok_ole_success(hr
, "WriteClassStm");
1465 hr
= ReadClassStm(pStream
, NULL
);
1466 ok(hr
== E_INVALIDARG
, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr
);
1468 /* test not rewound stream */
1469 hr
= ReadClassStm(pStream
, &clsid
);
1470 ok(hr
== STG_E_READFAULT
, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr
);
1471 ok(IsEqualCLSID(&clsid
, &CLSID_NULL
), "clsid should have been zeroed\n");
1473 hr
= IStream_Seek(pStream
, llZero
, STREAM_SEEK_SET
, NULL
);
1474 ok_ole_success(hr
, "IStream_Seek");
1475 hr
= ReadClassStm(pStream
, &clsid
);
1476 ok_ole_success(hr
, "ReadClassStm");
1477 ok(IsEqualCLSID(&clsid
, &test_stg_cls
), "clsid should have been set to CLSID_WineTest\n");
1487 static const struct access_res create
[16] =
1489 { TRUE
, ERROR_SUCCESS
, TRUE
},
1490 { TRUE
, ERROR_SUCCESS
, TRUE
},
1491 { TRUE
, ERROR_SUCCESS
, FALSE
},
1492 { TRUE
, ERROR_SUCCESS
, FALSE
},
1493 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1494 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1495 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1496 { TRUE
, ERROR_SUCCESS
, FALSE
},
1497 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1498 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1499 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1500 { TRUE
, ERROR_SUCCESS
, TRUE
},
1501 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1502 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1503 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1504 { TRUE
, ERROR_SUCCESS
, TRUE
}
1507 static const struct access_res create_commit
[16] =
1509 { TRUE
, ERROR_SUCCESS
, TRUE
},
1510 { TRUE
, ERROR_SUCCESS
, TRUE
},
1511 { TRUE
, ERROR_SUCCESS
, FALSE
},
1512 { TRUE
, ERROR_SUCCESS
, FALSE
},
1513 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1514 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1515 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1516 { TRUE
, ERROR_SUCCESS
, FALSE
},
1517 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1518 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1519 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1520 { TRUE
, ERROR_SUCCESS
, TRUE
},
1521 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1522 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1523 { FALSE
, ERROR_SHARING_VIOLATION
, FALSE
},
1524 { TRUE
, ERROR_SUCCESS
, TRUE
}
1527 static const struct access_res create_close
[16] =
1529 { TRUE
, ERROR_SUCCESS
, FALSE
},
1530 { TRUE
, ERROR_SUCCESS
, FALSE
},
1531 { TRUE
, ERROR_SUCCESS
, FALSE
},
1532 { TRUE
, ERROR_SUCCESS
, FALSE
},
1533 { TRUE
, ERROR_SUCCESS
, FALSE
},
1534 { TRUE
, ERROR_SUCCESS
, FALSE
},
1535 { TRUE
, ERROR_SUCCESS
, FALSE
},
1536 { TRUE
, ERROR_SUCCESS
, FALSE
},
1537 { TRUE
, ERROR_SUCCESS
, FALSE
},
1538 { TRUE
, ERROR_SUCCESS
, FALSE
},
1539 { TRUE
, ERROR_SUCCESS
, FALSE
},
1540 { TRUE
, ERROR_SUCCESS
, FALSE
},
1541 { TRUE
, ERROR_SUCCESS
, FALSE
},
1542 { TRUE
, ERROR_SUCCESS
, FALSE
},
1543 { TRUE
, ERROR_SUCCESS
, FALSE
},
1544 { TRUE
, ERROR_SUCCESS
}
1547 static void _test_file_access(LPCSTR file
, const struct access_res
*ares
, DWORD line
)
1549 DWORD access
= 0, share
= 0;
1554 for (i
= 0; i
< 4; i
++)
1556 if (i
== 0) access
= 0;
1557 if (i
== 1) access
= GENERIC_READ
;
1558 if (i
== 2) access
= GENERIC_WRITE
;
1559 if (i
== 3) access
= GENERIC_READ
| GENERIC_WRITE
;
1561 for (j
= 0; j
< 4; j
++)
1563 if (ares
[idx
].ignore
)
1566 if (j
== 0) share
= 0;
1567 if (j
== 1) share
= FILE_SHARE_READ
;
1568 if (j
== 2) share
= FILE_SHARE_WRITE
;
1569 if (j
== 3) share
= FILE_SHARE_READ
| FILE_SHARE_WRITE
;
1571 SetLastError(0xdeadbeef);
1572 hfile
= CreateFileA(file
, access
, share
, NULL
, OPEN_EXISTING
,
1573 FILE_ATTRIBUTE_NORMAL
, 0);
1574 lasterr
= GetLastError();
1576 ok((hfile
!= INVALID_HANDLE_VALUE
) == ares
[idx
].gothandle
,
1577 "(%d, handle, %d): Expected %d, got %d\n",
1578 line
, idx
, ares
[idx
].gothandle
,
1579 (hfile
!= INVALID_HANDLE_VALUE
));
1581 ok(lasterr
== ares
[idx
].lasterr
||
1582 broken(lasterr
== 0xdeadbeef) /* win9x */,
1583 "(%d, lasterr, %d): Expected %d, got %d\n",
1584 line
, idx
, ares
[idx
].lasterr
, lasterr
);
1592 #define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
1594 static void test_access(void)
1599 static const WCHAR fileW
[] = {'w','i','n','e','t','e','s','t',0};
1601 /* STGM_TRANSACTED */
1603 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1604 STGM_SHARE_EXCLUSIVE
| STGM_TRANSACTED
, 0, &stg
);
1605 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1607 test_file_access("winetest", create
);
1609 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1610 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1612 test_file_access("winetest", create_commit
);
1614 IStorage_Release(stg
);
1616 test_file_access("winetest", create_close
);
1618 DeleteFileA("winetest");
1622 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1623 STGM_SHARE_EXCLUSIVE
| STGM_DIRECT
, 0, &stg
);
1624 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1626 test_file_access("winetest", create
);
1628 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1629 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1631 test_file_access("winetest", create_commit
);
1633 IStorage_Release(stg
);
1635 test_file_access("winetest", create_close
);
1637 DeleteFileA("winetest");
1639 /* STGM_SHARE_DENY_NONE */
1641 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1642 STGM_SHARE_DENY_NONE
| STGM_TRANSACTED
, 0, &stg
);
1643 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1645 test_file_access("winetest", create
);
1647 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1648 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1650 test_file_access("winetest", create_commit
);
1652 IStorage_Release(stg
);
1654 test_file_access("winetest", create_close
);
1656 DeleteFileA("winetest");
1658 /* STGM_SHARE_DENY_READ */
1660 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1661 STGM_SHARE_DENY_READ
| STGM_TRANSACTED
, 0, &stg
);
1662 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1664 test_file_access("winetest", create
);
1666 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1667 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1669 test_file_access("winetest", create_commit
);
1671 IStorage_Release(stg
);
1673 test_file_access("winetest", create_close
);
1675 DeleteFileA("winetest");
1677 /* STGM_SHARE_DENY_WRITE */
1679 hr
= StgCreateDocfile(fileW
, STGM_CREATE
| STGM_READWRITE
|
1680 STGM_SHARE_DENY_WRITE
| STGM_TRANSACTED
, 0, &stg
);
1681 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1683 test_file_access("winetest", create
);
1685 hr
= IStorage_Commit(stg
, STGC_DEFAULT
);
1686 ok(hr
== S_OK
, "Expected S_OK, got %08x\n", hr
);
1688 test_file_access("winetest", create_commit
);
1690 IStorage_Release(stg
);
1692 test_file_access("winetest", create_close
);
1694 DeleteFileA("winetest");
1697 static void test_readonly(void)
1699 IStorage
*stg
, *stg2
, *stg3
;
1702 static const WCHAR fileW
[] = {'w','i','n','e','t','e','s','t',0};
1703 static const WCHAR storageW
[] = {'s','t','o','r','a','g','e',0};
1704 static const WCHAR streamW
[] = {'s','t','r','e','a','m',0};
1706 hr
= StgCreateDocfile( fileW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
1707 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1710 hr
= IStorage_CreateStorage( stg
, storageW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stg2
);
1711 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1714 hr
= IStorage_CreateStream( stg2
, streamW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stream
);
1715 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1717 IStream_Release(stream
);
1718 IStorage_Release(stg2
);
1720 IStorage_Release(stg
);
1723 /* re-open read only */
1724 hr
= StgOpenStorage( fileW
, NULL
, STGM_TRANSACTED
| STGM_SHARE_DENY_NONE
| STGM_READ
, NULL
, 0, &stg
);
1725 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1728 hr
= IStorage_OpenStorage( stg
, storageW
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READ
, NULL
, 0, &stg2
);
1729 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1732 /* CreateStream on read-only storage, name exists */
1733 hr
= IStorage_CreateStream( stg2
, streamW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stream
);
1734 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
1736 IStream_Release(stream
);
1738 /* CreateStream on read-only storage, name does not exist */
1739 hr
= IStorage_CreateStream( stg2
, storageW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stream
);
1740 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
1742 IStream_Release(stream
);
1744 /* CreateStorage on read-only storage, name exists */
1745 hr
= IStorage_CreateStorage( stg2
, streamW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stg3
);
1746 ok(hr
== STG_E_FILEALREADYEXISTS
, "should fail, res=%x\n", hr
);
1748 IStream_Release(stg3
);
1750 /* CreateStorage on read-only storage, name does not exist */
1751 hr
= IStorage_CreateStorage( stg2
, storageW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READ
, 0, 0, &stg3
);
1752 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
1754 IStream_Release(stg3
);
1756 /* DestroyElement on read-only storage, name exists */
1757 hr
= IStorage_DestroyElement( stg2
, streamW
);
1758 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
1760 /* DestroyElement on read-only storage, name does not exist */
1761 hr
= IStorage_DestroyElement( stg2
, storageW
);
1762 ok(hr
== STG_E_ACCESSDENIED
, "should fail, res=%x\n", hr
);
1764 IStorage_Release(stg2
);
1767 IStorage_Release(stg
);
1770 DeleteFileA("winetest");
1773 static void test_simple(void)
1775 /* Tests for STGM_SIMPLE mode */
1777 IStorage
*stg
, *stg2
;
1780 static const WCHAR stgname
[] = { 'S','t','g',0 };
1781 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
1782 static const WCHAR stmname2
[] = { 'S','m','a','l','l',0 };
1784 ULARGE_INTEGER upos
;
1788 DeleteFileA(filenameA
);
1790 r
= StgCreateDocfile( filename
, STGM_SIMPLE
| STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
1791 ok(r
== S_OK
, "got %08x\n", r
);
1793 r
= IStorage_CreateStorage(stg
, stgname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stg2
);
1794 ok(r
== STG_E_INVALIDFUNCTION
, "got %08x\n", r
);
1795 if (SUCCEEDED(r
)) IStorage_Release(stg2
);
1797 r
= IStorage_CreateStream(stg
, stmname
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1798 ok(r
== STG_E_INVALIDFLAG
, "got %08x\n", r
);
1799 r
= IStorage_CreateStream(stg
, stmname
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1800 ok(r
== S_OK
, "got %08x\n", r
);
1802 upos
.QuadPart
= 6000;
1803 r
= IStream_SetSize(stm
, upos
);
1804 ok(r
== S_OK
, "got %08x\n", r
);
1806 r
= IStream_Write(stm
, "foo", 3, &count
);
1807 ok(r
== S_OK
, "got %08x\n", r
);
1808 ok(count
== 3, "got %d\n", count
);
1811 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_CUR
, &upos
);
1812 ok(r
== S_OK
, "got %08x\n", r
);
1813 ok(upos
.QuadPart
== 3, "got %d\n", upos
.u
.LowPart
);
1815 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
1817 broken(r
== STG_E_INVALIDFUNCTION
), /* NT4 and below */
1820 ok(stat
.cbSize
.QuadPart
== 3, "got %d\n", stat
.cbSize
.u
.LowPart
);
1823 r
= IStream_Seek(stm
, pos
, STREAM_SEEK_SET
, &upos
);
1824 ok(r
== S_OK
, "got %08x\n", r
);
1825 ok(upos
.QuadPart
== 1, "got %d\n", upos
.u
.LowPart
);
1827 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
1829 broken(r
== STG_E_INVALIDFUNCTION
), /* NT4 and below */
1832 ok(stat
.cbSize
.QuadPart
== 1, "got %d\n", stat
.cbSize
.u
.LowPart
);
1834 IStream_Release(stm
);
1836 r
= IStorage_CreateStream(stg
, stmname2
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, 0, &stm
);
1837 ok(r
== S_OK
, "got %08x\n", r
);
1839 upos
.QuadPart
= 100;
1840 r
= IStream_SetSize(stm
, upos
);
1841 ok(r
== S_OK
, "got %08x\n", r
);
1843 r
= IStream_Write(stm
, "foo", 3, &count
);
1844 ok(r
== S_OK
, "got %08x\n", r
);
1845 ok(count
== 3, "got %d\n", count
);
1847 IStream_Release(stm
);
1849 IStorage_Commit(stg
, STGC_DEFAULT
);
1850 IStorage_Release(stg
);
1852 r
= StgOpenStorage( filename
, NULL
, STGM_SIMPLE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, NULL
, 0, &stg
);
1853 if (r
== STG_E_INVALIDFLAG
)
1855 win_skip("Flag combination is not supported on NT4 and below\n");
1856 DeleteFileA(filenameA
);
1859 ok(r
== S_OK
, "got %08x\n", r
);
1861 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, NULL
, 0, &stg2
);
1862 ok(r
== STG_E_INVALIDFUNCTION
, "got %08x\n", r
);
1863 if (SUCCEEDED(r
)) IStorage_Release(stg2
);
1865 r
= IStorage_OpenStream(stg
, stmname
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stm
);
1866 ok(r
== S_OK
, "got %08x\n", r
);
1868 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
1869 ok(r
== S_OK
, "got %08x\n", r
);
1870 ok(stat
.cbSize
.QuadPart
== 6000, "got %d\n", stat
.cbSize
.u
.LowPart
);
1872 IStream_Release(stm
);
1874 r
= IStorage_OpenStream(stg
, stmname2
, NULL
, STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stm
);
1875 ok(r
== S_OK
, "got %08x\n", r
);
1877 r
= IStream_Stat(stm
, &stat
, STATFLAG_NONAME
);
1878 ok(r
== S_OK
, "got %08x\n", r
);
1879 ok(stat
.cbSize
.QuadPart
== 4096, "got %d\n", stat
.cbSize
.u
.LowPart
);
1881 IStream_Release(stm
);
1884 IStorage_Release(stg
);
1886 DeleteFileA(filenameA
);
1889 static void test_fmtusertypestg(void)
1894 static const WCHAR fileW
[] = {'f','m','t','t','e','s','t',0};
1895 static WCHAR userTypeW
[] = {'S','t','g','U','s','r','T','y','p','e',0};
1896 static WCHAR strmNameW
[] = {1,'C','o','m','p','O','b','j',0};
1898 hr
= StgCreateDocfile( fileW
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &stg
);
1899 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1903 /* try to write the stream */
1904 hr
= WriteFmtUserTypeStg(stg
, 0, userTypeW
);
1905 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1907 /* check that the stream was created */
1908 hr
= IStorage_EnumElements(stg
, 0, NULL
, 0, &stat
);
1909 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1915 while ((hr
= IEnumSTATSTG_Next(stat
, 1, &statstg
, &got
)) == S_OK
&& got
== 1)
1917 if (lstrcmpW(statstg
.pwcsName
, strmNameW
) == 0)
1920 ok(0, "found unexpected stream or storage\n");
1922 ok(found
== TRUE
, "expected storage to contain stream \\0001CompObj\n");
1923 IEnumSTATSTG_Release(stat
);
1926 /* re-write the stream */
1927 hr
= WriteFmtUserTypeStg(stg
, 0, userTypeW
);
1928 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1930 /* check that the stream is still there */
1931 hr
= IStorage_EnumElements(stg
, 0, NULL
, 0, &stat
);
1932 ok(hr
== S_OK
, "should succeed, res=%x\n", hr
);
1938 while ((hr
= IEnumSTATSTG_Next(stat
, 1, &statstg
, &got
)) == S_OK
&& got
== 1)
1940 if (lstrcmpW(statstg
.pwcsName
, strmNameW
) == 0)
1943 ok(0, "found unexpected stream or storage\n");
1945 ok(found
== TRUE
, "expected storage to contain stream \\0001CompObj\n");
1946 IEnumSTATSTG_Release(stat
);
1949 IStorage_Release(stg
);
1950 DeleteFileW( fileW
);
1954 static void test_references(void)
1956 IStorage
*stg
,*stg2
;
1959 static const WCHAR StorName
[] = { 'D','a','t','a','S','p','a','c','e','I','n','f','o',0 };
1961 DeleteFileA(filenameA
);
1963 hr
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
|STGM_TRANSACTED
, 0, &stg
);
1964 ok(hr
==S_OK
, "StgCreateDocfile failed\n");
1968 IStorage_Release(stg
);
1970 hr
= StgOpenStorage( filename
, NULL
, STGM_TRANSACTED
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, NULL
, 0, &stg
);
1971 ok(hr
==S_OK
, "StgOpenStorage failed (result=%x)\n",hr
);
1975 hr
= IStorage_CreateStorage(stg
,StorName
,STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
,0,0,&stg2
);
1976 ok(hr
== S_OK
, "IStorage_CreateStorage failed (result=%x)\n",hr
);
1980 c1
= IStorage_AddRef(stg
);
1981 ok(c1
== 2, "creating internal storage added references to ancestor\n");
1982 c1
= IStorage_AddRef(stg
);
1983 IStorage_Release(stg2
);
1984 c2
= IStorage_AddRef(stg
) - 1;
1985 ok(c1
== c2
, "releasing internal storage removed references to ancestor\n");
1987 c1
= IStorage_Release(stg
);
1988 while ( c1
) c1
= IStorage_Release(stg
);
1992 DeleteFileA(filenameA
);
1997 * | `StreamA: "StreamA"
1999 * | `StreamB: "StreamB"
2000 * `StreamC: "StreamC"
2002 static HRESULT
create_test_file(IStorage
*dest
)
2004 IStorage
*stgA
= NULL
, *stgB
= NULL
;
2005 IStream
*strmA
= NULL
, *strmB
= NULL
, *strmC
= NULL
;
2006 const ULONG strmA_name_size
= lstrlenW(strmA_name
) * sizeof(WCHAR
);
2007 const ULONG strmB_name_size
= lstrlenW(strmB_name
) * sizeof(WCHAR
);
2008 const ULONG strmC_name_size
= lstrlenW(strmC_name
) * sizeof(WCHAR
);
2012 hr
= IStorage_CreateStorage(dest
, stgA_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stgA
);
2013 ok(hr
== S_OK
, "IStorage_CreateStorage failed: 0x%08x\n", hr
);
2017 hr
= IStorage_CreateStream(stgA
, strmA_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &strmA
);
2018 ok(hr
== S_OK
, "IStorage_CreateStream failed: 0x%08x\n", hr
);
2022 hr
= IStream_Write(strmA
, strmA_name
, strmA_name_size
, &bytes
);
2023 ok(hr
== S_OK
&& bytes
== strmA_name_size
, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr
, bytes
, strmA_name_size
);
2025 hr
= IStorage_CreateStorage(dest
, stgB_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stgB
);
2026 ok(hr
== S_OK
, "IStorage_CreateStorage failed: 0x%08x\n", hr
);
2030 hr
= IStorage_CreateStream(stgB
, strmB_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &strmB
);
2031 ok(hr
== S_OK
, "IStorage_CreateStream failed: 0x%08x\n", hr
);
2035 hr
= IStream_Write(strmB
, strmB_name
, strmB_name_size
, &bytes
);
2036 ok(hr
== S_OK
&& bytes
== strmB_name_size
, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr
, bytes
, strmB_name_size
);
2038 hr
= IStorage_CreateStream(dest
, strmC_name
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &strmC
);
2039 ok(hr
== S_OK
, "IStorage_CreateStream failed: 0x%08x\n", hr
);
2043 hr
= IStream_Write(strmC
, strmC_name
, strmC_name_size
, &bytes
);
2044 ok(hr
== S_OK
&& bytes
== strmC_name_size
, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr
, bytes
, strmC_name_size
);
2048 IStream_Release(strmC
);
2050 IStream_Release(strmB
);
2052 IStorage_Release(stgB
);
2054 IStream_Release(strmA
);
2056 IStorage_Release(stgA
);
2061 static void test_copyto(void)
2063 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2068 /* create & populate file1 */
2069 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2070 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2074 hr
= create_test_file(file1
);
2079 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2080 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2084 /* copy file1 into file2 */
2085 hr
= IStorage_CopyTo(file1
, 0, NULL
, NULL
, NULL
);
2086 ok(hr
== STG_E_INVALIDPOINTER
, "CopyTo should give STG_E_INVALIDPONITER, gave: 0x%08x\n", hr
);
2088 hr
= IStorage_CopyTo(file1
, 0, NULL
, NULL
, file2
);
2089 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2093 /* verify that all of file1 was copied */
2094 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2095 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2096 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2099 hr
= IStorage_OpenStream(stg_tmp
, strmA_name
, NULL
,
2100 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2101 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2104 memset(buf
, 0, sizeof(buf
));
2105 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2106 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2108 ok(lstrcmpW(buf
, strmA_name
) == 0,
2109 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmA_name
), wine_dbgstr_w(buf
));
2111 IStream_Release(strm_tmp
);
2114 IStorage_Release(stg_tmp
);
2117 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2118 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2119 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2122 hr
= IStorage_OpenStream(stg_tmp
, strmB_name
, NULL
,
2123 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2124 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2127 memset(buf
, 0, sizeof(buf
));
2128 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2129 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2131 ok(lstrcmpW(buf
, strmB_name
) == 0,
2132 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name
), wine_dbgstr_w(buf
));
2134 IStream_Release(strm_tmp
);
2137 IStorage_Release(stg_tmp
);
2140 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2141 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2142 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2145 memset(buf
, 0, sizeof(buf
));
2146 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2147 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2149 ok(lstrcmpW(buf
, strmC_name
) == 0,
2150 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name
), wine_dbgstr_w(buf
));
2152 IStream_Release(strm_tmp
);
2157 IStorage_Release(file1
);
2159 IStorage_Release(file2
);
2161 DeleteFileW(file1_name
);
2162 DeleteFileW(file2_name
);
2165 static void test_copyto_snbexclusions(void)
2167 static const WCHAR
*snb_exclude
[] = {stgA_name
, strmB_name
, strmC_name
, 0};
2169 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2174 /* create & populate file1 */
2175 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2176 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2180 hr
= create_test_file(file1
);
2185 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2186 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2190 /* copy file1 to file2 with name exclusions */
2191 hr
= IStorage_CopyTo(file1
, 0, NULL
, (SNB
)snb_exclude
, file2
);
2192 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2196 /* verify that file1 copied over, respecting exclusions */
2197 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2198 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2199 ok(hr
== STG_E_FILENOTFOUND
, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2201 IStorage_Release(stg_tmp
);
2203 hr
= IStorage_OpenStream(file2
, strmA_name
, NULL
,
2204 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2205 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2207 IStream_Release(strm_tmp
);
2209 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2210 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2211 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2214 hr
= IStorage_OpenStream(stg_tmp
, strmB_name
, NULL
,
2215 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2216 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2219 memset(buf
, 0, sizeof(buf
));
2220 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2221 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2223 ok(lstrcmpW(buf
, strmB_name
) == 0,
2224 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name
), wine_dbgstr_w(buf
));
2226 IStream_Release(strm_tmp
);
2229 IStorage_Release(stg_tmp
);
2232 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2233 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2234 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2236 IStream_Release(strm_tmp
);
2240 IStorage_Release(file1
);
2242 IStorage_Release(file2
);
2244 DeleteFileW(file1_name
);
2245 DeleteFileW(file2_name
);
2248 static void test_copyto_iidexclusions_storage(void)
2250 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2255 /* create & populate file1 */
2256 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2257 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2261 hr
= create_test_file(file1
);
2266 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2267 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2271 /* copy file1 to file2 with iid exclusions */
2272 hr
= IStorage_CopyTo(file1
, 1, &IID_IStorage
, NULL
, file2
);
2273 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2277 /* verify that file1 copied over, respecting exclusions */
2278 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2279 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2280 ok(hr
== STG_E_FILENOTFOUND
, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2282 IStorage_Release(stg_tmp
);
2284 hr
= IStorage_OpenStream(file2
, strmA_name
, NULL
,
2285 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2286 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2288 IStream_Release(strm_tmp
);
2290 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2291 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2292 ok(hr
== STG_E_FILENOTFOUND
, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2294 IStorage_Release(stg_tmp
);
2296 hr
= IStorage_OpenStream(file2
, strmB_name
, NULL
,
2297 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2298 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2300 IStream_Release(strm_tmp
);
2302 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2303 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2304 ok(hr
== S_OK
, "OpenStream failed: 0x%08x\n", hr
);
2307 memset(buf
, 0, sizeof(buf
));
2308 hr
= IStream_Read(strm_tmp
, buf
, sizeof(buf
), NULL
);
2309 ok(hr
== S_OK
, "Read failed: 0x%08x\n", hr
);
2311 ok(lstrcmpW(buf
, strmC_name
) == 0,
2312 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name
), wine_dbgstr_w(buf
));
2314 IStream_Release(strm_tmp
);
2319 IStorage_Release(file1
);
2321 IStorage_Release(file2
);
2323 DeleteFileW(file1_name
);
2324 DeleteFileW(file2_name
);
2327 static void test_copyto_iidexclusions_stream(void)
2329 IStorage
*file1
= NULL
, *file2
= NULL
, *stg_tmp
;
2333 /* create & populate file1 */
2334 hr
= StgCreateDocfile(file1_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file1
);
2335 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2339 hr
= create_test_file(file1
);
2344 hr
= StgCreateDocfile(file2_name
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
| STGM_READWRITE
, 0, &file2
);
2345 ok(hr
== S_OK
, "StgCreateDocfile failed: 0x%08x\n", hr
);
2349 /* copy file1 to file2 with iid exclusions */
2350 hr
= IStorage_CopyTo(file1
, 1, &IID_IStream
, NULL
, file2
);
2351 ok(hr
== S_OK
, "CopyTo failed: 0x%08x\n", hr
);
2355 /* verify that file1 copied over, respecting exclusions */
2356 hr
= IStorage_OpenStorage(file2
, stgA_name
, NULL
,
2357 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2358 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2361 hr
= IStorage_OpenStream(stg_tmp
, strmA_name
, NULL
,
2362 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2363 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2365 IStream_Release(strm_tmp
);
2367 IStorage_Release(stg_tmp
);
2370 hr
= IStorage_OpenStorage(file2
, stgB_name
, NULL
,
2371 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg_tmp
);
2372 ok(hr
== S_OK
, "OpenStorage failed: 0x%08x\n", hr
);
2375 hr
= IStorage_OpenStream(stg_tmp
, strmB_name
, NULL
,
2376 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2377 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2379 IStream_Release(strm_tmp
);
2381 IStorage_Release(stg_tmp
);
2384 hr
= IStorage_OpenStream(file2
, strmC_name
, NULL
,
2385 STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &strm_tmp
);
2386 ok(hr
== STG_E_FILENOTFOUND
, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr
);
2388 IStream_Release(strm_tmp
);
2392 IStorage_Release(file1
);
2394 IStorage_Release(file2
);
2396 DeleteFileW(file1_name
);
2397 DeleteFileW(file2_name
);
2400 static void test_rename(void)
2402 IStorage
*stg
, *stg2
;
2405 static const WCHAR stgname
[] = { 'P','E','R','M','S','T','G',0 };
2406 static const WCHAR stgname2
[] = { 'S','T','G',0 };
2407 static const WCHAR stmname
[] = { 'C','O','N','T','E','N','T','S',0 };
2408 static const WCHAR stmname2
[] = { 'E','N','T','S',0 };
2410 DeleteFileA(filenameA
);
2412 /* create the file */
2413 r
= StgCreateDocfile( filename
, STGM_CREATE
| STGM_SHARE_EXCLUSIVE
|
2414 STGM_READWRITE
, 0, &stg
);
2415 ok(r
==S_OK
, "StgCreateDocfile failed\n");
2417 /* create a substorage */
2418 r
= IStorage_CreateStorage(stg
, stgname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stg2
);
2419 ok(r
==S_OK
, "IStorage->CreateStorage failed, hr=%08x\n", r
);
2421 /* create a stream in the substorage */
2422 r
= IStorage_CreateStream(stg2
, stmname
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, 0, &stm
);
2423 ok(r
==S_OK
, "IStorage->CreateStream failed, hr=%08x\n", r
);
2424 IStream_Release(stm
);
2426 /* rename the stream */
2427 r
= IStorage_RenameElement(stg2
, stmname
, stmname2
);
2428 ok(r
==S_OK
, "IStorage->RenameElement failed, hr=%08x\n", r
);
2430 /* cannot open stream with old name */
2431 r
= IStorage_OpenStream(stg2
, stmname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
2432 ok(r
==STG_E_FILENOTFOUND
, "IStorage_OpenStream should fail, hr=%08x\n", r
);
2433 if (SUCCEEDED(r
)) IStream_Release(stm
);
2435 /* can open stream with new name */
2436 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
2437 ok(r
==S_OK
, "IStorage_OpenStream failed, hr=%08x\n", r
);
2438 if (SUCCEEDED(r
)) IStream_Release(stm
);
2440 IStorage_Release(stg2
);
2442 /* rename the storage */
2443 IStorage_RenameElement(stg
, stgname
, stgname2
);
2445 /* cannot open storage with old name */
2446 r
= IStorage_OpenStorage(stg
, stgname
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg2
);
2447 ok(r
==STG_E_FILENOTFOUND
, "IStorage_OpenStream should fail, hr=%08x\n", r
);
2448 if (SUCCEEDED(r
)) IStorage_Release(stg2
);
2450 /* can open storage with new name */
2451 r
= IStorage_OpenStorage(stg
, stgname2
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, NULL
, 0, &stg2
);
2452 ok(r
==S_OK
, "IStorage_OpenStream should fail, hr=%08x\n", r
);
2455 /* opened storage still has the stream */
2456 r
= IStorage_OpenStream(stg2
, stmname2
, NULL
, STGM_READWRITE
| STGM_SHARE_EXCLUSIVE
, 0, &stm
);
2457 ok(r
==S_OK
, "IStorage_OpenStream failed, hr=%08x\n", r
);
2458 if (SUCCEEDED(r
)) IStream_Release(stm
);
2460 IStorage_Release(stg2
);
2463 IStorage_Release(stg
);
2465 r
= DeleteFileA(filenameA
);
2466 ok( r
== TRUE
, "deleted file\n");
2469 START_TEST(storage32
)
2471 CHAR temp
[MAX_PATH
];
2473 GetTempPathA(MAX_PATH
, temp
);
2474 if(!GetTempFileNameA(temp
, "stg", 0, filenameA
))
2476 win_skip("Could not create temp file, %u\n", GetLastError());
2479 MultiByteToWideChar(CP_ACP
, 0, filenameA
, -1, filename
, MAX_PATH
);
2480 DeleteFileA(filenameA
);
2482 test_hglobal_storage_stat();
2483 test_create_storage_modes();
2484 test_storage_stream();
2485 test_open_storage();
2486 test_storage_suminfo();
2487 test_storage_refcount();
2490 test_substorage_share();
2493 test_nonroot_transacted();
2494 test_ReadClassStm();
2496 test_writeclassstg();
2499 test_fmtusertypestg();
2502 test_copyto_snbexclusions();
2503 test_copyto_iidexclusions_storage();
2504 test_copyto_iidexclusions_stream();