[OLE32_WINETEST] Sync with Wine Staging 3.3. CORE-14434
[reactos.git] / modules / rostests / winetests / ole32 / stg_prop.c
1 /* IPropertyStorage unit tests
2 * Copyright 2005 Juan Lang
3 *
4 * This library is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU Lesser General Public
6 * License as published by the Free Software Foundation; either
7 * version 2.1 of the License, or (at your option) any later version.
8 *
9 * This library is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12 * Lesser General Public License for more details.
13 *
14 * You should have received a copy of the GNU Lesser General Public
15 * License along with this library; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
17 */
18 #include <stdio.h>
19 #define COBJMACROS
20 #include "objbase.h"
21 #include "wine/test.h"
22 #include "initguid.h"
23
24 DEFINE_GUID(GUID_NULL,0,0,0,0,0,0,0,0,0,0,0);
25 DEFINE_GUID(FMTID_SummaryInformation,0xF29F85E0,0x4FF9,0x1068,0xAB,0x91,0x08,0x00,0x2B,0x27,0xB3,0xD9);
26 DEFINE_GUID(FMTID_DocSummaryInformation,0xD5CDD502,0x2E9C,0x101B,0x93,0x97,0x08,0x00,0x2B,0x2C,0xF9,0xAE);
27 DEFINE_GUID(FMTID_UserDefinedProperties,0xD5CDD505,0x2E9C,0x101B,0x93,0x97,0x08,0x00,0x2B,0x2C,0xF9,0xAE);
28
29 #ifndef PID_BEHAVIOR
30 #define PID_BEHAVIOR 0x80000003
31 #endif
32
33 static HRESULT (WINAPI *pFmtIdToPropStgName)(const FMTID *, LPOLESTR);
34 static HRESULT (WINAPI *pPropStgNameToFmtId)(const LPOLESTR, FMTID *);
35 static HRESULT (WINAPI *pStgCreatePropSetStg)(IStorage *, DWORD, IPropertySetStorage **);
36 static HRESULT (WINAPI *pStgCreatePropStg)(IUnknown *, REFFMTID, const CLSID *, DWORD, DWORD, IPropertyStorage **);
37 static HRESULT (WINAPI *pStgOpenPropStg)(IUnknown *, REFFMTID, DWORD, DWORD, IPropertyStorage **);
38
39 static void init_function_pointers(void)
40 {
41 HMODULE hmod = GetModuleHandleA("ole32.dll");
42 pFmtIdToPropStgName = (void*)GetProcAddress(hmod, "FmtIdToPropStgName");
43 pPropStgNameToFmtId = (void*)GetProcAddress(hmod, "PropStgNameToFmtId");
44 pStgCreatePropSetStg = (void*)GetProcAddress(hmod, "StgCreatePropSetStg");
45 pStgCreatePropStg = (void*)GetProcAddress(hmod, "StgCreatePropStg");
46 pStgOpenPropStg = (void*)GetProcAddress(hmod, "StgOpenPropStg");
47 }
48
49 /* FIXME: this creates an ANSI storage, try to find conditions under which
50 * Unicode translation fails
51 */
52 static void testPropsHelper(IPropertySetStorage **propSetStorage)
53 {
54 static const WCHAR szDot[] = { '.',0 };
55 static const WCHAR szPrefix[] = { 's','t','g',0 };
56 static const WCHAR szSummaryInfo[] = { 5,'S','u','m','m','a','r','y',
57 'I','n','f','o','r','m','a','t','i','o','n',0 };
58 static WCHAR propName[] = { 'p','r','o','p',0 };
59 static char val[] = "l33t auth0r";
60 WCHAR filename[MAX_PATH];
61 HRESULT hr;
62 IStorage *storage = NULL;
63 IStream *stream = NULL;
64 IPropertyStorage *propertyStorage = NULL;
65 PROPSPEC spec;
66 PROPVARIANT var;
67 CLIPDATA clipdata;
68 unsigned char clipcontent[] = "foobar";
69 GUID anyOldGuid = { 0x12345678,0xdead,0xbeef, {
70 0x00,0x01,0x02,0x03,0x04,0x05,0x06,0x07 } };
71
72 if(propSetStorage)
73 trace("Testing property storage with a set...\n");
74 else
75 trace("Testing property storage without a set...\n");
76
77 if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
78 return;
79
80 DeleteFileW(filename);
81
82 hr = StgCreateDocfile(filename,
83 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
84 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
85
86 if(propSetStorage)
87 {
88 if(!pStgCreatePropSetStg)
89 {
90 IStorage_Release(storage);
91 DeleteFileW(filename);
92 return;
93 }
94 hr = pStgCreatePropSetStg(storage, 0, propSetStorage);
95 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
96
97 hr = IPropertySetStorage_Create(*propSetStorage,
98 &FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI,
99 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
100 &propertyStorage);
101 ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
102 }
103 else
104 {
105 hr = IStorage_CreateStream(storage, szSummaryInfo,
106 STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stream);
107 ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
108
109 if(!pStgCreatePropStg)
110 {
111 IStorage_Release(storage);
112 IUnknown_Release(stream);
113 DeleteFileW(filename);
114 return;
115 }
116 hr = pStgCreatePropStg((IUnknown *)stream, &FMTID_SummaryInformation,
117 NULL, PROPSETFLAG_ANSI, 0, &propertyStorage);
118 ok(hr == S_OK, "StgCreatePropStg failed: 0x%08x\n", hr);
119 }
120
121 hr = IPropertyStorage_WriteMultiple(propertyStorage, 0, NULL, NULL, 0);
122 ok(hr == S_OK, "WriteMultiple with 0 args failed: 0x%08x\n", hr);
123 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, NULL, NULL, 0);
124 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
125
126 /* test setting one that I can't set */
127 spec.ulKind = PRSPEC_PROPID;
128 U(spec).propid = PID_DICTIONARY;
129 var.vt = VT_I4;
130 U(var).lVal = 1;
131 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
132 ok(hr == STG_E_INVALIDPARAMETER,
133 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
134
135 /* test setting one by name with an invalid propidNameFirst */
136 spec.ulKind = PRSPEC_LPWSTR;
137 U(spec).lpwstr = propName;
138 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var,
139 PID_DICTIONARY);
140 ok(hr == STG_E_INVALIDPARAMETER,
141 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
142
143 /* test setting behavior (case-sensitive) */
144 spec.ulKind = PRSPEC_PROPID;
145 U(spec).propid = PID_BEHAVIOR;
146 U(var).lVal = 1;
147 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
148 ok(hr == STG_E_INVALIDPARAMETER,
149 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
150
151 /* set one by value.. */
152 spec.ulKind = PRSPEC_PROPID;
153 U(spec).propid = PID_FIRST_USABLE;
154 U(var).lVal = 1;
155 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
156 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
157
158 /* set one by name */
159 spec.ulKind = PRSPEC_LPWSTR;
160 U(spec).lpwstr = propName;
161 U(var).lVal = 2;
162 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var,
163 PID_FIRST_USABLE);
164 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
165
166 /* set a string value */
167 spec.ulKind = PRSPEC_PROPID;
168 U(spec).propid = PIDSI_AUTHOR;
169 var.vt = VT_LPSTR;
170 U(var).pszVal = val;
171 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
172 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
173
174 /* set a clipboard value */
175 spec.ulKind = PRSPEC_PROPID;
176 U(spec).propid = PIDSI_THUMBNAIL;
177 var.vt = VT_CF;
178 clipdata.cbSize = sizeof clipcontent + sizeof (ULONG);
179 clipdata.ulClipFmt = CF_ENHMETAFILE;
180 clipdata.pClipData = clipcontent;
181 U(var).pclipdata = &clipdata;
182 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
183 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
184
185
186 /* check reading */
187 hr = IPropertyStorage_ReadMultiple(propertyStorage, 0, NULL, NULL);
188 ok(hr == S_FALSE, "ReadMultiple with 0 args failed: 0x%08x\n", hr);
189 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, NULL, NULL);
190 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
191 /* read by propid */
192 spec.ulKind = PRSPEC_PROPID;
193 U(spec).propid = PID_FIRST_USABLE;
194 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
195 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
196 ok(var.vt == VT_I4 && U(var).lVal == 1,
197 "Didn't get expected type or value for property (got type %d, value %d)\n",
198 var.vt, U(var).lVal);
199 /* read by name */
200 spec.ulKind = PRSPEC_LPWSTR;
201 U(spec).lpwstr = propName;
202 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
203 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
204 ok(var.vt == VT_I4 && U(var).lVal == 2,
205 "Didn't get expected type or value for property (got type %d, value %d)\n",
206 var.vt, U(var).lVal);
207 /* read string value */
208 spec.ulKind = PRSPEC_PROPID;
209 U(spec).propid = PIDSI_AUTHOR;
210 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
211 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
212 ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val),
213 "Didn't get expected type or value for property (got type %d, value %s)\n",
214 var.vt, U(var).pszVal);
215 PropVariantClear(&var);
216
217 /* read clipboard format */
218 spec.ulKind = PRSPEC_PROPID;
219 U(spec).propid = PIDSI_THUMBNAIL;
220 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
221 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
222 ok(var.vt == VT_CF, "variant type wrong\n");
223 ok(U(var).pclipdata->ulClipFmt == CF_ENHMETAFILE,
224 "clipboard type wrong\n");
225 ok(U(var).pclipdata->cbSize == sizeof clipcontent + sizeof (ULONG),
226 "clipboard size wrong\n");
227 ok(!memcmp(U(var).pclipdata->pClipData, clipcontent, sizeof clipcontent),
228 "clipboard contents wrong\n");
229 ok(S_OK == PropVariantClear(&var), "failed to clear variant\n");
230
231 /* check deleting */
232 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 0, NULL);
233 ok(hr == S_OK, "DeleteMultiple with 0 args failed: 0x%08x\n", hr);
234 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, NULL);
235 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
236 /* contrary to what the docs say, you can't delete the dictionary */
237 spec.ulKind = PRSPEC_PROPID;
238 U(spec).propid = PID_DICTIONARY;
239 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec);
240 ok(hr == STG_E_INVALIDPARAMETER,
241 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
242 /* now delete the first value.. */
243 U(spec).propid = PID_FIRST_USABLE;
244 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec);
245 ok(hr == S_OK, "DeleteMultiple failed: 0x%08x\n", hr);
246 /* and check that it's no longer readable */
247 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
248 ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr);
249
250 hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
251 ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
252
253 /* check reverting */
254 spec.ulKind = PRSPEC_PROPID;
255 U(spec).propid = PID_FIRST_USABLE;
256 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
257 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
258 hr = IPropertyStorage_Revert(propertyStorage);
259 ok(hr == S_OK, "Revert failed: 0x%08x\n", hr);
260 /* now check that it's still not there */
261 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
262 ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr);
263 /* set an integer value again */
264 spec.ulKind = PRSPEC_PROPID;
265 U(spec).propid = PID_FIRST_USABLE;
266 var.vt = VT_I4;
267 U(var).lVal = 1;
268 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
269 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
270 /* commit it */
271 hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
272 ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
273 /* set it to a string value */
274 var.vt = VT_LPSTR;
275 U(var).pszVal = val;
276 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
277 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
278 /* revert it */
279 hr = IPropertyStorage_Revert(propertyStorage);
280 ok(hr == S_OK, "Revert failed: 0x%08x\n", hr);
281 /* Oddly enough, there's no guarantee that a successful revert actually
282 * implies the value wasn't saved. Maybe transactional mode needs to be
283 * used for that?
284 */
285
286 IPropertyStorage_Release(propertyStorage);
287 if(propSetStorage) IPropertySetStorage_Release(*propSetStorage);
288 IStorage_Release(storage);
289 if(stream) IUnknown_Release(stream);
290
291 /* now open it again */
292 hr = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
293 NULL, 0, &storage);
294 ok(hr == S_OK, "StgOpenStorage failed: 0x%08x\n", hr);
295
296 if(propSetStorage)
297 {
298 hr = pStgCreatePropSetStg(storage, 0, propSetStorage);
299 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
300
301 hr = IPropertySetStorage_Open(*propSetStorage, &FMTID_SummaryInformation,
302 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &propertyStorage);
303 ok(hr == S_OK, "IPropertySetStorage_Open failed: 0x%08x\n", hr);
304 }
305 else
306 {
307 hr = IStorage_OpenStream(storage, szSummaryInfo,
308 0, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stream);
309 ok(hr == S_OK, "IStorage_OpenStream failed: 0x%08x\n", hr);
310
311 if(!pStgOpenPropStg)
312 {
313 IStorage_Release(storage);
314 IUnknown_Release(stream);
315 DeleteFileW(filename);
316 return;
317 }
318 hr = pStgOpenPropStg((IUnknown *)stream, &FMTID_SummaryInformation,
319 PROPSETFLAG_DEFAULT, 0, &propertyStorage);
320 ok(hr == S_OK, "StgOpenPropStg failed: 0x%08x\n", hr);
321 }
322
323 /* check properties again */
324 spec.ulKind = PRSPEC_LPWSTR;
325 U(spec).lpwstr = propName;
326 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
327 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
328 ok(var.vt == VT_I4 && U(var).lVal == 2,
329 "Didn't get expected type or value for property (got type %d, value %d)\n",
330 var.vt, U(var).lVal);
331 spec.ulKind = PRSPEC_PROPID;
332 U(spec).propid = PIDSI_AUTHOR;
333 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
334 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
335 ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val),
336 "Didn't get expected type or value for property (got type %d, value %s)\n",
337 var.vt, U(var).pszVal);
338 PropVariantClear(&var);
339
340 IPropertyStorage_Release(propertyStorage);
341 if(propSetStorage) IPropertySetStorage_Release(*propSetStorage);
342 IStorage_Release(storage);
343 if(stream) IUnknown_Release(stream);
344
345 DeleteFileW(filename);
346
347 /* Test creating a property set storage with a random GUID */
348 hr = StgCreateDocfile(filename,
349 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
350 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
351
352 if(propSetStorage)
353 {
354 hr = pStgCreatePropSetStg(storage, 0, propSetStorage);
355 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
356
357 hr = IPropertySetStorage_Create(*propSetStorage,
358 &anyOldGuid, NULL, PROPSETFLAG_ANSI,
359 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
360 &propertyStorage);
361 ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
362 }
363 else
364 {
365 hr = IStorage_CreateStream(storage, szSummaryInfo,
366 STGM_CREATE | STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, 0, &stream);
367 ok(hr == S_OK, "IStorage_CreateStream failed: 0x%08x\n", hr);
368
369 hr = pStgCreatePropStg((IUnknown *)stream, &anyOldGuid, NULL,
370 PROPSETFLAG_DEFAULT, 0, &propertyStorage);
371 ok(hr == S_OK, "StgCreatePropStg failed: 0x%08x\n", hr);
372 }
373
374 spec.ulKind = PRSPEC_PROPID;
375 U(spec).propid = PID_FIRST_USABLE;
376 var.vt = VT_I4;
377 U(var).lVal = 1;
378 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
379 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
380
381 hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
382 ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
383
384 IPropertyStorage_Release(propertyStorage);
385 if(propSetStorage) IPropertySetStorage_Release(*propSetStorage);
386 IStorage_Release(storage);
387 if(stream) IUnknown_Release(stream);
388
389 /* now open it again */
390 hr = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
391 NULL, 0, &storage);
392 ok(hr == S_OK, "StgOpenStorage failed: 0x%08x\n", hr);
393
394 if(propSetStorage)
395 {
396 hr = pStgCreatePropSetStg(storage, 0, propSetStorage);
397 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
398
399 hr = IPropertySetStorage_Open(*propSetStorage, &anyOldGuid,
400 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &propertyStorage);
401 ok(hr == S_OK, "IPropertySetStorage_Open failed: 0x%08x\n", hr);
402 }
403 else
404 {
405 hr = IStorage_OpenStream(storage, szSummaryInfo,
406 0, STGM_READWRITE | STGM_SHARE_EXCLUSIVE, 0, &stream);
407 ok(hr == S_OK, "IStorage_OpenStream failed: 0x%08x\n", hr);
408
409 hr = pStgOpenPropStg((IUnknown *)stream, &anyOldGuid,
410 PROPSETFLAG_DEFAULT, 0, &propertyStorage);
411 ok(hr == S_OK, "StgOpenPropStg failed: 0x%08x\n", hr);
412 }
413
414 spec.ulKind = PRSPEC_PROPID;
415 U(spec).propid = PID_FIRST_USABLE;
416 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
417 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
418
419 ok(var.vt == VT_I4 && U(var).lVal == 1,
420 "Didn't get expected type or value for property (got type %d, value %d)\n",
421 var.vt, U(var).lVal);
422
423 IPropertyStorage_Release(propertyStorage);
424 if(propSetStorage) IPropertySetStorage_Release(*propSetStorage);
425 IStorage_Release(storage);
426 if(stream) IUnknown_Release(stream);
427
428 DeleteFileW(filename);
429 }
430
431 static void testProps(void)
432 {
433 IPropertySetStorage *propSetStorage = NULL;
434
435 testPropsHelper(&propSetStorage);
436 testPropsHelper(NULL);
437 }
438
439 static void testCodepage(void)
440 {
441 static const WCHAR szDot[] = { '.',0 };
442 static const WCHAR szPrefix[] = { 's','t','g',0 };
443 static CHAR aval[] = "hi";
444 static WCHAR wval[] = { 'h','i',0 };
445 HRESULT hr;
446 IStorage *storage = NULL;
447 IPropertySetStorage *propSetStorage = NULL;
448 IPropertyStorage *propertyStorage = NULL;
449 PROPSPEC spec;
450 PROPVARIANT var;
451 WCHAR fileName[MAX_PATH];
452
453 if(!GetTempFileNameW(szDot, szPrefix, 0, fileName))
454 return;
455
456 hr = StgCreateDocfile(fileName,
457 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
458 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
459
460 if(!pStgCreatePropSetStg)
461 {
462 IStorage_Release(storage);
463 DeleteFileW(fileName);
464 return;
465 }
466 hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
467 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
468
469 hr = IPropertySetStorage_Create(propSetStorage,
470 &FMTID_SummaryInformation, NULL, PROPSETFLAG_DEFAULT,
471 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
472 &propertyStorage);
473 ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
474
475 PropVariantInit(&var);
476 spec.ulKind = PRSPEC_PROPID;
477 U(spec).propid = PID_CODEPAGE;
478 /* check code page before it's been explicitly set */
479 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
480 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
481 ok(var.vt == VT_I2 && U(var).iVal == 1200,
482 "Didn't get expected type or value for property\n");
483 /* Set the code page to ascii */
484 var.vt = VT_I2;
485 U(var).iVal = 1252;
486 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
487 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
488 /* check code page */
489 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
490 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
491 ok(var.vt == VT_I2 && U(var).iVal == 1252,
492 "Didn't get expected type or value for property\n");
493 /* Set code page to Unicode */
494 U(var).iVal = 1200;
495 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
496 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
497 /* check code page */
498 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
499 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
500 ok(var.vt == VT_I2 && U(var).iVal == 1200,
501 "Didn't get expected type or value for property\n");
502 /* Set a string value */
503 spec.ulKind = PRSPEC_PROPID;
504 U(spec).propid = PID_FIRST_USABLE;
505 var.vt = VT_LPSTR;
506 U(var).pszVal = aval;
507 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
508 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
509 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
510 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
511 ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "hi"),
512 "Didn't get expected type or value for property\n");
513 PropVariantClear(&var);
514 /* This seemingly non-sensical test is to show that the string is indeed
515 * interpreted according to the current system code page, not according to
516 * the property set's code page. (If the latter were true, the whole
517 * string would be maintained. As it is, only the first character is.)
518 */
519 var.vt = VT_LPSTR;
520 U(var).pszVal = (LPSTR)wval;
521 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
522 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
523 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
524 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
525 ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "h"),
526 "Didn't get expected type or value for property\n");
527 PropVariantClear(&var);
528
529 /* now that a property's been set, you can't change the code page */
530 spec.ulKind = PRSPEC_PROPID;
531 U(spec).propid = PID_CODEPAGE;
532 var.vt = VT_I2;
533 U(var).iVal = 1200;
534 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
535 ok(hr == STG_E_INVALIDPARAMETER,
536 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
537
538 IPropertyStorage_Release(propertyStorage);
539 IPropertySetStorage_Release(propSetStorage);
540 IStorage_Release(storage);
541
542 DeleteFileW(fileName);
543
544 /* same tests, but with PROPSETFLAG_ANSI */
545 hr = StgCreateDocfile(fileName,
546 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
547 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
548
549 hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
550 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
551
552 hr = IPropertySetStorage_Create(propSetStorage,
553 &FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI,
554 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
555 &propertyStorage);
556 ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
557
558 /* check code page before it's been explicitly set */
559 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
560 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
561 ok(var.vt == VT_I2, "Didn't get expected type for property (%u)\n", var.vt);
562 /* Set code page to Unicode */
563 U(var).iVal = 1200;
564 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
565 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
566 /* check code page */
567 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
568 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
569 ok(var.vt == VT_I2 && U(var).iVal == 1200,
570 "Didn't get expected type or value for property\n");
571 /* This test is commented out for documentation. It fails under Wine,
572 * and I expect it would under Windows as well, yet it succeeds. There's
573 * obviously something about string conversion I don't understand.
574 */
575 if(0) {
576 static unsigned char strVal[] = { 0x81, 0xff, 0x04, 0 };
577 /* Set code page to 950 (Traditional Chinese) */
578 U(var).iVal = 950;
579 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
580 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
581 /* Try writing an invalid string: lead byte 0x81 is unused in Traditional
582 * Chinese.
583 */
584 spec.ulKind = PRSPEC_PROPID;
585 U(spec).propid = PID_FIRST_USABLE;
586 var.vt = VT_LPSTR;
587 U(var).pszVal = (LPSTR)strVal;
588 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
589 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
590 /* Check returned string */
591 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
592 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
593 ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, (LPCSTR)strVal),
594 "Didn't get expected type or value for property\n");
595 }
596
597 IPropertyStorage_Release(propertyStorage);
598 IPropertySetStorage_Release(propSetStorage);
599 IStorage_Release(storage);
600
601 DeleteFileW(fileName);
602 }
603
604 static void testFmtId(void)
605 {
606 WCHAR szSummaryInfo[] = { 5,'S','u','m','m','a','r','y',
607 'I','n','f','o','r','m','a','t','i','o','n',0 };
608 WCHAR szDocSummaryInfo[] = { 5,'D','o','c','u','m','e','n','t',
609 'S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',
610 0 };
611 WCHAR szIID_IPropSetStg[] = { 5,'0','j','a','a','a','a','a',
612 'a','A','a','a','a','a','a','d','a','A','a','a','a','a','a','a','a','G',
613 'c',0 };
614 WCHAR name[32];
615 FMTID fmtid;
616 HRESULT hr;
617
618 if (pFmtIdToPropStgName) {
619 hr = pFmtIdToPropStgName(NULL, name);
620 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
621 hr = pFmtIdToPropStgName(&FMTID_SummaryInformation, NULL);
622 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
623 hr = pFmtIdToPropStgName(&FMTID_SummaryInformation, name);
624 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
625 ok(!memcmp(name, szSummaryInfo, (lstrlenW(szSummaryInfo) + 1) *
626 sizeof(WCHAR)), "Got wrong name for FMTID_SummaryInformation\n");
627 hr = pFmtIdToPropStgName(&FMTID_DocSummaryInformation, name);
628 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
629 ok(!memcmp(name, szDocSummaryInfo, (lstrlenW(szDocSummaryInfo) + 1) *
630 sizeof(WCHAR)), "Got wrong name for FMTID_DocSummaryInformation\n");
631 hr = pFmtIdToPropStgName(&FMTID_UserDefinedProperties, name);
632 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
633 ok(!memcmp(name, szDocSummaryInfo, (lstrlenW(szDocSummaryInfo) + 1) *
634 sizeof(WCHAR)), "Got wrong name for FMTID_DocSummaryInformation\n");
635 hr = pFmtIdToPropStgName(&IID_IPropertySetStorage, name);
636 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
637 ok(!memcmp(name, szIID_IPropSetStg, (lstrlenW(szIID_IPropSetStg) + 1) *
638 sizeof(WCHAR)), "Got wrong name for IID_IPropertySetStorage\n");
639 }
640
641 if(pPropStgNameToFmtId) {
642 /* test args first */
643 hr = pPropStgNameToFmtId(NULL, NULL);
644 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
645 hr = pPropStgNameToFmtId(NULL, &fmtid);
646 ok(hr == STG_E_INVALIDNAME, "Expected STG_E_INVALIDNAME, got 0x%08x\n",
647 hr);
648 hr = pPropStgNameToFmtId(szDocSummaryInfo, NULL);
649 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
650 /* test the known format IDs */
651 hr = pPropStgNameToFmtId(szSummaryInfo, &fmtid);
652 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
653 ok(!memcmp(&fmtid, &FMTID_SummaryInformation, sizeof(fmtid)),
654 "Got unexpected FMTID, expected FMTID_SummaryInformation\n");
655 hr = pPropStgNameToFmtId(szDocSummaryInfo, &fmtid);
656 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
657 ok(!memcmp(&fmtid, &FMTID_DocSummaryInformation, sizeof(fmtid)),
658 "Got unexpected FMTID, expected FMTID_DocSummaryInformation\n");
659 /* test another GUID */
660 hr = pPropStgNameToFmtId(szIID_IPropSetStg, &fmtid);
661 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
662 ok(!memcmp(&fmtid, &IID_IPropertySetStorage, sizeof(fmtid)),
663 "Got unexpected FMTID, expected IID_IPropertySetStorage\n");
664 /* now check case matching */
665 CharUpperW(szDocSummaryInfo + 1);
666 hr = pPropStgNameToFmtId(szDocSummaryInfo, &fmtid);
667 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
668 ok(!memcmp(&fmtid, &FMTID_DocSummaryInformation, sizeof(fmtid)),
669 "Got unexpected FMTID, expected FMTID_DocSummaryInformation\n");
670 CharUpperW(szIID_IPropSetStg + 1);
671 hr = pPropStgNameToFmtId(szIID_IPropSetStg, &fmtid);
672 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
673 ok(!memcmp(&fmtid, &IID_IPropertySetStorage, sizeof(fmtid)),
674 "Got unexpected FMTID, expected IID_IPropertySetStorage\n");
675 }
676 }
677
678 START_TEST(stg_prop)
679 {
680 init_function_pointers();
681 testProps();
682 testCodepage();
683 testFmtId();
684 }