?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
dplayx: Adjust GetCaps behaviour to documentation
[wine/gsoc_dplay.git] / dlls / ole32 / tests / storage32.c
blobfec854e5c280cdf7a4e45a13fe92cf13c50b1719
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 void test_hglobal_storage_stat(void)
40 {
41 ILockBytes *ilb = NULL;
42 IStorage *stg = NULL;
43 HRESULT r;
44 STATSTG stat;
45 DWORD mode, refcount;
46
47 r = CreateILockBytesOnHGlobal( NULL, TRUE, &ilb );
48 ok( r == S_OK, "CreateILockBytesOnHGlobal failed\n");
49
50 mode = STGM_CREATE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE;/*0x1012*/
51 r = StgCreateDocfileOnILockBytes( ilb, mode, 0, &stg );
52 ok( r == S_OK, "StgCreateDocfileOnILockBytes failed\n");
53
54 r = WriteClassStg( stg, &test_stg_cls );
55 ok( r == S_OK, "WriteClassStg failed\n");
56
57 memset( &stat, 0, sizeof stat );
58 r = IStorage_Stat( stg, &stat, 0 );
59
60 ok( stat.pwcsName == NULL, "storage name not null\n");
61 ok( stat.type == 1, "type is wrong\n");
62 ok( stat.grfMode == 0x12, "grf mode is incorrect\n");
63 ok( !memcmp(&stat.clsid, &test_stg_cls, sizeof test_stg_cls), "CLSID is wrong\n");
64
65 refcount = IStorage_Release( stg );
66 ok( refcount == 0, "IStorage refcount is wrong\n");
67 refcount = ILockBytes_Release( ilb );
68 ok( refcount == 0, "ILockBytes refcount is wrong\n");
69 }
70
71 static void test_create_storage_modes(void)
72 {
73 IStorage *stg = NULL;
74 HRESULT r;
75
76 DeleteFileA(filenameA);
77
78 /* test with some invalid parameters */
79 r = StgCreateDocfile( NULL, 0, 0, &stg);
80 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
81 r = StgCreateDocfile( filename, 0, 0, &stg);
82 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
83 r = StgCreateDocfile( filename, STGM_CREATE, 0, &stg);
84 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
85 r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE, 0, &stg);
86 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
87 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE, 0, &stg);
88 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
89 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, NULL);
90 ok(r==STG_E_INVALIDPOINTER, "StgCreateDocfile succeeded\n");
91 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, &stg);
92 ok(r==STG_E_INVALIDPARAMETER, "StgCreateDocfile succeeded\n");
93 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
94 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
95 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READ, 0, &stg);
96 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
97 r = StgCreateDocfile( filename, STGM_PRIORITY, 0, &stg);
98 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
99
100 /* StgCreateDocfile seems to be very particular about the flags it accepts */
101 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | STGM_WRITE, 0, &stg);
102 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
103 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 8, 0, &stg);
104 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
105 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80, 0, &stg);
106 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
107 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800, 0, &stg);
108 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
109 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x8000, 0, &stg);
110 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
111 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x80000, 0, &stg);
112 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
113 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED | 0x800000, 0, &stg);
114 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
115 ok(stg == NULL, "stg was set\n");
116
117 /* check what happens if the file already exists (which is how it's meant to be used) */
118 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
119 ok(r==S_OK, "StgCreateDocfile failed\n");
120 r = IStorage_Release(stg);
121 ok(r == 0, "storage not released\n");
122 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
123 ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n"); /* FAILIFTHERE is default */
124 r = StgCreateDocfile( filename, STGM_READ, 0, &stg);
125 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n"); /* need at least readmode and sharemode */
126 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE, 0, &stg);
127 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
128 r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE, 0, &stg);
129 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
130 r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE, 0, &stg);
131 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
132 r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
133 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
134 r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, &stg);
135 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
136 r = StgCreateDocfile( filename, STGM_SHARE_DENY_NONE | STGM_WRITE, 0, &stg);
137 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
138 r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_WRITE, 0, &stg);
139 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile failed\n");
140 r = StgCreateDocfile( filename, STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
141 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
142 r = StgCreateDocfile( filename, STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READ, 0, &stg);
143 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile wrong error\n");
144 ok(DeleteFileA(filenameA), "failed to delete file\n");
145
146 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
147 ok(r==S_OK, "StgCreateDocfile failed\n");
148 r = IStorage_Release(stg);
149 ok(r == 0, "storage not released\n");
150 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED |STGM_FAILIFTHERE, 0, &stg);
151 ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
152 r = StgCreateDocfile( filename, STGM_SHARE_EXCLUSIVE | STGM_WRITE, 0, &stg);
153 ok(r==STG_E_FILEALREADYEXISTS, "StgCreateDocfile wrong error\n");
154
155 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_WRITE | STGM_READWRITE, 0, &stg);
156 ok(r==STG_E_INVALIDFLAG, "StgCreateDocfile succeeded\n");
157 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
158 ok(r==S_OK, "StgCreateDocfile failed\n");
159 r = IStorage_Release(stg);
160 ok(r == 0, "storage not released\n");
161 ok(DeleteFileA(filenameA), "failed to delete file\n");
162
163 r = StgCreateDocfile( filename, STGM_CREATE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
164 ok(r==S_OK, "StgCreateDocfile failed\n");
165 r = IStorage_Release(stg);
166 ok(r == 0, "storage not released\n");
167 ok(DeleteFileA(filenameA), "failed to delete file\n");
168
169 /* test the way excel uses StgCreateDocFile */
170 r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
171 ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
172 if(r == S_OK)
173 {
174 r = IStorage_Release(stg);
175 ok(r == 0, "storage not released\n");
176 ok(DeleteFileA(filenameA), "failed to delete file\n");
177 }
178
179 /* and the way windows media uses it ... */
180 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_DENY_NONE | STGM_READWRITE | STGM_TRANSACTED, 0, &stg);
181 ok(r==S_OK, "StgCreateDocfile the windows media way failed\n");
182 if (r == S_OK)
183 {
184 r = IStorage_Release(stg);
185 ok(r == 0, "storage not released\n");
186 ok(DeleteFileA(filenameA), "failed to delete file\n");
187 }
188
189 /* looks like we need STGM_TRANSACTED or STGM_CREATE */
190 r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, 0, &stg);
191 ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
192 if(r == S_OK)
193 {
194 r = IStorage_Release(stg);
195 ok(r == 0, "storage not released\n");
196 ok(DeleteFileA(filenameA), "failed to delete file\n");
197 }
198
199 r = StgCreateDocfile( filename, STGM_TRANSACTED|STGM_CREATE|STGM_SHARE_DENY_WRITE|STGM_WRITE, 0, &stg);
200 ok(r==S_OK, "StgCreateDocfile the excel way failed\n");
201 if(r == S_OK)
202 {
203 r = IStorage_Release(stg);
204 ok(r == 0, "storage not released\n");
205 ok(DeleteFileA(filenameA), "failed to delete file\n");
206 }
207
208 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
209 ok(r==S_OK, "StgCreateDocfile the powerpoint way failed\n");
210 if(r == S_OK)
211 {
212 r = IStorage_Release(stg);
213 ok(r == 0, "storage not released\n");
214 ok(DeleteFileA(filenameA), "failed to delete file\n");
215 }
216
217 /* test the way msi uses StgCreateDocfile */
218 r = StgCreateDocfile( filename, STGM_DIRECT | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stg);
219 ok(r==S_OK, "StgCreateDocFile failed\n");
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 static void test_storage_stream(void)
226 {
227 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
228 static const WCHAR longname[] = {
229 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
230 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',0
231 };
232 IStorage *stg = NULL;
233 HRESULT r;
234 IStream *stm = NULL;
235 IStream *stm2 = NULL;
236 ULONG count = 0;
237 LARGE_INTEGER pos;
238 ULARGE_INTEGER p;
239 unsigned char buffer[0x100];
240
241 DeleteFileA(filenameA);
242
243 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
244 ok(r==S_OK, "StgCreateDocfile failed\n");
245
246 /* try create some invalid streams */
247 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 1, 0, &stm );
248 ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
249 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 1, &stm );
250 ok(r==STG_E_INVALIDPARAMETER, "IStorage->CreateStream wrong error\n");
251 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, NULL );
252 ok(r==STG_E_INVALIDPOINTER, "IStorage->CreateStream wrong error\n");
253 r = IStorage_CreateStream(stg, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
254 ok(r==STG_E_INVALIDNAME, "IStorage->CreateStream wrong error\n");
255 r = IStorage_CreateStream(stg, longname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
256 ok(r==STG_E_INVALIDNAME || broken(r==S_OK) /* nt4 */,
257 "IStorage->CreateStream wrong error, got %d GetLastError()=%d\n", r, GetLastError());
258 r = IStorage_CreateStream(stg, stmname, STGM_READWRITE, 0, 0, &stm );
259 ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
260 r = IStorage_CreateStream(stg, stmname, STGM_READ, 0, 0, &stm );
261 ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
262 r = IStorage_CreateStream(stg, stmname, STGM_WRITE, 0, 0, &stm );
263 ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
264 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READWRITE, 0, 0, &stm );
265 ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
266 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_DENY_NONE | STGM_READ, 0, 0, &stm );
267 ok(r==STG_E_INVALIDFLAG, "IStorage->CreateStream wrong error\n");
268
269 /* now really create a stream and delete it */
270 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
271 ok(r==S_OK, "IStorage->CreateStream failed\n");
272 r = IStream_Release(stm);
273 ok(r == 0, "wrong ref count\n");
274 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
275 ok(r==STG_E_FILEALREADYEXISTS, "IStorage->CreateStream failed\n");
276 r = IStorage_DestroyElement(stg,stmname);
277 ok(r==S_OK, "IStorage->DestroyElement failed\n");
278
279 /* create a stream and write to it */
280 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
281 ok(r==S_OK, "IStorage->CreateStream failed\n");
282
283 r = IStream_Clone(stm, &stm2);
284 ok(r==S_OK, "failed to clone stream\n");
285
286 r = IStream_Write(stm, NULL, 0, NULL );
287 ok(r==STG_E_INVALIDPOINTER, "IStream->Write wrong error\n");
288 r = IStream_Write(stm, "Hello\n", 0, NULL );
289 ok(r==S_OK, "failed to write stream\n");
290 r = IStream_Write(stm, "Hello\n", 0, &count );
291 ok(r==S_OK, "failed to write stream\n");
292 r = IStream_Write(stm, "Hello\n", 6, &count );
293 ok(r==S_OK, "failed to write stream\n");
294 r = IStream_Commit(stm, STGC_DEFAULT );
295 ok(r==S_OK, "failed to commit stream\n");
296 r = IStream_Commit(stm, STGC_DEFAULT );
297 ok(r==S_OK, "failed to commit stream\n");
298
299 /* seek round a bit, reset the stream size */
300 pos.QuadPart = 0;
301 r = IStream_Seek(stm, pos, 3, &p );
302 ok(r==STG_E_INVALIDFUNCTION, "IStream->Seek returned wrong error\n");
303 r = IStream_Seek(stm, pos, STREAM_SEEK_SET, NULL);
304 ok(r==S_OK, "failed to seek stream\n");
305 r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
306 ok(r==S_OK, "failed to seek stream\n");
307 r = IStream_SetSize(stm,p);
308 ok(r==S_OK, "failed to set pos\n");
309 pos.QuadPart = 10;
310 r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p );
311 ok(r==S_OK, "failed to seek stream\n");
312 ok(p.QuadPart == 10, "at wrong place\n");
313 pos.QuadPart = 0;
314 r = IStream_Seek(stm, pos, STREAM_SEEK_END, &p );
315 ok(r==S_OK, "failed to seek stream\n");
316 ok(p.QuadPart == 0, "at wrong place\n");
317 r = IStream_Read(stm, buffer, sizeof buffer, &count );
318 ok(r==S_OK, "failed to set pos\n");
319 ok(count == 0, "read bytes from empty stream\n");
320
321 /* wrap up */
322 r = IStream_Release(stm2);
323 ok(r == 0, "wrong ref count\n");
324
325 /* create a stream and write to it */
326 r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm2 );
327 ok(r==S_OK, "IStorage->CreateStream failed\n");
328
329 r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &p);
330 ok(r==STG_E_REVERTED, "overwritten stream should return STG_E_REVERTED instead of 0x%08x\n", r);
331
332 r = IStream_Release(stm2);
333 ok(r == 0, "wrong ref count\n");
334 r = IStream_Release(stm);
335 ok(r == 0, "wrong ref count\n");
336
337 r = IStorage_Release(stg);
338 ok(r == 0, "wrong ref count\n");
339 r = DeleteFileA(filenameA);
340 ok(r, "file should exist\n");
341 }
342
343 static BOOL touch_file(LPCSTR filename)
344 {
345 HANDLE file;
346
347 file = CreateFileA(filename, GENERIC_READ|GENERIC_WRITE, 0, NULL,
348 CREATE_ALWAYS, FILE_ATTRIBUTE_NORMAL, NULL);
349 if (file==INVALID_HANDLE_VALUE)
350 return FALSE;
351 CloseHandle(file);
352 return TRUE;
353 }
354
355 static BOOL is_zero_length(LPCSTR filename)
356 {
357 HANDLE file;
358 DWORD len;
359
360 file = CreateFileA(filename, GENERIC_READ, 0, NULL,
361 OPEN_EXISTING, 0, NULL);
362 if (file==INVALID_HANDLE_VALUE)
363 return FALSE;
364 len = GetFileSize(file, NULL);
365 CloseHandle(file);
366 return len == 0;
367 }
368
369 static BOOL is_existing_file(LPCSTR filename)
370 {
371 HANDLE file;
372
373 file = CreateFileA(filename, GENERIC_READ, 0, NULL,
374 OPEN_EXISTING, 0, NULL);
375 if (file==INVALID_HANDLE_VALUE)
376 return FALSE;
377 CloseHandle(file);
378 return TRUE;
379 }
380
381 static void test_open_storage(void)
382 {
383 static const WCHAR szNonExist[] = { 'n','o','n','e','x','i','s','t',0 };
384 IStorage *stg = NULL, *stg2 = NULL;
385 HRESULT r;
386 DWORD stgm;
387
388 /* try opening a zero length file - it should stay zero length */
389 DeleteFileA(filenameA);
390 touch_file(filenameA);
391 stgm = STGM_NOSCRATCH | STGM_TRANSACTED | STGM_SHARE_DENY_WRITE | STGM_READWRITE;
392 r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
393 ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
394
395 stgm = STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
396 r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
397 ok(r==STG_E_FILEALREADYEXISTS, "StgOpenStorage didn't fail\n");
398 ok(is_zero_length(filenameA), "file length changed\n");
399
400 DeleteFileA(filenameA);
401
402 /* try opening a nonexistent file - it should not create it */
403 stgm = STGM_DIRECT | STGM_SHARE_EXCLUSIVE | STGM_READWRITE;
404 r = StgOpenStorage( filename, NULL, stgm, NULL, 0, &stg);
405 ok(r!=S_OK, "StgOpenStorage failed: 0x%08x\n", r);
406 if (r==S_OK) IStorage_Release(stg);
407 ok(!is_existing_file(filenameA), "StgOpenStorage should not create a file\n");
408 DeleteFileA(filenameA);
409
410 /* create the file */
411 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
412 ok(r==S_OK, "StgCreateDocfile failed\n");
413 IStorage_Release(stg);
414
415 r = StgOpenStorage( filename, NULL, 0, NULL, 0, &stg);
416 ok(r==STG_E_INVALIDFLAG, "StgOpenStorage wrong error\n");
417 r = StgOpenStorage( NULL, NULL, STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
418 ok(r==STG_E_INVALIDNAME, "StgOpenStorage wrong error\n");
419 r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, NULL);
420 ok(r==STG_E_INVALIDPOINTER, "StgOpenStorage wrong error\n");
421 r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 1, &stg);
422 ok(r==STG_E_INVALIDPARAMETER, "StgOpenStorage wrong error\n");
423 r = StgOpenStorage( szNonExist, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
424 ok(r==STG_E_FILENOTFOUND, "StgOpenStorage failed\n");
425 r = StgOpenStorage( filename, NULL, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
426 ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
427 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
428 ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
429 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_READ | STGM_READ, NULL, 0, &stg);
430 ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
431 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
432 ok(r==STG_E_INVALIDFLAG, "StgOpenStorage failed\n");
433
434 /* open it for real */
435 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg); /* XLViewer 97/2000 */
436 ok(r==S_OK, "StgOpenStorage failed\n");
437 if(stg)
438 {
439 r = IStorage_Release(stg);
440 ok(r == 0, "wrong ref count\n");
441 }
442
443 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE | STGM_READ, NULL, 0, &stg);
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 /* test the way word opens its custom dictionary */
452 r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_TRANSACTED |
453 STGM_SHARE_DENY_WRITE | STGM_READWRITE, NULL, 0, &stg);
454 ok(r==S_OK, "StgOpenStorage failed\n");
455 if(stg)
456 {
457 r = IStorage_Release(stg);
458 ok(r == 0, "wrong ref count\n");
459 }
460
461 r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
462 ok(r==S_OK, "StgOpenStorage failed\n");
463 r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2);
464 ok(r==STG_E_SHAREVIOLATION, "StgOpenStorage failed\n");
465 if(stg)
466 {
467 r = IStorage_Release(stg);
468 ok(r == 0, "wrong ref count\n");
469 }
470
471 /* now try write to a storage file we opened read-only */
472 r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg);
473 ok(r==S_OK, "StgOpenStorage failed\n");
474 if(stg)
475 {
476 static const WCHAR stmname[] = { 'w','i','n','e','t','e','s','t',0};
477 IStream *stm = NULL;
478 IStorage *stg2 = NULL;
479
480 r = IStorage_CreateStream( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE,
481 0, 0, &stm );
482 ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
483 r = IStorage_CreateStorage( stg, stmname, STGM_WRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stg2);
484 ok(r == STG_E_ACCESSDENIED, "CreateStream should fail\n");
485
486 r = IStorage_Release(stg);
487 ok(r == 0, "wrong ref count\n");
488 }
489
490 /* open like visio 2003 */
491 stg = NULL;
492 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_NONE, NULL, 0, &stg);
493 ok(r == S_OK, "should succeed\n");
494 if (stg)
495 IStorage_Release(stg);
496
497 /* test other sharing modes with STGM_PRIORITY */
498 stg = NULL;
499 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_EXCLUSIVE, NULL, 0, &stg);
500 ok(r == S_OK, "should succeed\n");
501 if (stg)
502 IStorage_Release(stg);
503
504 stg = NULL;
505 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_WRITE, NULL, 0, &stg);
506 ok(r == S_OK, "should succeed\n");
507 if (stg)
508 IStorage_Release(stg);
509
510 stg = NULL;
511 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_SHARE_DENY_READ, NULL, 0, &stg);
512 ok(r == S_OK, "should succeed\n");
513 if (stg)
514 IStorage_Release(stg);
515
516 /* open like Project 2003 */
517 stg = NULL;
518 r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg);
519 ok(r == S_OK, "should succeed\n");
520 r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stg2);
521 ok(r == S_OK, "should succeed\n");
522 if (stg2)
523 IStorage_Release(stg2);
524 if (stg)
525 IStorage_Release(stg);
526
527 stg = NULL;
528 r = StgOpenStorage( filename, NULL, STGM_PRIORITY | STGM_READWRITE, NULL, 0, &stg);
529 ok(r == STG_E_INVALIDFLAG, "should fail\n");
530
531 r = StgOpenStorage( filename, NULL, STGM_TRANSACTED | STGM_PRIORITY, NULL, 0, &stg);
532 ok(r == STG_E_INVALIDFLAG, "should fail\n");
533
534 r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_PRIORITY, NULL, 0, &stg);
535 ok(r == STG_E_INVALIDFLAG, "should fail\n");
536
537 r = StgOpenStorage( filename, NULL, STGM_DELETEONRELEASE | STGM_PRIORITY, NULL, 0, &stg);
538 ok(r == STG_E_INVALIDFUNCTION, "should fail\n");
539
540 r = StgOpenStorage( filename, NULL, STGM_NOSCRATCH | STGM_PRIORITY, NULL, 0, &stg);
541 ok(r == STG_E_INVALIDFLAG, "should fail\n");
542
543 r = StgOpenStorage( filename, NULL, STGM_NOSNAPSHOT | STGM_PRIORITY, NULL, 0, &stg);
544 ok(r == STG_E_INVALIDFLAG, "should fail\n");
545
546 r = DeleteFileA(filenameA);
547 ok(r, "file didn't exist\n");
548 }
549
550 static void test_storage_suminfo(void)
551 {
552 IStorage *stg = NULL;
553 IPropertySetStorage *propset = NULL;
554 IPropertyStorage *ps = NULL;
555 HRESULT r;
556
557 DeleteFileA(filenameA);
558
559 /* create the file */
560 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
561 STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
562 ok(r==S_OK, "StgCreateDocfile failed\n");
563
564 r = IStorage_QueryInterface( stg, &IID_IPropertySetStorage, (LPVOID) &propset );
565 ok(r == S_OK, "query interface failed\n");
566
567 /* delete it */
568 r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
569 ok(r == STG_E_FILENOTFOUND, "deleted property set storage\n");
570
571 r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
572 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
573 ok(r == STG_E_FILENOTFOUND, "opened property set storage\n");
574
575 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
576 STGM_READ | STGM_SHARE_EXCLUSIVE, &ps );
577 ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
578
579 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
580 STGM_READ, &ps );
581 ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
582
583 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0, 0, &ps );
584 ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
585
586 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
587 STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
588 ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
589
590 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
591 STGM_CREATE|STGM_WRITE|STGM_SHARE_EXCLUSIVE, &ps );
592 ok(r == STG_E_INVALIDFLAG, "created property set storage\n");
593
594 /* now try really creating a property set */
595 r = IPropertySetStorage_Create( propset, &FMTID_SummaryInformation, NULL, 0,
596 STGM_CREATE|STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps );
597 ok(r == S_OK, "failed to create property set storage\n");
598
599 if( ps )
600 IPropertyStorage_Release(ps);
601
602 /* now try creating the same thing again */
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 if( ps )
607 IPropertyStorage_Release(ps);
608
609 /* should be able to open it */
610 r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
611 STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
612 ok(r == S_OK, "open failed\n");
613 if(r == S_OK)
614 IPropertyStorage_Release(ps);
615
616 /* delete it */
617 r = IPropertySetStorage_Delete( propset, &FMTID_SummaryInformation );
618 ok(r == S_OK, "failed to delete property set storage\n");
619
620 /* try opening with an invalid FMTID */
621 r = IPropertySetStorage_Open( propset, NULL,
622 STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
623 ok(r == E_INVALIDARG, "open succeeded\n");
624 if(r == S_OK)
625 IPropertyStorage_Release(ps);
626
627 /* try a bad guid */
628 r = IPropertySetStorage_Open( propset, &IID_IStorage,
629 STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
630 ok(r == STG_E_FILENOTFOUND, "open succeeded\n");
631 if(r == S_OK)
632 IPropertyStorage_Release(ps);
633
634
635 /* try some invalid flags */
636 r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
637 STGM_CREATE | STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
638 ok(r == STG_E_INVALIDFLAG, "open succeeded\n");
639 if(r == S_OK)
640 IPropertyStorage_Release(ps);
641
642 /* after deleting it, it should be gone */
643 r = IPropertySetStorage_Open( propset, &FMTID_SummaryInformation,
644 STGM_READWRITE|STGM_SHARE_EXCLUSIVE, &ps);
645 ok(r == STG_E_FILENOTFOUND, "open failed\n");
646 if(r == S_OK)
647 IPropertyStorage_Release(ps);
648
649 r = IPropertySetStorage_Release( propset );
650 ok(r == 1, "ref count wrong\n");
651
652 r = IStorage_Release(stg);
653 ok(r == 0, "ref count wrong\n");
654
655 DeleteFileA(filenameA);
656 }
657
658 static void test_storage_refcount(void)
659 {
660 IStorage *stg = NULL;
661 IStorage *stgprio = NULL;
662 HRESULT r;
663 IStream *stm = NULL;
664 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
665 LARGE_INTEGER pos;
666 ULARGE_INTEGER upos;
667 STATSTG stat;
668 char buffer[10];
669
670 DeleteFileA(filenameA);
671
672 /* create the file */
673 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
674 STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
675 ok(r==S_OK, "StgCreateDocfile failed\n");
676
677 r = WriteClassStg( stg, &test_stg_cls );
678 ok( r == S_OK, "WriteClassStg failed\n");
679
680 r = IStorage_Commit( stg, STGC_DEFAULT );
681 ok( r == S_OK, "IStorage_Commit failed\n");
682
683 /* now create a stream */
684 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
685 ok(r==S_OK, "IStorage->CreateStream failed\n");
686
687 r = IStorage_Release( stg );
688 ok (r == 0, "storage not released\n");
689
690 pos.QuadPart = 0;
691 r = IStream_Seek( stm, pos, 0, &upos );
692 ok (r == STG_E_REVERTED, "seek should fail\n");
693
694 r = IStream_Stat( stm, &stat, STATFLAG_DEFAULT );
695 ok (r == STG_E_REVERTED, "stat should fail\n");
696
697 r = IStream_Write( stm, "Test string", strlen("Test string"), NULL);
698 ok (r == STG_E_REVERTED, "IStream_Write should return STG_E_REVERTED instead of 0x%08x\n", r);
699
700 r = IStream_Read( stm, buffer, sizeof(buffer), NULL);
701 ok (r == STG_E_REVERTED, "IStream_Read should return STG_E_REVERTED instead of 0x%08x\n", r);
702
703 r = IStream_Release(stm);
704 ok (r == 0, "stream not released\n");
705
706 /* tests that STGM_PRIORITY doesn't prevent readwrite access from other
707 * StgOpenStorage calls in transacted mode */
708 r = StgOpenStorage( filename, NULL, STGM_PRIORITY, NULL, 0, &stgprio);
709 ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
710
711 todo_wine {
712 /* non-transacted mode read/write fails */
713 r = StgOpenStorage( filename, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg);
714 ok(r==STG_E_LOCKVIOLATION, "StgOpenStorage should return STG_E_LOCKVIOLATION instead of 0x%08x\n", r);
715 }
716
717 /* non-transacted mode read-only succeeds */
718 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_WRITE|STGM_READ, NULL, 0, &stg);
719 ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
720 IStorage_Release(stg);
721
722 r = StgOpenStorage( filename, NULL, STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE, NULL, 0, &stg);
723 ok(r==S_OK, "StgOpenStorage failed with error 0x%08x\n", r);
724 if(stg)
725 {
726 static const WCHAR stgname[] = { ' ',' ',' ','2','9',0 };
727 static const WCHAR stgname2[] = { 'C','V','_','i','e','w',0 };
728 static const WCHAR stmname2[] = { 'V','a','r','2','D','a','t','a',0 };
729 IStorage *stg2;
730 IStorage *stg3;
731 STATSTG statstg;
732
733 r = IStorage_Stat( stg, &statstg, STATFLAG_NONAME );
734 ok(r == S_OK, "Stat should have succeded instead of returning 0x%08x\n", r);
735 ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
736 ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
737 ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
738 ok(statstg.grfMode == (STGM_TRANSACTED|STGM_SHARE_DENY_WRITE|STGM_READWRITE),
739 "Statstg grfMode should have been 0x10022 instead of 0x%x\n", statstg.grfMode);
740 ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
741 ok(IsEqualCLSID(&statstg.clsid, &test_stg_cls), "Statstg clsid is not test_stg_cls\n");
742 ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
743 ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
744
745 r = IStorage_CreateStorage( stg, stgname, STGM_SHARE_EXCLUSIVE, 0, 0, &stg2 );
746 ok(r == S_OK, "CreateStorage should have succeeded instead of returning 0x%08x\n", r);
747
748 r = IStorage_Stat( stg2, &statstg, STATFLAG_DEFAULT );
749 ok(r == S_OK, "Stat should have succeded instead of returning 0x%08x\n", r);
750 ok(!memcmp(statstg.pwcsName, stgname, sizeof(stgname)),
751 "Statstg pwcsName should have been the name the storage was created with\n");
752 ok(statstg.type == STGTY_STORAGE, "Statstg type should have been STGTY_STORAGE instead of %d\n", statstg.type);
753 ok(U(statstg.cbSize).LowPart == 0, "Statstg cbSize.LowPart should have been 0 instead of %d\n", U(statstg.cbSize).LowPart);
754 ok(U(statstg.cbSize).HighPart == 0, "Statstg cbSize.HighPart should have been 0 instead of %d\n", U(statstg.cbSize).HighPart);
755 ok(statstg.grfMode == STGM_SHARE_EXCLUSIVE,
756 "Statstg grfMode should have been STGM_SHARE_EXCLUSIVE instead of 0x%x\n", statstg.grfMode);
757 ok(statstg.grfLocksSupported == 0, "Statstg grfLocksSupported should have been 0 instead of %d\n", statstg.grfLocksSupported);
758 ok(IsEqualCLSID(&statstg.clsid, &CLSID_NULL), "Statstg clsid is not CLSID_NULL\n");
759 ok(statstg.grfStateBits == 0, "Statstg grfStateBits should have been 0 instead of %d\n", statstg.grfStateBits);
760 ok(statstg.reserved == 0, "Statstg reserved should have been 0 instead of %d\n", statstg.reserved);
761 CoTaskMemFree(statstg.pwcsName);
762
763 r = IStorage_CreateStorage( stg2, stgname2, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, 0, &stg3 );
764 ok(r == STG_E_ACCESSDENIED, "CreateStorage should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
765
766 r = IStorage_CreateStream( stg2, stmname2, STGM_CREATE|STGM_SHARE_EXCLUSIVE, 0, 0, &stm );
767 ok(r == STG_E_ACCESSDENIED, "CreateStream should have returned STG_E_ACCESSDENIED instead of 0x%08x\n", r);
768
769 IStorage_Release(stg2);
770
771 r = IStorage_Release(stg);
772 ok(r == 0, "wrong ref count\n");
773 }
774 IStorage_Release(stgprio);
775
776 DeleteFileA(filenameA);
777 }
778
779 static void test_writeclassstg(void)
780 {
781 IStorage *stg = NULL;
782 HRESULT r;
783 CLSID temp_cls;
784
785 DeleteFileA(filenameA);
786
787 /* create the file */
788 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
789 STGM_READWRITE, 0, &stg);
790 ok(r==S_OK, "StgCreateDocfile failed\n");
791
792 r = ReadClassStg( NULL, NULL );
793 ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
794
795 r = ReadClassStg( stg, NULL );
796 ok(r == E_INVALIDARG, "ReadClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
797
798 temp_cls.Data1 = 0xdeadbeef;
799 r = ReadClassStg( stg, &temp_cls );
800 ok(r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
801
802 ok(IsEqualCLSID(&temp_cls, &CLSID_NULL), "ReadClassStg returned wrong clsid\n");
803
804 r = WriteClassStg( NULL, NULL );
805 ok(r == E_INVALIDARG, "WriteClassStg should return E_INVALIDARG instead of 0x%08X\n", r);
806
807 r = WriteClassStg( stg, NULL );
808 ok(r == STG_E_INVALIDPOINTER, "WriteClassStg should return STG_E_INVALIDPOINTER instead of 0x%08X\n", r);
809
810 r = WriteClassStg( stg, &test_stg_cls );
811 ok( r == S_OK, "WriteClassStg failed with 0x%08X\n", r);
812
813 r = ReadClassStg( stg, &temp_cls );
814 ok( r == S_OK, "ReadClassStg failed with 0x%08X\n", r);
815 ok(IsEqualCLSID(&temp_cls, &test_stg_cls), "ReadClassStg returned wrong clsid\n");
816
817 r = IStorage_Release( stg );
818 ok (r == 0, "storage not released\n");
819
820 DeleteFileA(filenameA);
821 }
822
823 static void test_streamenum(void)
824 {
825 IStorage *stg = NULL;
826 HRESULT r;
827 IStream *stm = NULL;
828 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
829 STATSTG stat;
830 IEnumSTATSTG *ee = NULL;
831 ULONG count;
832
833 DeleteFileA(filenameA);
834
835 /* create the file */
836 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
837 STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
838 ok(r==S_OK, "StgCreateDocfile failed\n");
839
840 r = WriteClassStg( stg, &test_stg_cls );
841 ok( r == S_OK, "WriteClassStg failed\n");
842
843 r = IStorage_Commit( stg, STGC_DEFAULT );
844 ok( r == S_OK, "IStorage_Commit failed\n");
845
846 /* now create a stream */
847 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
848 ok(r==S_OK, "IStorage->CreateStream failed\n");
849
850 r = IStream_Release(stm);
851
852 /* first enum ... should be 1 stream */
853 r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
854 ok(r==S_OK, "IStorage->EnumElements failed\n");
855
856 count = 0xf00;
857 r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
858 ok(r==S_OK, "IEnumSTATSTG->Next failed\n");
859 ok(count == 1, "count wrong\n");
860
861 r = IEnumSTATSTG_Release(ee);
862
863 /* second enum... destroy the stream before reading */
864 r = IStorage_EnumElements(stg, 0, NULL, 0, &ee);
865 ok(r==S_OK, "IStorage->EnumElements failed\n");
866
867 r = IStorage_DestroyElement(stg, stmname);
868 ok(r==S_OK, "IStorage->EnumElements failed\n");
869
870 todo_wine {
871 count = 0xf00;
872 r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
873 ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
874 ok(count == 0, "count wrong\n");
875 }
876
877 /* reset and try again */
878 r = IEnumSTATSTG_Reset(ee);
879 ok(r==S_OK, "IEnumSTATSTG->Reset failed\n");
880
881 count = 0xf00;
882 r = IEnumSTATSTG_Next(ee, 1, &stat, &count);
883 ok(r==S_FALSE, "IEnumSTATSTG->Next failed\n");
884 ok(count == 0, "count wrong\n");
885
886 r = IEnumSTATSTG_Release(ee);
887 ok (r == 0, "enum not released\n");
888
889 r = IStorage_Release( stg );
890 ok (r == 0, "storage not released\n");
891
892 DeleteFileA(filenameA);
893 }
894
895 static void test_transact(void)
896 {
897 IStorage *stg = NULL, *stg2 = NULL;
898 HRESULT r;
899 IStream *stm = NULL;
900 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
901 static const WCHAR stmname2[] = { 'F','O','O',0 };
902
903 DeleteFileA(filenameA);
904
905 /* create the file */
906 r = StgCreateDocfile( filename, STGM_CREATE | STGM_SHARE_EXCLUSIVE |
907 STGM_READWRITE |STGM_TRANSACTED, 0, &stg);
908 ok(r==S_OK, "StgCreateDocfile failed\n");
909
910 /* now create a stream, but don't commit it */
911 r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
912 ok(r==S_OK, "IStorage->CreateStream failed\n");
913
914 r = IStream_Write(stm, "this is stream 1\n", 16, NULL);
915 ok(r==S_OK, "IStream->Write failed\n");
916
917 r = IStream_Release(stm);
918
919 r = IStorage_Commit(stg, 0);
920 ok(r==S_OK, "IStorage->Commit failed\n");
921
922 /* now create a stream, but don't commit it */
923 stm = NULL;
924 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm );
925 ok(r==S_OK, "IStorage->CreateStream failed\n");
926
927 r = IStream_Write(stm, "this is stream 2\n", 16, NULL);
928 ok(r==S_OK, "IStream->Write failed\n");
929
930 r = IStream_Commit(stm, STGC_ONLYIFCURRENT | STGC_DANGEROUSLYCOMMITMERELYTODISKCACHE);
931 ok(r==S_OK, "IStream->Commit failed\n");
932
933 r = IStream_Release(stm);
934
935 IStorage_Release(stg);
936
937 stm = NULL;
938 stg = NULL;
939 r = StgOpenStorage( filename, NULL, STGM_SHARE_DENY_NONE | STGM_READ | STGM_TRANSACTED, NULL, 0, &stg);
940 ok(r==S_OK, "StgOpenStorage failed\n");
941
942 if (!stg)
943 return;
944
945 r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_DENY_NONE|STGM_READ, 0, &stm );
946 ok(r==STG_E_INVALIDFLAG, "IStorage->OpenStream failed %08x\n", r);
947
948 r = IStorage_OpenStream(stg, stmname, NULL, STGM_DELETEONRELEASE|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
949 ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
950
951 r = IStorage_OpenStream(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
952 ok(r==STG_E_INVALIDFUNCTION, "IStorage->OpenStream failed %08x\n", r);
953
954 r = IStorage_OpenStorage(stg, stmname, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
955 ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
956
957 todo_wine {
958 r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
959 ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream should fail %08x\n", r);
960 }
961 if (stm)
962 r = IStream_Release(stm);
963
964 r = IStorage_OpenStorage(stg, stmname2, NULL, STGM_TRANSACTED|STGM_SHARE_EXCLUSIVE|STGM_READWRITE, NULL, 0, &stg2 );
965 ok(r==STG_E_FILENOTFOUND, "IStorage->OpenStream failed %08x\n", r);
966
967 r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE|STGM_READWRITE, 0, &stm );
968 ok(r==S_OK, "IStorage->OpenStream should fail %08x\n", r);
969 if (stm)
970 r = IStream_Release(stm);
971
972 IStorage_Release(stg);
973
974 r = DeleteFileA(filenameA);
975 ok( r == TRUE, "deleted file\n");
976 }
977
978 static void test_ReadClassStm(void)
979 {
980 CLSID clsid;
981 HRESULT hr;
982 IStream *pStream;
983 static const LARGE_INTEGER llZero;
984
985 hr = ReadClassStm(NULL, &clsid);
986 ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
987
988 hr = CreateStreamOnHGlobal(NULL, TRUE, &pStream);
989 ok_ole_success(hr, "CreateStreamOnHGlobal");
990 hr = WriteClassStm(pStream, &test_stg_cls);
991 ok_ole_success(hr, "WriteClassStm");
992
993 hr = ReadClassStm(pStream, NULL);
994 ok(hr == E_INVALIDARG, "ReadClassStm should have returned E_INVALIDARG instead of 0x%08x\n", hr);
995
996 /* test not rewound stream */
997 hr = ReadClassStm(pStream, &clsid);
998 ok(hr == STG_E_READFAULT, "ReadClassStm should have returned STG_E_READFAULT instead of 0x%08x\n", hr);
999 ok(IsEqualCLSID(&clsid, &CLSID_NULL), "clsid should have been zeroed\n");
1000
1001 hr = IStream_Seek(pStream, llZero, STREAM_SEEK_SET, NULL);
1002 ok_ole_success(hr, "IStream_Seek");
1003 hr = ReadClassStm(pStream, &clsid);
1004 ok_ole_success(hr, "ReadClassStm");
1005 ok(IsEqualCLSID(&clsid, &test_stg_cls), "clsid should have been set to CLSID_WineTest\n");
1006 }
1007
1008 struct access_res
1009 {
1010 BOOL gothandle;
1011 DWORD lasterr;
1012 BOOL ignore;
1013 };
1014
1015 static const struct access_res create[16] =
1016 {
1017 { TRUE, ERROR_SUCCESS, TRUE },
1018 { TRUE, ERROR_SUCCESS, TRUE },
1019 { TRUE, ERROR_SUCCESS, FALSE },
1020 { TRUE, ERROR_SUCCESS, FALSE },
1021 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1022 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1023 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1024 { TRUE, ERROR_SUCCESS, FALSE },
1025 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1026 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1027 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1028 { TRUE, ERROR_SUCCESS, TRUE },
1029 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1030 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1031 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1032 { TRUE, ERROR_SUCCESS, TRUE }
1033 };
1034
1035 static const struct access_res create_commit[16] =
1036 {
1037 { TRUE, ERROR_SUCCESS, TRUE },
1038 { TRUE, ERROR_SUCCESS, TRUE },
1039 { TRUE, ERROR_SUCCESS, FALSE },
1040 { TRUE, ERROR_SUCCESS, FALSE },
1041 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1042 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1043 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1044 { TRUE, ERROR_SUCCESS, FALSE },
1045 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1046 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1047 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1048 { TRUE, ERROR_SUCCESS, TRUE },
1049 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1050 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1051 { FALSE, ERROR_SHARING_VIOLATION, FALSE },
1052 { TRUE, ERROR_SUCCESS, TRUE }
1053 };
1054
1055 static const struct access_res create_close[16] =
1056 {
1057 { TRUE, ERROR_SUCCESS, FALSE },
1058 { TRUE, ERROR_SUCCESS, FALSE },
1059 { TRUE, ERROR_SUCCESS, FALSE },
1060 { TRUE, ERROR_SUCCESS, FALSE },
1061 { TRUE, ERROR_SUCCESS, FALSE },
1062 { TRUE, ERROR_SUCCESS, FALSE },
1063 { TRUE, ERROR_SUCCESS, FALSE },
1064 { TRUE, ERROR_SUCCESS, FALSE },
1065 { TRUE, ERROR_SUCCESS, FALSE },
1066 { TRUE, ERROR_SUCCESS, FALSE },
1067 { TRUE, ERROR_SUCCESS, FALSE },
1068 { TRUE, ERROR_SUCCESS, FALSE },
1069 { TRUE, ERROR_SUCCESS, FALSE },
1070 { TRUE, ERROR_SUCCESS, FALSE },
1071 { TRUE, ERROR_SUCCESS, FALSE },
1072 { TRUE, ERROR_SUCCESS }
1073 };
1074
1075 static void _test_file_access(LPCSTR file, const struct access_res *ares, DWORD line)
1076 {
1077 DWORD access = 0, share = 0;
1078 DWORD lasterr;
1079 HANDLE hfile;
1080 int i, j, idx = 0;
1081
1082 for (i = 0; i < 4; i++)
1083 {
1084 if (i == 0) access = 0;
1085 if (i == 1) access = GENERIC_READ;
1086 if (i == 2) access = GENERIC_WRITE;
1087 if (i == 3) access = GENERIC_READ | GENERIC_WRITE;
1088
1089 for (j = 0; j < 4; j++)
1090 {
1091 if (ares[idx].ignore)
1092 continue;
1093
1094 if (j == 0) share = 0;
1095 if (j == 1) share = FILE_SHARE_READ;
1096 if (j == 2) share = FILE_SHARE_WRITE;
1097 if (j == 3) share = FILE_SHARE_READ | FILE_SHARE_WRITE;
1098
1099 SetLastError(0xdeadbeef);
1100 hfile = CreateFileA(file, access, share, NULL, OPEN_EXISTING,
1101 FILE_ATTRIBUTE_NORMAL, 0);
1102 lasterr = GetLastError();
1103
1104 ok((hfile != INVALID_HANDLE_VALUE) == ares[idx].gothandle,
1105 "(%d, handle, %d): Expected %d, got %d\n",
1106 line, idx, ares[idx].gothandle,
1107 (hfile != INVALID_HANDLE_VALUE));
1108
1109 ok(lasterr == ares[idx].lasterr ||
1110 broken(lasterr == 0xdeadbeef) /* win9x */,
1111 "(%d, lasterr, %d): Expected %d, got %d\n",
1112 line, idx, ares[idx].lasterr, lasterr);
1113
1114 CloseHandle(hfile);
1115 idx++;
1116 }
1117 }
1118 }
1119
1120 #define test_file_access(file, ares) _test_file_access(file, ares, __LINE__)
1121
1122 static void test_access(void)
1123 {
1124 IStorage *stg;
1125 HRESULT hr;
1126
1127 static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1128
1129 /* STGM_TRANSACTED */
1130
1131 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1132 STGM_SHARE_EXCLUSIVE | STGM_TRANSACTED, 0, &stg);
1133 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1134
1135 test_file_access("winetest", create);
1136
1137 hr = IStorage_Commit(stg, STGC_DEFAULT);
1138 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1139
1140 test_file_access("winetest", create_commit);
1141
1142 IStorage_Release(stg);
1143
1144 test_file_access("winetest", create_close);
1145
1146 DeleteFileA("winetest");
1147
1148 /* STGM_DIRECT */
1149
1150 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1151 STGM_SHARE_EXCLUSIVE | STGM_DIRECT, 0, &stg);
1152 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1153
1154 test_file_access("winetest", create);
1155
1156 hr = IStorage_Commit(stg, STGC_DEFAULT);
1157 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1158
1159 test_file_access("winetest", create_commit);
1160
1161 IStorage_Release(stg);
1162
1163 test_file_access("winetest", create_close);
1164
1165 DeleteFileA("winetest");
1166
1167 /* STGM_SHARE_DENY_NONE */
1168
1169 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1170 STGM_SHARE_DENY_NONE | STGM_TRANSACTED, 0, &stg);
1171 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1172
1173 test_file_access("winetest", create);
1174
1175 hr = IStorage_Commit(stg, STGC_DEFAULT);
1176 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1177
1178 test_file_access("winetest", create_commit);
1179
1180 IStorage_Release(stg);
1181
1182 test_file_access("winetest", create_close);
1183
1184 DeleteFileA("winetest");
1185
1186 /* STGM_SHARE_DENY_READ */
1187
1188 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1189 STGM_SHARE_DENY_READ | STGM_TRANSACTED, 0, &stg);
1190 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1191
1192 test_file_access("winetest", create);
1193
1194 hr = IStorage_Commit(stg, STGC_DEFAULT);
1195 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1196
1197 test_file_access("winetest", create_commit);
1198
1199 IStorage_Release(stg);
1200
1201 test_file_access("winetest", create_close);
1202
1203 DeleteFileA("winetest");
1204
1205 /* STGM_SHARE_DENY_WRITE */
1206
1207 hr = StgCreateDocfile(fileW, STGM_CREATE | STGM_READWRITE |
1208 STGM_SHARE_DENY_WRITE | STGM_TRANSACTED, 0, &stg);
1209 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1210
1211 test_file_access("winetest", create);
1212
1213 hr = IStorage_Commit(stg, STGC_DEFAULT);
1214 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1215
1216 test_file_access("winetest", create_commit);
1217
1218 IStorage_Release(stg);
1219
1220 test_file_access("winetest", create_close);
1221
1222 DeleteFileA("winetest");
1223 }
1224
1225 static void test_readonly(void)
1226 {
1227 IStorage *stg, *stg2, *stg3;
1228 IStream *stream;
1229 HRESULT hr;
1230 static const WCHAR fileW[] = {'w','i','n','e','t','e','s','t',0};
1231 static const WCHAR storageW[] = {'s','t','o','r','a','g','e',0};
1232 static const WCHAR streamW[] = {'s','t','r','e','a','m',0};
1233
1234 hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1235 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1236 if (SUCCEEDED(hr))
1237 {
1238 hr = IStorage_CreateStorage( stg, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stg2 );
1239 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1240 if (SUCCEEDED(hr))
1241 {
1242 hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stream );
1243 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1244 if (SUCCEEDED(hr))
1245 IStream_Release(stream);
1246 IStorage_Release(stg2);
1247 }
1248 IStorage_Release(stg);
1249 }
1250
1251 /* re-open read only */
1252 hr = StgOpenStorage( fileW, NULL, STGM_TRANSACTED | STGM_SHARE_DENY_NONE | STGM_READ, NULL, 0, &stg);
1253 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1254 if (SUCCEEDED(hr))
1255 {
1256 hr = IStorage_OpenStorage( stg, storageW, NULL, STGM_SHARE_EXCLUSIVE | STGM_READ, NULL, 0, &stg2 );
1257 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1258 if (SUCCEEDED(hr))
1259 {
1260 /* CreateStream on read-only storage, name exists */
1261 hr = IStorage_CreateStream( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1262 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1263 if (SUCCEEDED(hr))
1264 IStream_Release(stream);
1265
1266 /* CreateStream on read-only storage, name does not exist */
1267 hr = IStorage_CreateStream( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stream );
1268 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1269 if (SUCCEEDED(hr))
1270 IStream_Release(stream);
1271
1272 /* CreateStorage on read-only storage, name exists */
1273 hr = IStorage_CreateStorage( stg2, streamW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1274 ok(hr == STG_E_FILEALREADYEXISTS, "should fail, res=%x\n", hr);
1275 if (SUCCEEDED(hr))
1276 IStream_Release(stg3);
1277
1278 /* CreateStorage on read-only storage, name does not exist */
1279 hr = IStorage_CreateStorage( stg2, storageW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READ, 0, 0, &stg3 );
1280 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1281 if (SUCCEEDED(hr))
1282 IStream_Release(stg3);
1283
1284 /* DestroyElement on read-only storage, name exists */
1285 hr = IStorage_DestroyElement( stg2, streamW );
1286 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1287
1288 /* DestroyElement on read-only storage, name does not exist */
1289 hr = IStorage_DestroyElement( stg2, storageW );
1290 ok(hr == STG_E_ACCESSDENIED, "should fail, res=%x\n", hr);
1291
1292 IStorage_Release(stg2);
1293 }
1294
1295 IStorage_Release(stg);
1296 }
1297
1298 DeleteFileA("winetest");
1299 }
1300
1301 static void test_simple(void)
1302 {
1303 /* Tests for STGM_SIMPLE mode */
1304
1305 IStorage *stg;
1306 HRESULT r;
1307 IStream *stm;
1308 static const WCHAR stmname[] = { 'C','O','N','T','E','N','T','S',0 };
1309 static const WCHAR stmname2[] = { 'S','m','a','l','l',0 };
1310 LARGE_INTEGER pos;
1311 ULARGE_INTEGER upos;
1312 DWORD count;
1313 STATSTG stat;
1314
1315 DeleteFileA(filenameA);
1316
1317 r = StgCreateDocfile( filename, STGM_SIMPLE | STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1318 ok(r == S_OK, "got %08x\n", r);
1319
1320 r = IStorage_CreateStream(stg, stmname, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1321 ok(r == STG_E_INVALIDFLAG, "got %08x\n", r);
1322 r = IStorage_CreateStream(stg, stmname, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1323 ok(r == S_OK, "got %08x\n", r);
1324
1325 upos.QuadPart = 6000;
1326 r = IStream_SetSize(stm, upos);
1327 ok(r == S_OK, "got %08x\n", r);
1328
1329 r = IStream_Write(stm, "foo", 3, &count);
1330 ok(r == S_OK, "got %08x\n", r);
1331 ok(count == 3, "got %d\n", count);
1332
1333 pos.QuadPart = 0;
1334 r = IStream_Seek(stm, pos, STREAM_SEEK_CUR, &upos);
1335 ok(r == S_OK, "got %08x\n", r);
1336 ok(upos.QuadPart == 3, "got %d\n", upos.u.LowPart);
1337
1338 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1339 ok(r == S_OK ||
1340 broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1341 "got %08x\n", r);
1342 if (r == S_OK)
1343 ok(stat.cbSize.QuadPart == 3, "got %d\n", stat.cbSize.u.LowPart);
1344
1345 pos.QuadPart = 1;
1346 r = IStream_Seek(stm, pos, STREAM_SEEK_SET, &upos);
1347 ok(r == S_OK, "got %08x\n", r);
1348 ok(upos.QuadPart == 1, "got %d\n", upos.u.LowPart);
1349
1350 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1351 ok(r == S_OK ||
1352 broken(r == STG_E_INVALIDFUNCTION), /* NT4 and below */
1353 "got %08x\n", r);
1354 if (r == S_OK)
1355 ok(stat.cbSize.QuadPart == 1, "got %d\n", stat.cbSize.u.LowPart);
1356
1357 IStream_Release(stm);
1358
1359 r = IStorage_CreateStream(stg, stmname2, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, 0, &stm);
1360 ok(r == S_OK, "got %08x\n", r);
1361
1362 upos.QuadPart = 100;
1363 r = IStream_SetSize(stm, upos);
1364 ok(r == S_OK, "got %08x\n", r);
1365
1366 r = IStream_Write(stm, "foo", 3, &count);
1367 ok(r == S_OK, "got %08x\n", r);
1368 ok(count == 3, "got %d\n", count);
1369
1370 IStream_Release(stm);
1371
1372 IStorage_Commit(stg, STGC_DEFAULT);
1373 IStorage_Release(stg);
1374
1375 r = StgOpenStorage( filename, NULL, STGM_SIMPLE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, NULL, 0, &stg);
1376 if (r == STG_E_INVALIDFLAG)
1377 {
1378 win_skip("Flag combination is not supported on NT4 and below\n");
1379 DeleteFileA(filenameA);
1380 return;
1381 }
1382 ok(r == S_OK, "got %08x\n", r);
1383
1384 r = IStorage_OpenStream(stg, stmname, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1385 ok(r == S_OK, "got %08x\n", r);
1386
1387 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1388 ok(r == S_OK, "got %08x\n", r);
1389 ok(stat.cbSize.QuadPart == 6000, "got %d\n", stat.cbSize.u.LowPart);
1390
1391 IStream_Release(stm);
1392
1393 r = IStorage_OpenStream(stg, stmname2, NULL, STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stm);
1394 ok(r == S_OK, "got %08x\n", r);
1395
1396 r = IStream_Stat(stm, &stat, STATFLAG_NONAME);
1397 ok(r == S_OK, "got %08x\n", r);
1398 ok(stat.cbSize.QuadPart == 4096, "got %d\n", stat.cbSize.u.LowPart);
1399
1400 IStream_Release(stm);
1401
1402
1403 IStorage_Release(stg);
1404
1405 DeleteFileA(filenameA);
1406 }
1407
1408 static void test_fmtusertypestg(void)
1409 {
1410 IStorage *stg;
1411 IEnumSTATSTG *stat;
1412 HRESULT hr;
1413 static const WCHAR fileW[] = {'f','m','t','t','e','s','t',0};
1414 static WCHAR userTypeW[] = {'S','t','g','U','s','r','T','y','p','e',0};
1415 static WCHAR strmNameW[] = {1,'C','o','m','p','O','b','j',0};
1416
1417 hr = StgCreateDocfile( fileW, STGM_CREATE | STGM_SHARE_EXCLUSIVE | STGM_READWRITE, 0, &stg);
1418 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1419
1420 if (SUCCEEDED(hr))
1421 {
1422 /* try to write the stream */
1423 hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1424 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1425
1426 /* check that the stream was created */
1427 hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1428 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1429 if (SUCCEEDED(hr))
1430 {
1431 BOOL found = FALSE;
1432 STATSTG statstg;
1433 DWORD got;
1434 while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1435 {
1436 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1437 found = TRUE;
1438 else
1439 ok(0, "found unexpected stream or storage\n");
1440 }
1441 ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1442 IEnumSTATSTG_Release(stat);
1443 }
1444
1445 /* re-write the stream */
1446 hr = WriteFmtUserTypeStg(stg, 0, userTypeW);
1447 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1448
1449 /* check that the stream is still there */
1450 hr = IStorage_EnumElements(stg, 0, NULL, 0, &stat);
1451 ok(hr == S_OK, "should succeed, res=%x\n", hr);
1452 if (SUCCEEDED(hr))
1453 {
1454 BOOL found = FALSE;
1455 STATSTG statstg;
1456 DWORD got;
1457 while ((hr = IEnumSTATSTG_Next(stat, 1, &statstg, &got)) == S_OK && got == 1)
1458 {
1459 if (lstrcmpW(statstg.pwcsName, strmNameW) == 0)
1460 found = TRUE;
1461 else
1462 ok(0, "found unexpected stream or storage\n");
1463 }
1464 ok(found == TRUE, "expected storage to contain stream \\0001CompObj\n");
1465 IEnumSTATSTG_Release(stat);
1466 }
1467
1468 IStorage_Release(stg);
1469 DeleteFileW( fileW );
1470 }
1471 }
1472
1473 START_TEST(storage32)
1474 {
1475 CHAR temp[MAX_PATH];
1476
1477 GetTempPathA(MAX_PATH, temp);
1478 if(!GetTempFileNameA(temp, "stg", 0, filenameA))
1479 {
1480 win_skip("Could not create temp file, %u\n", GetLastError());
1481 return;
1482 }
1483 MultiByteToWideChar(CP_ACP, 0, filenameA, -1, filename, MAX_PATH);
1484 DeleteFileA(filenameA);
1485
1486 test_hglobal_storage_stat();
1487 test_create_storage_modes();
1488 test_storage_stream();
1489 test_open_storage();
1490 test_storage_suminfo();
1491 test_storage_refcount();
1492 test_streamenum();
1493 test_transact();
1494 test_ReadClassStm();
1495 test_access();
1496 test_writeclassstg();
1497 test_readonly();
1498 test_simple();
1499 test_fmtusertypestg();
1500 }
DirectPlay implementation for GSoC