?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ole32: Forbid opening the same storage twice.
[wine/hacks.git] / dlls / ole32 / tests / storage32.c
blob42741acd41ec282214461dfa75605aa140f4c1e1
1 /*
2 * Unit tests for OLE storage
3 *
4 * Copyright (c) 2004 Mike McCormack
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #include <stdio.h>
22
23 #define COBJMACROS
24
25 #include <windows.h>
26 #include "wine/test.h"
27
28 #include "ole2.h"
29 #include "objidl.h"
30 #include "initguid.h"
31
32 DEFINE_GUID( test_stg_cls, 0x88888888, 0x0425, 0x0000, 0,0,0,0,0,0,0,0);
33
34 #define ok_ole_success(hr, func) ok(hr == S_OK, func " failed with error 0x%08x\n", hr)
35
36 static CHAR filenameA[MAX_PATH];
37 static WCHAR filename[MAX_PATH];
38
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};
46
47 static void test_hglobal_storage_stat(void)
48 {
49 ILockBytes *ilb = NULL;
50 IStorage *stg = NULL;
51 HRESULT r;
52 STATSTG stat;
53 DWORD mode, refcount;
54
55 r = CreateILockBytesOnHGlobal( NULL, TRUE, &ilb );
56 ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
57
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");
61
62 r = WriteClassStg( stg, &test_stg_cls );
63 ok( r == S_OK, "WriteClassStg failed\n");
64
65 memset( &stat, 0, sizeof stat );
66 r = IStorage_Stat( stg, &stat, 0 );
67
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");
72
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");
77 }
78
79 static void test_create_storage_modes(void)
80 {
81 IStorage *stg = NULL;
82 HRESULT r;
83
84 DeleteFileA(filenameA);
85
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");
107
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");
124
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");
153
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");
162
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");
170
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");
176
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");
180 if(r == S_OK)
181 {
182 r = IStorage_Release(stg);
183 ok(r == 0, "storage not released\n");
184 ok(DeleteFileA(filenameA), "failed to delete file\n");
185 }
186
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");
190 if (r == S_OK)
191 {
192 r = IStorage_Release(stg);
193 ok(r == 0, "storage not released\n");
194 ok(DeleteFileA(filenameA), "failed to delete file\n");
195 }
196
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");
200 if(r == S_OK)
201 {
202 r = IStorage_Release(stg);
203 ok(r == 0, "storage not released\n");
204 ok(DeleteFileA(filenameA), "failed to delete file\n");
205 }
206
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");
209 if(r == S_OK)
210 {
211 r = IStorage_Release(stg);
212 ok(r == 0, "storage not released\n");
213 ok(DeleteFileA(filenameA), "failed to delete file\n");
214 }
215
216 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
217 ok(r==S_OK, "StgCreateDocfile the powerpoint way failed\n");
218 if(r == S_OK)
219 {
220 r = IStorage_Release(stg);
221 ok(r == 0, "storage not released\n");
222 ok(DeleteFileA(filenameA), "failed to delete file\n");
223 }
224
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");
231 }
232
233 static void test_storage_stream(void)
234 {
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
239 };
240 IStorage *stg = NULL;
241 HRESULT r;
242 IStream *stm = NULL;
243 IStream *stm2 = NULL;
244 ULONG count = 0;
245 LARGE_INTEGER pos;
246 ULARGE_INTEGER p;
247 unsigned char buffer[0x100];
248
249 DeleteFileA(filenameA);
250
251 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
252 ok(r==S_OK, "StgCreateDocfile failed\n");
253
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");
276
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");
286
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");
290
291 r = IStream_Clone(stm, &stm2);
292 ok(r==S_OK, "failed to clone stream\n");
293
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");
306
307 /* seek round a bit, reset the stream size */
308 pos.QuadPart = 0;
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");
317 pos.QuadPart = 10;
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");
321 pos.QuadPart = 0;
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");
328
329 /* wrap up */
330 r = IStream_Release(stm2);
331 ok(r == 0, "wrong ref count\n");
332
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");
336
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);
339
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");
344
345 r = IStorage_Release(stg);
346 ok(r == 0, "wrong ref count\n");
347 r = DeleteFileA(filenameA);
348 ok(r, "file should exist\n");
349 }
350
351 static BOOL touch_file(LPCSTR filename)
352 {
353 HANDLE file;
354
355 file = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
356 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
357 if (file==INVALID_HANDLE_VALUE)
358 return FALSE;
359 CloseHandle(file);
360 return TRUE;
361 }
362
363 static BOOL is_zero_length(LPCSTR filename)
364 {
365 HANDLE file;
366 DWORD len;
367
368 file = CreateFileA(filename, GENERIC_READ, 0, NULL,
369 OPEN_EXISTING, 0, NULL);
370 if (file==INVALID_HANDLE_VALUE)
371 return FALSE;
372 len = GetFileSize(file, NULL);
373 CloseHandle(file);
374 return len == 0;
375 }
376
377 static BOOL is_existing_file(LPCSTR filename)
378 {
379 HANDLE file;
380
381 file = CreateFileA(filename, GENERIC_READ, 0, NULL,
382 OPEN_EXISTING, 0, NULL);
383 if (file==INVALID_HANDLE_VALUE)
384 return FALSE;
385 CloseHandle(file);
386 return TRUE;
387 }
388
389 static void test_open_storage(void)
390 {
391 static const WCHAR szNonExist[] = { 'n','o','n','e','x','i','s','t',0 };
392 IStorage *stg = NULL, *stg2 = NULL;
393 HRESULT r;
394 DWORD stgm;
395
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");
402
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");
407
408 DeleteFileA(filenameA);
409
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);
417
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);
422
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");
441
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");
445 if(stg)
446 {
447 r = IStorage_Release(stg);
448 ok(r == 0, "wrong ref count\n");
449 }
450
451 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READ, NULL, 0, &stg);
452 ok(r==S_OK, "StgOpenStorage failed\n");
453 if(stg)
454 {
455 r = IStorage_Release(stg);
456 ok(r == 0, "wrong ref count\n");
457 }
458
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");
463 if(stg)
464 {
465 r = IStorage_Release(stg);
466 ok(r == 0, "wrong ref count\n");
467 }
468
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");
473 if(stg)
474 {
475 r = IStorage_Release(stg);
476 ok(r == 0, "wrong ref count\n");
477 }
478
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");
482 if(stg)
483 {
484 static const WCHAR stmname[] = { 'w','i','n','e','t','e','s','t',0};
485 IStream *stm = NULL;
486 IStorage *stg2 = NULL;
487
488 r = IStorage_CreateStream( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
489 0, 0, &stm );
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");
493
494 r = IStorage_Release(stg);
495 ok(r == 0, "wrong ref count\n");
496 }
497
498 /* open like visio 2003 */
499 stg = NULL;
500 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
501 ok(r == S_OK, "should succeed\n");
502 if (stg)
503 IStorage_Release(stg);
504
505 /* test other sharing modes with STGM_PRIORITY */
506 stg = NULL;
507 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
508 ok(r == S_OK, "should succeed\n");
509 if (stg)
510 IStorage_Release(stg);
511
512 stg = NULL;
513 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
514 ok(r == S_OK, "should succeed\n");
515 if (stg)
516 IStorage_Release(stg);
517
518 stg = NULL;
519 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_READ, NULL, 0, &stg);
520 ok(r == S_OK, "should succeed\n");
521 if (stg)
522 IStorage_Release(stg);
523
524 /* open like Project 2003 */
525 stg = NULL;
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");
530 if (stg2)
531 IStorage_Release(stg2);
532 if (stg)
533 IStorage_Release(stg);
534
535 stg = NULL;
536 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_READWRITE, NULL, 0, &stg);
537 ok(r == STG_E_INVALIDFLAG, "should fail\n");
538
539 r = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_PRIORITY, NULL, 0, &stg);
540 ok(r == STG_E_INVALIDFLAG, "should fail\n");
541
542 r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_PRIORITY, NULL, 0, &stg);
543 ok(r == STG_E_INVALIDFLAG, "should fail\n");
544
545 r = StgOpenStorage( filename, NULL, STGM_DELETEONRELEASE | STGM_PRIORITY, NULL, 0, &stg);
546 ok(r == STG_E_INVALIDFUNCTION, "should fail\n");
547
548 r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_PRIORITY, NULL, 0, &stg);
549 ok(r == STG_E_INVALIDFLAG, "should fail\n");
550
551 r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg);
552 ok(r == STG_E_INVALIDFLAG, "should fail\n");
553
554 r = DeleteFileA(filenameA);
555 ok(r, "file didn't exist\n");
556 }
557
558 static void test_storage_suminfo(void)
559 {
560 IStorage *stg = NULL;
561 IPropertySetStorage *propset = NULL;
562 IPropertyStorage *ps = NULL;
563 HRESULT r;
564
565 DeleteFileA(filenameA);
566
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");
571
572 r = IStorage_QueryInterface( stg, &IID_IPropertySetStorage, (LPVOID) &propset );
573 ok(r == S_OK, "query interface failed\n");
574
575 /* delete it */
576 r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
577 ok(r == STG_E_FILENOTFOUND, "deleted property set storage\n");
578
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");
582
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");
586
587 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
588 STGM_READ, &ps );
589 ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
590
591 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0, 0, &ps );
592 ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
593
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");
597
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");
601
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");
606
607 if( ps )
608 IPropertyStorage_Release(ps);
609
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");
614 if( ps )
615 IPropertyStorage_Release(ps);
616
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");
621 if(r == S_OK)
622 IPropertyStorage_Release(ps);
623
624 /* delete it */
625 r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
626 ok(r == S_OK, "failed to delete property set storage\n");
627
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");
632 if(r == S_OK)
633 IPropertyStorage_Release(ps);
634
635 /* try a bad guid */
636 r = IPropertySetStorage_Open( propset, &IID_IStorage,
637 STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
638 ok(r == STG_E_FILENOTFOUND, "open succeeded\n");
639 if(r == S_OK)
640 IPropertyStorage_Release(ps);
641
642
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");
647 if(r == S_OK)
648 IPropertyStorage_Release(ps);
649
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");
654 if(r == S_OK)
655 IPropertyStorage_Release(ps);
656
657 r = IPropertySetStorage_Release( propset );
658 ok(r == 1, "ref count wrong\n");
659
660 r = IStorage_Release(stg);
661 ok(r == 0, "ref count wrong\n");
662
663 DeleteFileA(filenameA);
664 }
665
666 static void test_storage_refcount(void)
667 {
668 IStorage *stg = NULL;
669 IStorage *stgprio = NULL;
670 HRESULT r;
671 IStream *stm = NULL;
672 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
673 LARGE_INTEGER pos;
674 ULARGE_INTEGER upos;
675 STATSTG stat;
676 char buffer[10];
677
678 DeleteFileA(filenameA);
679
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");
684
685 r = WriteClassStg( stg, &test_stg_cls );
686 ok( r == S_OK, "WriteClassStg failed\n");
687
688 r = IStorage_Commit( stg, STGC_DEFAULT );
689 ok( r == S_OK, "IStorage_Commit failed\n");
690
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");
694
695 r = IStorage_Release( stg );
696 ok (r == 0, "storage not released\n");
697
698 pos.QuadPart = 0;
699 r = IStream_Seek( stm, pos, 0, &upos );
700 ok (r == STG_E_REVERTED, "seek should fail\n");
701
702 r = IStream_Stat( stm, &stat, STATFLAG_DEFAULT );
703 ok (r == STG_E_REVERTED, "stat should fail\n");
704
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);
707
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);
710
711 r = IStream_Release(stm);
712 ok (r == 0, "stream not released\n");
713
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);
718
719 todo_wine {
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);
723 }
724
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);
729
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);
732 if(stg)
733 {
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 };
737 IStorage *stg2;
738 IStorage *stg3;
739 STATSTG statstg;
740
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);
752
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);
755
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);
770
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);
773
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);
776
777 IStorage_Release(stg2);
778
779 r = IStorage_Release(stg);
780 ok(r == 0, "wrong ref count\n");
781 }
782 IStorage_Release(stgprio);
783
784 DeleteFileA(filenameA);
785 }
786
787 static void test_writeclassstg(void)
788 {
789 IStorage *stg = NULL;
790 HRESULT r;
791 CLSID temp_cls;
792
793 DeleteFileA(filenameA);
794
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");
799
800 r = ReadClassStg( NULL, NULL );
801 ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
802
803 r = ReadClassStg( stg, NULL );
804 ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
805
806 temp_cls.Data1 = 0xdeadbeef;
807 r = ReadClassStg( stg, &temp_cls );
808 ok(r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
809
810 ok(IsEqualCLSID(&temp_cls, &CLSID_NULL), "ReadClassStg returned wrong clsid\n");
811
812 r = WriteClassStg( NULL, NULL );
813 ok(r == E_INVALIDARG, "WriteClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
814
815 r = WriteClassStg( stg, NULL );
816 ok(r == STG_E_INVALIDPOINTER, "WriteClassStg should return STG_E_INVALIDPOINTER instead of 0x%08X\n", r);
817
818 r = WriteClassStg( stg, &test_stg_cls );
819 ok( r == S_OK, "WriteClassStg failed with 0x%08X\n", r);
820
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");
824
825 r = IStorage_Release( stg );
826 ok (r == 0, "storage not released\n");
827
828 DeleteFileA(filenameA);
829 }
830
831 static void test_streamenum(void)
832 {
833 IStorage *stg = NULL;
834 HRESULT r;
835 IStream *stm = NULL;
836 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
837 STATSTG stat;
838 IEnumSTATSTG *ee = NULL;
839 ULONG count;
840
841 DeleteFileA(filenameA);
842
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");
847
848 r = WriteClassStg( stg, &test_stg_cls );
849 ok( r == S_OK, "WriteClassStg failed\n");
850
851 r = IStorage_Commit( stg, STGC_DEFAULT );
852 ok( r == S_OK, "IStorage_Commit failed\n");
853
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");
857
858 r = IStream_Release(stm);
859
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");
863
864 count = 0xf00;
865 r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
866 ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
867 ok(count == 1, "count wrong\n");
868
869 r = IEnumSTATSTG_Release(ee);
870
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");
874
875 r = IStorage_DestroyElement(stg, stmname);
876 ok(r==S_OK, "IStorage->EnumElements failed\n");
877
878 todo_wine {
879 count = 0xf00;
880 r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
881 ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
882 ok(count == 0, "count wrong\n");
883 }
884
885 /* reset and try again */
886 r = IEnumSTATSTG_Reset(ee);
887 ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
888
889 count = 0xf00;
890 r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
891 ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
892 ok(count == 0, "count wrong\n");
893
894 r = IEnumSTATSTG_Release(ee);
895 ok (r == 0, "enum not released\n");
896
897 r = IStorage_Release( stg );
898 ok (r == 0, "storage not released\n");
899
900 DeleteFileA(filenameA);
901 }
902
903 static void test_transact(void)
904 {
905 IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
906 HRESULT r;
907 IStream *stm = 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 };
912
913 DeleteFileA(filenameA);
914
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");
919
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");
923
924 r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
925 ok(r==S_OK, "IStream->Write failed\n");
926
927 IStream_Release(stm);
928
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);
931
932 if (r == S_OK)
933 {
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);
937
938 if (r == S_OK)
939 IStorage_Release(stg3);
940
941 r = IStorage_Commit(stg, 0);
942 ok(r==S_OK, "IStorage->Commit failed\n");
943
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);
946
947 if (r == S_OK)
948 IStorage_Release(stg3);
949
950 IStorage_Release(stg2);
951 }
952
953 /* now create a stream and storage, but don't commit them */
954 stm = NULL;
955 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
956 ok(r==S_OK, "IStorage->CreateStream failed\n");
957
958 r = IStream_Write(stm, "this is stream 2\n", 16, NULL);
959 ok(r==S_OK, "IStream->Write failed\n");
960
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");
964
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);
967
968 if (r == S_OK)
969 IStorage_Release(stg2);
970
971 IStream_Release(stm);
972
973 IStorage_Release(stg);
974
975 stm = NULL;
976 stg = NULL;
977 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg);
978 ok(r==S_OK, "StgOpenStorage failed\n");
979
980 if (!stg)
981 return;
982
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);
985
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);
988
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);
991
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);
994
995 todo_wine {
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);
998 }
999 if (r == S_OK)
1000 IStream_Release(stm);
1001
1002 todo_wine {
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);
1005 }
1006 if (r == S_OK)
1007 IStorage_Release(stg2);
1008
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);
1011
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);
1014 if (r == S_OK)
1015 IStream_Release(stm);
1016
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);
1019 if (r == S_OK)
1020 {
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);
1023 if (r == S_OK)
1024 IStorage_Release(stg3);
1025
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);
1028 if (r == S_OK)
1029 IStorage_Release(stg3);
1030
1031 IStorage_Release(stg2);
1032 }
1033
1034 IStorage_Release(stg);
1035
1036 r = DeleteFileA(filenameA);
1037 ok( r == TRUE, "deleted file\n");
1038 }
1039
1040 static void test_substorage_share(void)
1041 {
1042 IStorage *stg, *stg2, *stg3;
1043 IStream *stm, *stm2;
1044 HRESULT r;
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 };
1048
1049 DeleteFileA(filenameA);
1050
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");
1055
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);
1059
1060 if (r == S_OK)
1061 {
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);
1064
1065 if (r == S_OK)
1066 IStorage_Release(stg3);
1067
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);
1070
1071 if (r == S_OK)
1072 IStorage_Release(stg3);
1073
1074 /* cannot rename the storage while it's open */
1075 r = IStorage_RenameElement(stg, stgname, othername);
1076 todo_wine ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1077 if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stgname);
1078
1079 #if 0
1080 /* This crashes on Wine. */
1081
1082 /* destroying an object while it's open invalidates it */
1083 r = IStorage_DestroyElement(stg, stgname);
1084 ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1085
1086 r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1087 todo_wine ok(r==STG_E_REVERTED, "IStorage->CreateStream failed, hr=%08x\n", r);
1088
1089 if (r == S_OK)
1090 IStorage_Release(stm);
1091 #endif
1092
1093 IStorage_Release(stg2);
1094 }
1095
1096 /* create a read/write stream and try to open it again */
1097 r = IStorage_CreateStream(stg, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
1098 ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
1099
1100 if (r == S_OK)
1101 {
1102 r = IStorage_OpenStream(stg, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1103 ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1104
1105 if (r == S_OK)
1106 IStorage_Release(stm2);
1107
1108 r = IStorage_OpenStream(stg, stmname, NULL, STGM_READ | STGM_SHARE_EXCLUSIVE, 0, &stm2);
1109 ok(r==STG_E_ACCESSDENIED, "IStorage->OpenStream should fail %08x\n", r);
1110
1111 if (r == S_OK)
1112 IStorage_Release(stm2);
1113
1114 /* cannot rename the stream while it's open */
1115 r = IStorage_RenameElement(stg, stmname, othername);
1116 ok(r==STG_E_ACCESSDENIED, "IStorage->RenameElement should fail %08x\n", r);
1117 if (SUCCEEDED(r)) IStorage_RenameElement(stg, othername, stmname);
1118
1119 /* destroying an object while it's open invalidates it */
1120 r = IStorage_DestroyElement(stg, stmname);
1121 ok(r==S_OK, "IStorage->DestroyElement failed, hr=%08x\n", r);
1122
1123 r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1124 ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1125
1126 IStorage_Release(stm);
1127 }
1128
1129 IStorage_Release(stg);
1130
1131 r = DeleteFileA(filenameA);
1132 ok( r == TRUE, "deleted file\n");
1133 }
1134
1135 static void test_revert(void)
1136 {
1137 IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1138 HRESULT r;
1139 IStream *stm = NULL, *stm2 = NULL;
1140 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1141 static const WCHAR stmname2[] = { 'F','O','O',0 };
1142 static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1143 static const WCHAR stgname2[] = { 'T','E','M','P','S','T','G',0 };
1144 STATSTG statstg;
1145
1146 DeleteFileA(filenameA);
1147
1148 /* create the file */
1149 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1150 STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1151 ok(r==S_OK, "StgCreateDocfile failed\n");
1152
1153 /* commit a new stream and storage */
1154 r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1155 ok(r==S_OK, "IStorage->CreateStream failed\n");
1156
1157 r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
1158 ok(r==S_OK, "IStream->Write failed\n");
1159
1160 r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1161 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1162
1163 if (r == S_OK)
1164 {
1165 /* Create two substorages but only commit one */
1166 r = IStorage_CreateStorage(stg2, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1167 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1168
1169 if (r == S_OK)
1170 IStorage_Release(stg3);
1171
1172 r = IStorage_Commit(stg, 0);
1173 ok(r==S_OK, "IStorage->Commit failed\n");
1174
1175 r = IStorage_CreateStorage(stg2, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1176 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1177
1178 if (r == S_OK)
1179 IStorage_Release(stg3);
1180 }
1181
1182 /* now create a stream and storage, then revert */
1183 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
1184 ok(r==S_OK, "IStorage->CreateStream failed\n");
1185
1186 r = IStream_Write(stm2, "this is stream 2\n", 16, NULL);
1187 ok(r==S_OK, "IStream->Write failed\n");
1188
1189 r = IStorage_CreateStorage(stg, stgname2, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg3);
1190 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1191
1192 r = IStorage_Revert(stg);
1193
1194 /* all open objects become invalid */
1195 todo_wine {
1196 r = IStream_Write(stm, "this shouldn't work\n", 20, NULL);
1197 ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1198
1199 r = IStream_Write(stm2, "this shouldn't work\n", 20, NULL);
1200 ok(r==STG_E_REVERTED, "IStream_Write should fail %08x\n", r);
1201
1202 r = IStorage_Stat(stg2, &statstg, STATFLAG_NONAME);
1203 ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1204
1205 r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
1206 ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1207 }
1208
1209 IStream_Release(stm);
1210 IStream_Release(stm2);
1211 IStorage_Release(stg2);
1212 IStorage_Release(stg3);
1213
1214 r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
1215 ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
1216
1217 r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1218 ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1219
1220 r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1221 ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
1222
1223 r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1224 ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1225
1226 todo_wine {
1227 r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1228 ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1229 }
1230 if (r == S_OK)
1231 IStream_Release(stm);
1232
1233 todo_wine {
1234 r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1235 ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1236 }
1237 if (r == S_OK)
1238 IStorage_Release(stg2);
1239
1240 r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1241 ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
1242
1243 r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1244 ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1245 if (r == S_OK)
1246 IStream_Release(stm);
1247
1248 r = IStorage_OpenStorage(stg, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
1249 ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1250 if (r == S_OK)
1251 {
1252 r = IStorage_OpenStorage(stg2, stgname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1253 ok(r==S_OK, "IStorage->OpenStorage should succeed %08x\n", r);
1254 if (r == S_OK)
1255 IStorage_Release(stg3);
1256
1257 r = IStorage_OpenStorage(stg2, stgname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg3 );
1258 todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStorage should fail %08x\n", r);
1259 if (r == S_OK)
1260 IStorage_Release(stg3);
1261
1262 IStorage_Release(stg2);
1263 }
1264
1265 IStorage_Release(stg);
1266
1267 r = DeleteFileA(filenameA);
1268 ok( r == TRUE, "deleted file\n");
1269
1270 /* Revert only invalidates objects in transacted mode */
1271 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1272 STGM_READWRITE, 0, &stg);
1273 ok(r==S_OK, "StgCreateDocfile failed\n");
1274
1275 r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1276 ok(r==S_OK, "IStorage->CreateStream failed\n");
1277
1278 r = IStorage_Revert(stg);
1279 todo_wine ok(r==S_OK, "IStorage->Revert failed %08x\n", r);
1280
1281 r = IStream_Write(stm, "this works\n", 11, NULL);
1282 ok(r==S_OK, "IStream_Write should succeed %08x\n", r);
1283
1284 IStream_Release(stm);
1285 IStream_Release(stg);
1286
1287 r = DeleteFileA(filenameA);
1288 ok( r == TRUE, "deleted file\n");
1289 }
1290
1291 static void test_parent_free(void)
1292 {
1293 IStorage *stg = NULL, *stg2 = NULL, *stg3 = NULL;
1294 HRESULT r;
1295 IStream *stm = NULL;
1296 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1297 static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1298 ULONG ref;
1299 STATSTG statstg;
1300
1301 DeleteFileA(filenameA);
1302
1303 /* create the file */
1304 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1305 STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1306 ok(r==S_OK, "StgCreateDocfile failed\n");
1307
1308 /* create a new storage */
1309 r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
1310 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1311
1312 if (r == S_OK)
1313 {
1314 /* now create a stream inside the new storage */
1315 r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1316 ok(r==S_OK, "IStorage->CreateStream failed\n");
1317
1318 if (r == S_OK)
1319 {
1320 /* create a storage inside the new storage */
1321 r = IStorage_CreateStorage(stg2, stgname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg3 );
1322 ok(r==S_OK, "IStorage->CreateStorage failed\n");
1323 }
1324
1325 /* free the parent */
1326 ref = IStorage_Release(stg2);
1327 ok(ref == 0, "IStorage still has %u references\n", ref);
1328
1329 /* child objects are invalid */
1330 if (r == S_OK)
1331 {
1332 r = IStream_Write(stm, "this should fail\n", 17, NULL);
1333 ok(r==STG_E_REVERTED, "IStream->Write sould fail, hr=%x\n", r);
1334
1335 IStream_Release(stm);
1336
1337 r = IStorage_Stat(stg3, &statstg, STATFLAG_NONAME);
1338 ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1339
1340 r = IStorage_SetStateBits(stg3, 1, 1);
1341 ok(r==STG_E_REVERTED, "IStorage_Stat should fail %08x\n", r);
1342
1343 IStorage_Release(stg3);
1344 }
1345 }
1346
1347 IStorage_Release(stg);
1348
1349 r = DeleteFileA(filenameA);
1350 ok( r == TRUE, "deleted file\n");
1351 }
1352
1353 static void test_nonroot_transacted(void)
1354 {
1355 IStorage *stg = NULL, *stg2 = NULL;
1356 HRESULT r;
1357 IStream *stm = NULL;
1358 static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
1359 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1360 static const WCHAR stmname2[] = { 'F','O','O',0 };
1361
1362 DeleteFileA(filenameA);
1363
1364 /* create a transacted file */
1365 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1366 STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1367 ok(r==S_OK, "StgCreateDocfile failed\n");
1368
1369 /* create a transacted substorage */
1370 r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1371 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1372
1373 if (r == S_OK)
1374 {
1375 /* create and commit stmname */
1376 r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1377 ok(r==S_OK, "IStorage->CreateStream failed\n");
1378 if (r == S_OK)
1379 IStream_Release(stm);
1380
1381 IStorage_Commit(stg2, 0);
1382
1383 /* create and revert stmname2 */
1384 r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1385 ok(r==S_OK, "IStorage->CreateStream failed\n");
1386 if (r == S_OK)
1387 IStream_Release(stm);
1388
1389 IStorage_Revert(stg2);
1390
1391 /* check that Commit and Revert really worked */
1392 r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1393 ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1394 if (r == S_OK)
1395 IStream_Release(stm);
1396
1397 r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1398 todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1399 if (r == S_OK)
1400 IStream_Release(stm);
1401
1402 IStorage_Release(stg2);
1403 }
1404
1405 IStream_Release(stg);
1406
1407 /* create a non-transacted file */
1408 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
1409 STGM_READWRITE, 0, &stg);
1410 ok(r==S_OK, "StgCreateDocfile failed\n");
1411
1412 /* create a transacted substorage */
1413 r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, 0, &stg2);
1414 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
1415
1416 if (r == S_OK)
1417 {
1418 /* create and commit stmname */
1419 r = IStorage_CreateStream(stg2, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1420 ok(r==S_OK, "IStorage->CreateStream failed\n");
1421 if (r == S_OK)
1422 IStream_Release(stm);
1423
1424 IStorage_Commit(stg2, 0);
1425
1426 /* create and revert stmname2 */
1427 r = IStorage_CreateStream(stg2, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
1428 ok(r==S_OK, "IStorage->CreateStream failed\n");
1429 if (r == S_OK)
1430 IStream_Release(stm);
1431
1432 IStorage_Revert(stg2);
1433
1434 /* check that Commit and Revert really worked */
1435 r = IStorage_OpenStream(stg2, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1436 ok(r==S_OK, "IStorage->OpenStream should succeed %08x\n", r);
1437 if (r == S_OK)
1438 IStream_Release(stm);
1439
1440 r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
1441 todo_wine ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
1442 if (r == S_OK)
1443 IStream_Release(stm);
1444
1445 IStorage_Release(stg2);
1446 }
1447
1448 IStream_Release(stg);
1449
1450 r = DeleteFileA(filenameA);
1451 ok( r == TRUE, "deleted file\n");
1452 }
1453
1454 static void test_ReadClassStm(void)
1455 {
1456 CLSID clsid;
1457 HRESULT hr;
1458 IStream *pStream;
1459 static const LARGE_INTEGER llZero;
1460
1461 hr = ReadClassStm(NULL, &clsid);
1462 ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1463
1464 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
1465 ok_ole_success(hr, "CreateStreamOnHGlobal");
1466 hr = WriteClassStm(pStream, &test_stg_cls);
1467 ok_ole_success(hr, "WriteClassStm");
1468
1469 hr = ReadClassStm(pStream, NULL);
1470 ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
1471
1472 /* test not rewound stream */
1473 hr = ReadClassStm(pStream, &clsid);
1474 ok(hr == STG_E_READFAULT, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
1475 ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid should have been zeroed\n");
1476
1477 hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
1478 ok_ole_success(hr, "IStream_Seek");
1479 hr = ReadClassStm(pStream, &clsid);
1480 ok_ole_success(hr, "ReadClassStm");
1481 ok(IsEqualCLSID(&clsid, &test_stg_cls), "clsid should have been set to CLSID_WineTest\n");
1482 }
1483
1484 struct access_res
1485 {
1486 BOOL gothandle;
1487 DWORD lasterr;
1488 BOOL ignore;
1489 };
1490
1491 static const struct access_res create[16] =
1492 {
1493 { TRUE, ERROR_SUCCESS, TRUE },
1494 { TRUE, ERROR_SUCCESS, TRUE },
1495 { TRUE, ERROR_SUCCESS, 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, FALSE },
1501 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1502 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1503 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1504 { TRUE, ERROR_SUCCESS, TRUE },
1505 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1506 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1507 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1508 { TRUE, ERROR_SUCCESS, TRUE }
1509 };
1510
1511 static const struct access_res create_commit[16] =
1512 {
1513 { TRUE, ERROR_SUCCESS, TRUE },
1514 { TRUE, ERROR_SUCCESS, TRUE },
1515 { TRUE, ERROR_SUCCESS, 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, FALSE },
1521 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1522 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1523 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1524 { TRUE, ERROR_SUCCESS, TRUE },
1525 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1526 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1527 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1528 { TRUE, ERROR_SUCCESS, TRUE }
1529 };
1530
1531 static const struct access_res create_close[16] =
1532 {
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, FALSE },
1545 { TRUE, ERROR_SUCCESS, FALSE },
1546 { TRUE, ERROR_SUCCESS, FALSE },
1547 { TRUE, ERROR_SUCCESS, FALSE },
1548 { TRUE, ERROR_SUCCESS }
1549 };
1550
1551 static void _test_file_access(LPCSTR file, const struct access_res *ares, DWORD line)
1552 {
1553 DWORD access = 0, share = 0;
1554 DWORD lasterr;
1555 HANDLE hfile;
1556 int i, j, idx = 0;
1557
1558 for (i = 0; i < 4; i++)
1559 {
1560 if (i == 0) access = 0;
1561 if (i == 1) access = GENERIC_READ;
1562 if (i == 2) access = GENERIC_WRITE;
1563 if (i == 3) access = GENERIC_READ | GENERIC_WRITE;
1564
1565 for (j = 0; j < 4; j++)
1566 {
1567 if (ares[idx].ignore)
1568 continue;
1569
1570 if (j == 0) share = 0;
1571 if (j == 1) share = FILE_SHARE_READ;
1572 if (j == 2) share = FILE_SHARE_WRITE;
1573 if (j == 3) share = FILE_SHARE_READ | FILE_SHARE_WRITE;
1574
1575 SetLastError(0xdeadbeef);
1576 hfile = CreateFileA(file, access, share, NULL, OPEN_EXISTING,
1577 FILE_ATTRIBUTE_NORMAL, 0);
1578 lasterr = GetLastError();
1579
1580 ok((hfile != INVALID_HANDLE_VALUE) == ares[idx].gothandle,
1581 "(%d, handle, %d): Expected %d, got %d\n",
1582 line, idx, ares[idx].gothandle,
1583 (hfile != INVALID_HANDLE_VALUE));
1584
1585 ok(lasterr == ares[idx].lasterr ||
1586 broken(lasterr == 0xdeadbeef) /* win9x */,
1587 "(%d, lasterr, %d): Expected %d, got %d\n",
1588 line, idx, ares[idx].lasterr, lasterr);
1589
1590 CloseHandle(hfile);
1591 idx++;
1592 }
1593 }
1594 }
1595
1596 #define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
1597
1598 static void test_access(void)
1599 {
1600 IStorage *stg;
1601 HRESULT hr;
1602
1603 static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1604
1605 /* STGM_TRANSACTED */
1606
1607 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1608 STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, &stg);
1609 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1610
1611 test_file_access("winetest", create);
1612
1613 hr = IStorage_Commit(stg, STGC_DEFAULT);
1614 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1615
1616 test_file_access("winetest", create_commit);
1617
1618 IStorage_Release(stg);
1619
1620 test_file_access("winetest", create_close);
1621
1622 DeleteFileA("winetest");
1623
1624 /* STGM_DIRECT */
1625
1626 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1627 STGM_SHARE_EXCLUSIVE | STGM_DIRECT, 0, &stg);
1628 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1629
1630 test_file_access("winetest", create);
1631
1632 hr = IStorage_Commit(stg, STGC_DEFAULT);
1633 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1634
1635 test_file_access("winetest", create_commit);
1636
1637 IStorage_Release(stg);
1638
1639 test_file_access("winetest", create_close);
1640
1641 DeleteFileA("winetest");
1642
1643 /* STGM_SHARE_DENY_NONE */
1644
1645 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1646 STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
1647 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1648
1649 test_file_access("winetest", create);
1650
1651 hr = IStorage_Commit(stg, STGC_DEFAULT);
1652 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1653
1654 test_file_access("winetest", create_commit);
1655
1656 IStorage_Release(stg);
1657
1658 test_file_access("winetest", create_close);
1659
1660 DeleteFileA("winetest");
1661
1662 /* STGM_SHARE_DENY_READ */
1663
1664 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1665 STGM_SHARE_DENY_READ | STGM_TRANSACTED, 0, &stg);
1666 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1667
1668 test_file_access("winetest", create);
1669
1670 hr = IStorage_Commit(stg, STGC_DEFAULT);
1671 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1672
1673 test_file_access("winetest", create_commit);
1674
1675 IStorage_Release(stg);
1676
1677 test_file_access("winetest", create_close);
1678
1679 DeleteFileA("winetest");
1680
1681 /* STGM_SHARE_DENY_WRITE */
1682
1683 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1684 STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
1685 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1686
1687 test_file_access("winetest", create);
1688
1689 hr = IStorage_Commit(stg, STGC_DEFAULT);
1690 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1691
1692 test_file_access("winetest", create_commit);
1693
1694 IStorage_Release(stg);
1695
1696 test_file_access("winetest", create_close);
1697
1698 DeleteFileA("winetest");
1699 }
1700
1701 static void test_readonly(void)
1702 {
1703 IStorage *stg, *stg2, *stg3;
1704 IStream *stream;
1705 HRESULT hr;
1706 static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1707 static const WCHAR storageW[] = {'s','t','o','r','a','g','e',0};
1708 static const WCHAR streamW[] = {'s','t','r','e','a','m',0};
1709
1710 hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1711 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1712 if (SUCCEEDED(hr))
1713 {
1714 hr = IStorage_CreateStorage( stg, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2 );
1715 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1716 if (SUCCEEDED(hr))
1717 {
1718 hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stream );
1719 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1720 if (SUCCEEDED(hr))
1721 IStream_Release(stream);
1722 IStorage_Release(stg2);
1723 }
1724 IStorage_Release(stg);
1725 }
1726
1727 /* re-open read only */
1728 hr = StgOpenStorage( fileW, NULL, STGM_TRANSACTED | STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
1729 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1730 if (SUCCEEDED(hr))
1731 {
1732 hr = IStorage_OpenStorage( stg, storageW, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2 );
1733 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1734 if (SUCCEEDED(hr))
1735 {
1736 /* CreateStream on read-only storage, name exists */
1737 hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1738 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1739 if (SUCCEEDED(hr))
1740 IStream_Release(stream);
1741
1742 /* CreateStream on read-only storage, name does not exist */
1743 hr = IStorage_CreateStream( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1744 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1745 if (SUCCEEDED(hr))
1746 IStream_Release(stream);
1747
1748 /* CreateStorage on read-only storage, name exists */
1749 hr = IStorage_CreateStorage( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1750 ok(hr == STG_E_FILEALREADYEXISTS, "should fail, res=%x\n", hr);
1751 if (SUCCEEDED(hr))
1752 IStream_Release(stg3);
1753
1754 /* CreateStorage on read-only storage, name does not exist */
1755 hr = IStorage_CreateStorage( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1756 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1757 if (SUCCEEDED(hr))
1758 IStream_Release(stg3);
1759
1760 /* DestroyElement on read-only storage, name exists */
1761 hr = IStorage_DestroyElement( stg2, streamW );
1762 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1763
1764 /* DestroyElement on read-only storage, name does not exist */
1765 hr = IStorage_DestroyElement( stg2, storageW );
1766 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1767
1768 IStorage_Release(stg2);
1769 }
1770
1771 IStorage_Release(stg);
1772 }
1773
1774 DeleteFileA("winetest");
1775 }
1776
1777 static void test_simple(void)
1778 {
1779 /* Tests for STGM_SIMPLE mode */
1780
1781 IStorage *stg;
1782 HRESULT r;
1783 IStream *stm;
1784 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1785 static const WCHAR stmname2[] = { 'S','m','a','l','l',0 };
1786 LARGE_INTEGER pos;
1787 ULARGE_INTEGER upos;
1788 DWORD count;
1789 STATSTG stat;
1790
1791 DeleteFileA(filenameA);
1792
1793 r = StgCreateDocfile( filename, STGM_SIMPLE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1794 ok(r == S_OK, "got %08x\n", r);
1795
1796 r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1797 ok(r == STG_E_INVALIDFLAG, "got %08x\n", r);
1798 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1799 ok(r == S_OK, "got %08x\n", r);
1800
1801 upos.QuadPart = 6000;
1802 r = IStream_SetSize(stm, upos);
1803 ok(r == S_OK, "got %08x\n", r);
1804
1805 r = IStream_Write(stm, "foo", 3, &count);
1806 ok(r == S_OK, "got %08x\n", r);
1807 ok(count == 3, "got %d\n", count);
1808
1809 pos.QuadPart = 0;
1810 r = IStream_Seek(stm, pos, STREAM_SEEK_CUR, &upos);
1811 ok(r == S_OK, "got %08x\n", r);
1812 ok(upos.QuadPart == 3, "got %d\n", upos.u.LowPart);
1813
1814 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1815 ok(r == S_OK ||
1816 broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1817 "got %08x\n", r);
1818 if (r == S_OK)
1819 ok(stat.cbSize.QuadPart == 3, "got %d\n", stat.cbSize.u.LowPart);
1820
1821 pos.QuadPart = 1;
1822 r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
1823 ok(r == S_OK, "got %08x\n", r);
1824 ok(upos.QuadPart == 1, "got %d\n", upos.u.LowPart);
1825
1826 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1827 ok(r == S_OK ||
1828 broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1829 "got %08x\n", r);
1830 if (r == S_OK)
1831 ok(stat.cbSize.QuadPart == 1, "got %d\n", stat.cbSize.u.LowPart);
1832
1833 IStream_Release(stm);
1834
1835 r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1836 ok(r == S_OK, "got %08x\n", r);
1837
1838 upos.QuadPart = 100;
1839 r = IStream_SetSize(stm, upos);
1840 ok(r == S_OK, "got %08x\n", r);
1841
1842 r = IStream_Write(stm, "foo", 3, &count);
1843 ok(r == S_OK, "got %08x\n", r);
1844 ok(count == 3, "got %d\n", count);
1845
1846 IStream_Release(stm);
1847
1848 IStorage_Commit(stg, STGC_DEFAULT);
1849 IStorage_Release(stg);
1850
1851 r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
1852 if (r == STG_E_INVALIDFLAG)
1853 {
1854 win_skip("Flag combination is not supported on NT4 and below\n");
1855 DeleteFileA(filenameA);
1856 return;
1857 }
1858 ok(r == S_OK, "got %08x\n", r);
1859
1860 r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1861 ok(r == S_OK, "got %08x\n", r);
1862
1863 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1864 ok(r == S_OK, "got %08x\n", r);
1865 ok(stat.cbSize.QuadPart == 6000, "got %d\n", stat.cbSize.u.LowPart);
1866
1867 IStream_Release(stm);
1868
1869 r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1870 ok(r == S_OK, "got %08x\n", r);
1871
1872 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1873 ok(r == S_OK, "got %08x\n", r);
1874 ok(stat.cbSize.QuadPart == 4096, "got %d\n", stat.cbSize.u.LowPart);
1875
1876 IStream_Release(stm);
1877
1878
1879 IStorage_Release(stg);
1880
1881 DeleteFileA(filenameA);
1882 }
1883
1884 static void test_fmtusertypestg(void)
1885 {
1886 IStorage *stg;
1887 IEnumSTATSTG *stat;
1888 HRESULT hr;
1889 static const WCHAR fileW[] = {'f','m','t','t','e','s','t',0};
1890 static WCHAR userTypeW[] = {'S','t','g','U','s','r','T','y','p','e',0};
1891 static WCHAR strmNameW[] = {1,'C','o','m','p','O','b','j',0};
1892
1893 hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1894 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1895
1896 if (SUCCEEDED(hr))
1897 {
1898 /* try to write the stream */
1899 hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1900 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1901
1902 /* check that the stream was created */
1903 hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1904 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1905 if (SUCCEEDED(hr))
1906 {
1907 BOOL found = FALSE;
1908 STATSTG statstg;
1909 DWORD got;
1910 while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1911 {
1912 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1913 found = TRUE;
1914 else
1915 ok(0, "found unexpected stream or storage\n");
1916 }
1917 ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1918 IEnumSTATSTG_Release(stat);
1919 }
1920
1921 /* re-write the stream */
1922 hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1923 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1924
1925 /* check that the stream is still there */
1926 hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1927 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1928 if (SUCCEEDED(hr))
1929 {
1930 BOOL found = FALSE;
1931 STATSTG statstg;
1932 DWORD got;
1933 while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1934 {
1935 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1936 found = TRUE;
1937 else
1938 ok(0, "found unexpected stream or storage\n");
1939 }
1940 ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1941 IEnumSTATSTG_Release(stat);
1942 }
1943
1944 IStorage_Release(stg);
1945 DeleteFileW( fileW );
1946 }
1947 }
1948
1949 static void test_references(void)
1950 {
1951 IStorage *stg,*stg2;
1952 HRESULT hr;
1953 unsigned c1,c2;
1954 static const WCHAR StorName[] = { 'D','a','t','a','S','p','a','c','e','I','n','f','o',0 };
1955
1956 DeleteFileA(filenameA);
1957
1958 hr = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
1959 ok(hr==S_OK, "StgCreateDocfile failed\n");
1960
1961 if (SUCCEEDED(hr))
1962 {
1963 IStorage_Release(stg);
1964
1965 hr = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
1966 ok(hr==S_OK, "StgOpenStorage failed (result=%x)\n",hr);
1967
1968 if (SUCCEEDED(hr))
1969 {
1970 hr = IStorage_CreateStorage(stg,StorName,STGM_READWRITE | STGM_SHARE_EXCLUSIVE,0,0,&stg2);
1971 ok(hr == S_OK, "IStorage_CreateStorage failed (result=%x)\n",hr);
1972
1973 if (SUCCEEDED(hr))
1974 {
1975 c1 = IStorage_AddRef(stg);
1976 ok(c1 == 2, "creating internal storage added references to ancestor\n");
1977 c1 = IStorage_AddRef(stg);
1978 IStorage_Release(stg2);
1979 c2 = IStorage_AddRef(stg) - 1;
1980 ok(c1 == c2, "releasing internal storage removed references to ancestor\n");
1981 }
1982 c1 = IStorage_Release(stg);
1983 while ( c1 ) c1 = IStorage_Release(stg);
1984 }
1985 }
1986
1987 DeleteFileA(filenameA);
1988 }
1989
1990 /* dest
1991 * |-StorageA
1992 * | `StreamA: "StreamA"
1993 * |-StorageB
1994 * | `StreamB: "StreamB"
1995 * `StreamC: "StreamC"
1996 */
1997 static HRESULT create_test_file(IStorage *dest)
1998 {
1999 IStorage *stgA = NULL, *stgB = NULL;
2000 IStream *strmA = NULL, *strmB = NULL, *strmC = NULL;
2001 const ULONG strmA_name_size = lstrlenW(strmA_name) * sizeof(WCHAR);
2002 const ULONG strmB_name_size = lstrlenW(strmB_name) * sizeof(WCHAR);
2003 const ULONG strmC_name_size = lstrlenW(strmC_name) * sizeof(WCHAR);
2004 ULONG bytes;
2005 HRESULT hr;
2006
2007 hr = IStorage_CreateStorage(dest, stgA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgA);
2008 ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
2009 if(FAILED(hr))
2010 goto cleanup;
2011
2012 hr = IStorage_CreateStream(stgA, strmA_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmA);
2013 ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2014 if(FAILED(hr))
2015 goto cleanup;
2016
2017 hr = IStream_Write(strmA, strmA_name, strmA_name_size, &bytes);
2018 ok(hr == S_OK && bytes == strmA_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmA_name_size);
2019
2020 hr = IStorage_CreateStorage(dest, stgB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stgB);
2021 ok(hr == S_OK, "IStorage_CreateStorage failed: 0x%08x\n", hr);
2022 if(FAILED(hr))
2023 goto cleanup;
2024
2025 hr = IStorage_CreateStream(stgB, strmB_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmB);
2026 ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2027 if(FAILED(hr))
2028 goto cleanup;
2029
2030 hr = IStream_Write(strmB, strmB_name, strmB_name_size, &bytes);
2031 ok(hr == S_OK && bytes == strmB_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmB_name_size);
2032
2033 hr = IStorage_CreateStream(dest, strmC_name, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &strmC);
2034 ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
2035 if(FAILED(hr))
2036 goto cleanup;
2037
2038 hr = IStream_Write(strmC, strmC_name, strmC_name_size, &bytes);
2039 ok(hr == S_OK && bytes == strmC_name_size, "IStream_Write failed: 0x%08x, %d of %d bytes written\n", hr, bytes, strmC_name_size);
2040
2041 cleanup:
2042 if(strmC)
2043 IStream_Release(strmC);
2044 if(strmB)
2045 IStream_Release(strmB);
2046 if(stgB)
2047 IStorage_Release(stgB);
2048 if(strmA)
2049 IStream_Release(strmA);
2050 if(stgA)
2051 IStorage_Release(stgA);
2052
2053 return hr;
2054 }
2055
2056 static void test_copyto(void)
2057 {
2058 IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2059 IStream *strm_tmp;
2060 WCHAR buf[64];
2061 HRESULT hr;
2062
2063 /* create & populate file1 */
2064 hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2065 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2066 if(FAILED(hr))
2067 goto cleanup;
2068
2069 hr = create_test_file(file1);
2070 if(FAILED(hr))
2071 goto cleanup;
2072
2073 /* create file2 */
2074 hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2075 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2076 if(FAILED(hr))
2077 goto cleanup;
2078
2079 /* copy file1 into file2 */
2080 hr = IStorage_CopyTo(file1, 0, NULL, NULL, NULL);
2081 ok(hr == STG_E_INVALIDPOINTER, "CopyTo should give STG_E_INVALIDPONITER, gave: 0x%08x\n", hr);
2082
2083 hr = IStorage_CopyTo(file1, 0, NULL, NULL, file2);
2084 ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2085 if(FAILED(hr))
2086 goto cleanup;
2087
2088 /* verify that all of file1 was copied */
2089 hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2090 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2091 ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2092
2093 if(SUCCEEDED(hr)){
2094 hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2095 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2096 ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2097
2098 if(SUCCEEDED(hr)){
2099 memset(buf, 0, sizeof(buf));
2100 hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2101 ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2102 if(SUCCEEDED(hr))
2103 ok(lstrcmpW(buf, strmA_name) == 0,
2104 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmA_name), wine_dbgstr_w(buf));
2105
2106 IStream_Release(strm_tmp);
2107 }
2108
2109 IStorage_Release(stg_tmp);
2110 }
2111
2112 hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2113 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2114 ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2115
2116 if(SUCCEEDED(hr)){
2117 hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2118 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2119 ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2120
2121 if(SUCCEEDED(hr)){
2122 memset(buf, 0, sizeof(buf));
2123 hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2124 ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2125 if(SUCCEEDED(hr))
2126 ok(lstrcmpW(buf, strmB_name) == 0,
2127 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2128
2129 IStream_Release(strm_tmp);
2130 }
2131
2132 IStorage_Release(stg_tmp);
2133 }
2134
2135 hr = IStorage_OpenStream(file2, strmC_name, NULL,
2136 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2137 ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2138
2139 if(SUCCEEDED(hr)){
2140 memset(buf, 0, sizeof(buf));
2141 hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2142 ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2143 if(SUCCEEDED(hr))
2144 ok(lstrcmpW(buf, strmC_name) == 0,
2145 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2146
2147 IStream_Release(strm_tmp);
2148 }
2149
2150 cleanup:
2151 if(file1)
2152 IStorage_Release(file1);
2153 if(file2)
2154 IStorage_Release(file2);
2155
2156 DeleteFileW(file1_name);
2157 DeleteFileW(file2_name);
2158 }
2159
2160 static void test_copyto_snbexclusions(void)
2161 {
2162 static const WCHAR *snb_exclude[] = {stgA_name, strmB_name, strmC_name, 0};
2163
2164 IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2165 IStream *strm_tmp;
2166 WCHAR buf[64];
2167 HRESULT hr;
2168
2169 /* create & populate file1 */
2170 hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2171 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2172 if(FAILED(hr))
2173 goto cleanup;
2174
2175 hr = create_test_file(file1);
2176 if(FAILED(hr))
2177 goto cleanup;
2178
2179 /* create file2 */
2180 hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2181 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2182 if(FAILED(hr))
2183 goto cleanup;
2184
2185 /* copy file1 to file2 with name exclusions */
2186 hr = IStorage_CopyTo(file1, 0, NULL, (SNB)snb_exclude, file2);
2187 ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2188 if(FAILED(hr))
2189 goto cleanup;
2190
2191 /* verify that file1 copied over, respecting exclusions */
2192 hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2193 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2194 ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2195 if(SUCCEEDED(hr))
2196 IStorage_Release(stg_tmp);
2197
2198 hr = IStorage_OpenStream(file2, strmA_name, NULL,
2199 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2200 ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2201 if(SUCCEEDED(hr))
2202 IStream_Release(strm_tmp);
2203
2204 hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2205 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2206 ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2207
2208 if(SUCCEEDED(hr)){
2209 hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2210 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2211 ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2212
2213 if(SUCCEEDED(hr)){
2214 memset(buf, 0, sizeof(buf));
2215 hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2216 ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2217 if(SUCCEEDED(hr))
2218 ok(lstrcmpW(buf, strmB_name) == 0,
2219 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmB_name), wine_dbgstr_w(buf));
2220
2221 IStream_Release(strm_tmp);
2222 }
2223
2224 IStorage_Release(stg_tmp);
2225 }
2226
2227 hr = IStorage_OpenStream(file2, strmC_name, NULL,
2228 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2229 ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2230 if(SUCCEEDED(hr))
2231 IStream_Release(strm_tmp);
2232
2233 cleanup:
2234 if(file1)
2235 IStorage_Release(file1);
2236 if(file2)
2237 IStorage_Release(file2);
2238
2239 DeleteFileW(file1_name);
2240 DeleteFileW(file2_name);
2241 }
2242
2243 static void test_copyto_iidexclusions_storage(void)
2244 {
2245 IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2246 IStream *strm_tmp;
2247 WCHAR buf[64];
2248 HRESULT hr;
2249
2250 /* create & populate file1 */
2251 hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2252 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2253 if(FAILED(hr))
2254 goto cleanup;
2255
2256 hr = create_test_file(file1);
2257 if(FAILED(hr))
2258 goto cleanup;
2259
2260 /* create file2 */
2261 hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2262 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2263 if(FAILED(hr))
2264 goto cleanup;
2265
2266 /* copy file1 to file2 with iid exclusions */
2267 hr = IStorage_CopyTo(file1, 1, &IID_IStorage, NULL, file2);
2268 ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2269 if(FAILED(hr))
2270 goto cleanup;
2271
2272 /* verify that file1 copied over, respecting exclusions */
2273 hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2274 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2275 ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2276 if(SUCCEEDED(hr))
2277 IStorage_Release(stg_tmp);
2278
2279 hr = IStorage_OpenStream(file2, strmA_name, NULL,
2280 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2281 ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2282 if(SUCCEEDED(hr))
2283 IStream_Release(strm_tmp);
2284
2285 hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2286 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2287 ok(hr == STG_E_FILENOTFOUND, "OpenStorage should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2288 if(SUCCEEDED(hr))
2289 IStorage_Release(stg_tmp);
2290
2291 hr = IStorage_OpenStream(file2, strmB_name, NULL,
2292 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2293 ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2294 if(SUCCEEDED(hr))
2295 IStream_Release(strm_tmp);
2296
2297 hr = IStorage_OpenStream(file2, strmC_name, NULL,
2298 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2299 ok(hr == S_OK, "OpenStream failed: 0x%08x\n", hr);
2300
2301 if(SUCCEEDED(hr)){
2302 memset(buf, 0, sizeof(buf));
2303 hr = IStream_Read(strm_tmp, buf, sizeof(buf), NULL);
2304 ok(hr == S_OK, "Read failed: 0x%08x\n", hr);
2305 if(SUCCEEDED(hr))
2306 ok(lstrcmpW(buf, strmC_name) == 0,
2307 "Expected %s to be read, got %s\n", wine_dbgstr_w(strmC_name), wine_dbgstr_w(buf));
2308
2309 IStream_Release(strm_tmp);
2310 }
2311
2312 cleanup:
2313 if(file1)
2314 IStorage_Release(file1);
2315 if(file2)
2316 IStorage_Release(file2);
2317
2318 DeleteFileW(file1_name);
2319 DeleteFileW(file2_name);
2320 }
2321
2322 static void test_copyto_iidexclusions_stream(void)
2323 {
2324 IStorage *file1 = NULL, *file2 = NULL, *stg_tmp;
2325 IStream *strm_tmp;
2326 HRESULT hr;
2327
2328 /* create & populate file1 */
2329 hr = StgCreateDocfile(file1_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file1);
2330 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2331 if(FAILED(hr))
2332 goto cleanup;
2333
2334 hr = create_test_file(file1);
2335 if(FAILED(hr))
2336 goto cleanup;
2337
2338 /* create file2 */
2339 hr = StgCreateDocfile(file2_name, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &file2);
2340 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
2341 if(FAILED(hr))
2342 goto cleanup;
2343
2344 /* copy file1 to file2 with iid exclusions */
2345 hr = IStorage_CopyTo(file1, 1, &IID_IStream, NULL, file2);
2346 ok(hr == S_OK, "CopyTo failed: 0x%08x\n", hr);
2347 if(FAILED(hr))
2348 goto cleanup;
2349
2350 /* verify that file1 copied over, respecting exclusions */
2351 hr = IStorage_OpenStorage(file2, stgA_name, NULL,
2352 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2353 ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2354
2355 if(SUCCEEDED(hr)){
2356 hr = IStorage_OpenStream(stg_tmp, strmA_name, NULL,
2357 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2358 ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2359 if(SUCCEEDED(hr))
2360 IStream_Release(strm_tmp);
2361
2362 IStorage_Release(stg_tmp);
2363 }
2364
2365 hr = IStorage_OpenStorage(file2, stgB_name, NULL,
2366 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg_tmp);
2367 ok(hr == S_OK, "OpenStorage failed: 0x%08x\n", hr);
2368
2369 if(SUCCEEDED(hr)){
2370 hr = IStorage_OpenStream(stg_tmp, strmB_name, NULL,
2371 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2372 ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2373 if(SUCCEEDED(hr))
2374 IStream_Release(strm_tmp);
2375
2376 IStorage_Release(stg_tmp);
2377 }
2378
2379 hr = IStorage_OpenStream(file2, strmC_name, NULL,
2380 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &strm_tmp);
2381 ok(hr == STG_E_FILENOTFOUND, "OpenStream should give STG_E_FILENOTFOUND, gave: 0x%08x\n", hr);
2382 if(SUCCEEDED(hr))
2383 IStream_Release(strm_tmp);
2384
2385 cleanup:
2386 if(file1)
2387 IStorage_Release(file1);
2388 if(file2)
2389 IStorage_Release(file2);
2390
2391 DeleteFileW(file1_name);
2392 DeleteFileW(file2_name);
2393 }
2394
2395 static void test_rename(void)
2396 {
2397 IStorage *stg, *stg2;
2398 IStream *stm;
2399 HRESULT r;
2400 static const WCHAR stgname[] = { 'P','E','R','M','S','T','G',0 };
2401 static const WCHAR stgname2[] = { 'S','T','G',0 };
2402 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
2403 static const WCHAR stmname2[] = { 'E','N','T','S',0 };
2404
2405 DeleteFileA(filenameA);
2406
2407 /* create the file */
2408 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
2409 STGM_READWRITE, 0, &stg);
2410 ok(r==S_OK, "StgCreateDocfile failed\n");
2411
2412 /* create a substorage */
2413 r = IStorage_CreateStorage(stg, stgname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
2414 ok(r==S_OK, "IStorage->CreateStorage failed, hr=%08x\n", r);
2415
2416 /* create a stream in the substorage */
2417 r = IStorage_CreateStream(stg2, stmname, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stm);
2418 ok(r==S_OK, "IStorage->CreateStream failed, hr=%08x\n", r);
2419 IStream_Release(stm);
2420
2421 /* rename the stream */
2422 r = IStorage_RenameElement(stg2, stmname, stmname2);
2423 ok(r==S_OK, "IStorage->RenameElement failed, hr=%08x\n", r);
2424
2425 /* cannot open stream with old name */
2426 r = IStorage_OpenStream(stg2, stmname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2427 ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2428 if (SUCCEEDED(r)) IStream_Release(stm);
2429
2430 /* can open stream with new name */
2431 r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2432 ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
2433 if (SUCCEEDED(r)) IStream_Release(stm);
2434
2435 IStorage_Release(stg2);
2436
2437 /* rename the storage */
2438 IStorage_RenameElement(stg, stgname, stgname2);
2439
2440 /* cannot open storage with old name */
2441 r = IStorage_OpenStorage(stg, stgname, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2442 ok(r==STG_E_FILENOTFOUND, "IStorage_OpenStream should fail, hr=%08x\n", r);
2443 if (SUCCEEDED(r)) IStorage_Release(stg2);
2444
2445 /* can open storage with new name */
2446 r = IStorage_OpenStorage(stg, stgname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg2);
2447 ok(r==S_OK, "IStorage_OpenStream should fail, hr=%08x\n", r);
2448 if (SUCCEEDED(r))
2449 {
2450 /* opened storage still has the stream */
2451 r = IStorage_OpenStream(stg2, stmname2, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stm);
2452 ok(r==S_OK, "IStorage_OpenStream failed, hr=%08x\n", r);
2453 if (SUCCEEDED(r)) IStream_Release(stm);
2454
2455 IStorage_Release(stg2);
2456 }
2457
2458 IStorage_Release(stg);
2459
2460 r = DeleteFileA(filenameA);
2461 ok( r == TRUE, "deleted file\n");
2462 }
2463
2464 START_TEST(storage32)
2465 {
2466 CHAR temp[MAX_PATH];
2467
2468 GetTempPathA(MAX_PATH, temp);
2469 if(!GetTempFileNameA(temp, "stg", 0, filenameA))
2470 {
2471 win_skip("Could not create temp file, %u\n", GetLastError());
2472 return;
2473 }
2474 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
2475 DeleteFileA(filenameA);
2476
2477 test_hglobal_storage_stat();
2478 test_create_storage_modes();
2479 test_storage_stream();
2480 test_open_storage();
2481 test_storage_suminfo();
2482 test_storage_refcount();
2483 test_streamenum();
2484 test_transact();
2485 test_substorage_share();
2486 test_revert();
2487 test_parent_free();
2488 test_nonroot_transacted();
2489 test_ReadClassStm();
2490 test_access();
2491 test_writeclassstg();
2492 test_readonly();
2493 test_simple();
2494 test_fmtusertypestg();
2495 test_references();
2496 test_copyto();
2497 test_copyto_snbexclusions();
2498 test_copyto_iidexclusions_storage();
2499 test_copyto_iidexclusions_stream();
2500 test_rename();
2501 }
useful hacks and other patches not (yet) suitable for mainline