[OLE32_WINETEST]
[reactos.git] / 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
37 static void init_function_pointers(void)
38 {
39 HMODULE hmod = GetModuleHandleA("ole32.dll");
40 pFmtIdToPropStgName = (void*)GetProcAddress(hmod, "FmtIdToPropStgName");
41 pPropStgNameToFmtId = (void*)GetProcAddress(hmod, "PropStgNameToFmtId");
42 pStgCreatePropSetStg = (void*)GetProcAddress(hmod, "StgCreatePropSetStg");
43 }
44 /* FIXME: this creates an ANSI storage, try to find conditions under which
45 * Unicode translation fails
46 */
47 static void testProps(void)
48 {
49 static const WCHAR szDot[] = { '.',0 };
50 static const WCHAR szPrefix[] = { 's','t','g',0 };
51 static WCHAR propName[] = { 'p','r','o','p',0 };
52 static char val[] = "l33t auth0r";
53 WCHAR filename[MAX_PATH];
54 HRESULT hr;
55 IStorage *storage = NULL;
56 IPropertySetStorage *propSetStorage = NULL;
57 IPropertyStorage *propertyStorage = NULL;
58 PROPSPEC spec;
59 PROPVARIANT var;
60 CLIPDATA clipdata;
61 unsigned char clipcontent[] = "foobar";
62
63 if(!GetTempFileNameW(szDot, szPrefix, 0, filename))
64 return;
65
66 DeleteFileW(filename);
67
68 hr = StgCreateDocfile(filename,
69 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
70 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
71
72 if(!pStgCreatePropSetStg)
73 {
74 IStorage_Release(storage);
75 DeleteFileW(filename);
76 return;
77 }
78 hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
79 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
80
81 hr = IPropertySetStorage_Create(propSetStorage,
82 &FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI,
83 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
84 &propertyStorage);
85 ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
86
87 hr = IPropertyStorage_WriteMultiple(propertyStorage, 0, NULL, NULL, 0);
88 ok(hr == S_OK, "WriteMultiple with 0 args failed: 0x%08x\n", hr);
89 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, NULL, NULL, 0);
90 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
91
92 /* test setting one that I can't set */
93 spec.ulKind = PRSPEC_PROPID;
94 U(spec).propid = PID_DICTIONARY;
95 var.vt = VT_I4;
96 U(var).lVal = 1;
97 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
98 ok(hr == STG_E_INVALIDPARAMETER,
99 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
100
101 /* test setting one by name with an invalid propidNameFirst */
102 spec.ulKind = PRSPEC_LPWSTR;
103 U(spec).lpwstr = propName;
104 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var,
105 PID_DICTIONARY);
106 ok(hr == STG_E_INVALIDPARAMETER,
107 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
108
109 /* test setting behavior (case-sensitive) */
110 spec.ulKind = PRSPEC_PROPID;
111 U(spec).propid = PID_BEHAVIOR;
112 U(var).lVal = 1;
113 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
114 ok(hr == STG_E_INVALIDPARAMETER,
115 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
116
117 /* set one by value.. */
118 spec.ulKind = PRSPEC_PROPID;
119 U(spec).propid = PID_FIRST_USABLE;
120 U(var).lVal = 1;
121 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
122 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
123
124 /* set one by name */
125 spec.ulKind = PRSPEC_LPWSTR;
126 U(spec).lpwstr = propName;
127 U(var).lVal = 2;
128 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var,
129 PID_FIRST_USABLE);
130 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
131
132 /* set a string value */
133 spec.ulKind = PRSPEC_PROPID;
134 U(spec).propid = PIDSI_AUTHOR;
135 var.vt = VT_LPSTR;
136 U(var).pszVal = val;
137 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
138 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
139
140 /* set a clipboard value */
141 spec.ulKind = PRSPEC_PROPID;
142 U(spec).propid = PIDSI_THUMBNAIL;
143 var.vt = VT_CF;
144 clipdata.cbSize = sizeof clipcontent + sizeof (ULONG);
145 clipdata.ulClipFmt = CF_ENHMETAFILE;
146 clipdata.pClipData = clipcontent;
147 U(var).pclipdata = &clipdata;
148 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
149 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
150
151
152 /* check reading */
153 hr = IPropertyStorage_ReadMultiple(propertyStorage, 0, NULL, NULL);
154 ok(hr == S_FALSE, "ReadMultiple with 0 args failed: 0x%08x\n", hr);
155 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, NULL, NULL);
156 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
157 /* read by propid */
158 spec.ulKind = PRSPEC_PROPID;
159 U(spec).propid = PID_FIRST_USABLE;
160 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
161 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
162 ok(var.vt == VT_I4 && U(var).lVal == 1,
163 "Didn't get expected type or value for property (got type %d, value %d)\n",
164 var.vt, U(var).lVal);
165 /* read by name */
166 spec.ulKind = PRSPEC_LPWSTR;
167 U(spec).lpwstr = propName;
168 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
169 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
170 ok(var.vt == VT_I4 && U(var).lVal == 2,
171 "Didn't get expected type or value for property (got type %d, value %d)\n",
172 var.vt, U(var).lVal);
173 /* read string value */
174 spec.ulKind = PRSPEC_PROPID;
175 U(spec).propid = PIDSI_AUTHOR;
176 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
177 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
178 ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val),
179 "Didn't get expected type or value for property (got type %d, value %s)\n",
180 var.vt, U(var).pszVal);
181 PropVariantClear(&var);
182
183 /* read clipboard format */
184 spec.ulKind = PRSPEC_PROPID;
185 U(spec).propid = PIDSI_THUMBNAIL;
186 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
187 ok(SUCCEEDED(hr), "ReadMultiple failed: 0x%08x\n", hr);
188 ok(var.vt == VT_CF, "variant type wrong\n");
189 ok(U(var).pclipdata->ulClipFmt == CF_ENHMETAFILE,
190 "clipboard type wrong\n");
191 ok(U(var).pclipdata->cbSize == sizeof clipcontent + sizeof (ULONG),
192 "clipboard size wrong\n");
193 ok(!memcmp(U(var).pclipdata->pClipData, clipcontent, sizeof clipcontent),
194 "clipboard contents wrong\n");
195 ok(S_OK == PropVariantClear(&var), "failed to clear variant\n");
196
197 /* check deleting */
198 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 0, NULL);
199 ok(hr == S_OK, "DeleteMultiple with 0 args failed: 0x%08x\n", hr);
200 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, NULL);
201 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
202 /* contrary to what the docs say, you can't delete the dictionary */
203 spec.ulKind = PRSPEC_PROPID;
204 U(spec).propid = PID_DICTIONARY;
205 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec);
206 ok(hr == STG_E_INVALIDPARAMETER,
207 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
208 /* now delete the first value.. */
209 U(spec).propid = PID_FIRST_USABLE;
210 hr = IPropertyStorage_DeleteMultiple(propertyStorage, 1, &spec);
211 ok(hr == S_OK, "DeleteMultiple failed: 0x%08x\n", hr);
212 /* and check that it's no longer readable */
213 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
214 ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr);
215
216 hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
217 ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
218
219 /* check reverting */
220 spec.ulKind = PRSPEC_PROPID;
221 U(spec).propid = PID_FIRST_USABLE;
222 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
223 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
224 hr = IPropertyStorage_Revert(propertyStorage);
225 ok(hr == S_OK, "Revert failed: 0x%08x\n", hr);
226 /* now check that it's still not there */
227 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
228 ok(hr == S_FALSE, "Expected S_FALSE, got 0x%08x\n", hr);
229 /* set an integer value again */
230 spec.ulKind = PRSPEC_PROPID;
231 U(spec).propid = PID_FIRST_USABLE;
232 var.vt = VT_I4;
233 U(var).lVal = 1;
234 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
235 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
236 /* commit it */
237 hr = IPropertyStorage_Commit(propertyStorage, STGC_DEFAULT);
238 ok(hr == S_OK, "Commit failed: 0x%08x\n", hr);
239 /* set it to a string value */
240 var.vt = VT_LPSTR;
241 U(var).pszVal = val;
242 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
243 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
244 /* revert it */
245 hr = IPropertyStorage_Revert(propertyStorage);
246 ok(hr == S_OK, "Revert failed: 0x%08x\n", hr);
247 /* Oddly enough, there's no guarantee that a successful revert actually
248 * implies the value wasn't saved. Maybe transactional mode needs to be
249 * used for that?
250 */
251
252 IPropertyStorage_Release(propertyStorage);
253 propertyStorage = NULL;
254 IPropertySetStorage_Release(propSetStorage);
255 propSetStorage = NULL;
256 IStorage_Release(storage);
257 storage = NULL;
258
259 /* now open it again */
260 hr = StgOpenStorage(filename, NULL, STGM_READWRITE | STGM_SHARE_EXCLUSIVE,
261 NULL, 0, &storage);
262 ok(hr == S_OK, "StgOpenStorage failed: 0x%08x\n", hr);
263
264 hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
265 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
266
267 hr = IPropertySetStorage_Open(propSetStorage, &FMTID_SummaryInformation,
268 STGM_READWRITE | STGM_SHARE_EXCLUSIVE, &propertyStorage);
269 ok(hr == S_OK, "IPropertySetStorage_Open failed: 0x%08x\n", hr);
270
271 /* check properties again */
272 spec.ulKind = PRSPEC_LPWSTR;
273 U(spec).lpwstr = propName;
274 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
275 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
276 ok(var.vt == VT_I4 && U(var).lVal == 2,
277 "Didn't get expected type or value for property (got type %d, value %d)\n",
278 var.vt, U(var).lVal);
279 spec.ulKind = PRSPEC_PROPID;
280 U(spec).propid = PIDSI_AUTHOR;
281 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
282 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
283 ok(var.vt == VT_LPSTR && !lstrcmpA(U(var).pszVal, val),
284 "Didn't get expected type or value for property (got type %d, value %s)\n",
285 var.vt, U(var).pszVal);
286 PropVariantClear(&var);
287
288 IPropertyStorage_Release(propertyStorage);
289 IPropertySetStorage_Release(propSetStorage);
290 IStorage_Release(storage);
291
292 DeleteFileW(filename);
293 }
294
295 static void testCodepage(void)
296 {
297 static const WCHAR szDot[] = { '.',0 };
298 static const WCHAR szPrefix[] = { 's','t','g',0 };
299 static CHAR aval[] = "hi";
300 static WCHAR wval[] = { 'h','i',0 };
301 HRESULT hr;
302 IStorage *storage = NULL;
303 IPropertySetStorage *propSetStorage = NULL;
304 IPropertyStorage *propertyStorage = NULL;
305 PROPSPEC spec;
306 PROPVARIANT var;
307 WCHAR fileName[MAX_PATH];
308
309 if(!GetTempFileNameW(szDot, szPrefix, 0, fileName))
310 return;
311
312 hr = StgCreateDocfile(fileName,
313 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
314 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
315
316 if(!pStgCreatePropSetStg)
317 {
318 IStorage_Release(storage);
319 DeleteFileW(fileName);
320 return;
321 }
322 hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
323 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
324
325 hr = IPropertySetStorage_Create(propSetStorage,
326 &FMTID_SummaryInformation, NULL, PROPSETFLAG_DEFAULT,
327 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
328 &propertyStorage);
329 ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
330
331 PropVariantInit(&var);
332 spec.ulKind = PRSPEC_PROPID;
333 U(spec).propid = PID_CODEPAGE;
334 /* check code page before it's been explicitly set */
335 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
336 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
337 ok(var.vt == VT_I2 && U(var).iVal == 1200,
338 "Didn't get expected type or value for property\n");
339 /* Set the code page to ascii */
340 var.vt = VT_I2;
341 U(var).iVal = 1252;
342 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
343 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
344 /* check code page */
345 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
346 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
347 ok(var.vt == VT_I2 && U(var).iVal == 1252,
348 "Didn't get expected type or value for property\n");
349 /* Set code page to Unicode */
350 U(var).iVal = 1200;
351 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
352 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
353 /* check code page */
354 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
355 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
356 ok(var.vt == VT_I2 && U(var).iVal == 1200,
357 "Didn't get expected type or value for property\n");
358 /* Set a string value */
359 spec.ulKind = PRSPEC_PROPID;
360 U(spec).propid = PID_FIRST_USABLE;
361 var.vt = VT_LPSTR;
362 U(var).pszVal = aval;
363 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
364 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
365 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
366 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
367 ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "hi"),
368 "Didn't get expected type or value for property\n");
369 PropVariantClear(&var);
370 /* This seemingly non-sensical test is to show that the string is indeed
371 * interpreted according to the current system code page, not according to
372 * the property set's code page. (If the latter were true, the whole
373 * string would be maintained. As it is, only the first character is.)
374 */
375 var.vt = VT_LPSTR;
376 U(var).pszVal = (LPSTR)wval;
377 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
378 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
379 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
380 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
381 ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, "h"),
382 "Didn't get expected type or value for property\n");
383 PropVariantClear(&var);
384
385 /* now that a property's been set, you can't change the code page */
386 spec.ulKind = PRSPEC_PROPID;
387 U(spec).propid = PID_CODEPAGE;
388 var.vt = VT_I2;
389 U(var).iVal = 1200;
390 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
391 ok(hr == STG_E_INVALIDPARAMETER,
392 "Expected STG_E_INVALIDPARAMETER, got 0x%08x\n", hr);
393
394 IPropertyStorage_Release(propertyStorage);
395 IPropertySetStorage_Release(propSetStorage);
396 IStorage_Release(storage);
397
398 DeleteFileW(fileName);
399
400 /* same tests, but with PROPSETFLAG_ANSI */
401 hr = StgCreateDocfile(fileName,
402 STGM_READWRITE | STGM_SHARE_EXCLUSIVE | STGM_CREATE, 0, &storage);
403 ok(hr == S_OK, "StgCreateDocfile failed: 0x%08x\n", hr);
404
405 hr = pStgCreatePropSetStg(storage, 0, &propSetStorage);
406 ok(hr == S_OK, "StgCreatePropSetStg failed: 0x%08x\n", hr);
407
408 hr = IPropertySetStorage_Create(propSetStorage,
409 &FMTID_SummaryInformation, NULL, PROPSETFLAG_ANSI,
410 STGM_READWRITE | STGM_CREATE | STGM_SHARE_EXCLUSIVE,
411 &propertyStorage);
412 ok(hr == S_OK, "IPropertySetStorage_Create failed: 0x%08x\n", hr);
413
414 /* check code page before it's been explicitly set */
415 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
416 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
417 ok(var.vt == VT_I2, "Didn't get expected type for property (%u)\n", var.vt);
418 /* Set code page to Unicode */
419 U(var).iVal = 1200;
420 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
421 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
422 /* check code page */
423 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
424 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
425 ok(var.vt == VT_I2 && U(var).iVal == 1200,
426 "Didn't get expected type or value for property\n");
427 /* This test is commented out for documentation. It fails under Wine,
428 * and I expect it would under Windows as well, yet it succeeds. There's
429 * obviously something about string conversion I don't understand.
430 */
431 if(0) {
432 static unsigned char strVal[] = { 0x81, 0xff, 0x04, 0 };
433 /* Set code page to 950 (Traditional Chinese) */
434 U(var).iVal = 950;
435 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
436 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
437 /* Try writing an invalid string: lead byte 0x81 is unused in Traditional
438 * Chinese.
439 */
440 spec.ulKind = PRSPEC_PROPID;
441 U(spec).propid = PID_FIRST_USABLE;
442 var.vt = VT_LPSTR;
443 U(var).pszVal = (LPSTR)strVal;
444 hr = IPropertyStorage_WriteMultiple(propertyStorage, 1, &spec, &var, 0);
445 ok(hr == S_OK, "WriteMultiple failed: 0x%08x\n", hr);
446 /* Check returned string */
447 hr = IPropertyStorage_ReadMultiple(propertyStorage, 1, &spec, &var);
448 ok(hr == S_OK, "ReadMultiple failed: 0x%08x\n", hr);
449 ok(var.vt == VT_LPSTR && !strcmp(U(var).pszVal, (LPCSTR)strVal),
450 "Didn't get expected type or value for property\n");
451 }
452
453 IPropertyStorage_Release(propertyStorage);
454 IPropertySetStorage_Release(propSetStorage);
455 IStorage_Release(storage);
456
457 DeleteFileW(fileName);
458 }
459
460 static void testFmtId(void)
461 {
462 WCHAR szSummaryInfo[] = { 5,'S','u','m','m','a','r','y',
463 'I','n','f','o','r','m','a','t','i','o','n',0 };
464 WCHAR szDocSummaryInfo[] = { 5,'D','o','c','u','m','e','n','t',
465 'S','u','m','m','a','r','y','I','n','f','o','r','m','a','t','i','o','n',
466 0 };
467 WCHAR szIID_IPropSetStg[] = { 5,'0','j','a','a','a','a','a',
468 'a','A','a','a','a','a','a','d','a','A','a','a','a','a','a','a','a','G',
469 'c',0 };
470 WCHAR name[32];
471 FMTID fmtid;
472 HRESULT hr;
473
474 if (pFmtIdToPropStgName) {
475 hr = pFmtIdToPropStgName(NULL, name);
476 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
477 hr = pFmtIdToPropStgName(&FMTID_SummaryInformation, NULL);
478 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
479 hr = pFmtIdToPropStgName(&FMTID_SummaryInformation, name);
480 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
481 ok(!memcmp(name, szSummaryInfo, (lstrlenW(szSummaryInfo) + 1) *
482 sizeof(WCHAR)), "Got wrong name for FMTID_SummaryInformation\n");
483 hr = pFmtIdToPropStgName(&FMTID_DocSummaryInformation, name);
484 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
485 ok(!memcmp(name, szDocSummaryInfo, (lstrlenW(szDocSummaryInfo) + 1) *
486 sizeof(WCHAR)), "Got wrong name for FMTID_DocSummaryInformation\n");
487 hr = pFmtIdToPropStgName(&FMTID_UserDefinedProperties, name);
488 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
489 ok(!memcmp(name, szDocSummaryInfo, (lstrlenW(szDocSummaryInfo) + 1) *
490 sizeof(WCHAR)), "Got wrong name for FMTID_DocSummaryInformation\n");
491 hr = pFmtIdToPropStgName(&IID_IPropertySetStorage, name);
492 ok(hr == S_OK, "FmtIdToPropStgName failed: 0x%08x\n", hr);
493 ok(!memcmp(name, szIID_IPropSetStg, (lstrlenW(szIID_IPropSetStg) + 1) *
494 sizeof(WCHAR)), "Got wrong name for IID_IPropertySetStorage\n");
495 }
496
497 if(pPropStgNameToFmtId) {
498 /* test args first */
499 hr = pPropStgNameToFmtId(NULL, NULL);
500 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
501 hr = pPropStgNameToFmtId(NULL, &fmtid);
502 ok(hr == STG_E_INVALIDNAME, "Expected STG_E_INVALIDNAME, got 0x%08x\n",
503 hr);
504 hr = pPropStgNameToFmtId(szDocSummaryInfo, NULL);
505 ok(hr == E_INVALIDARG, "Expected E_INVALIDARG, got 0x%08x\n", hr);
506 /* test the known format IDs */
507 hr = pPropStgNameToFmtId(szSummaryInfo, &fmtid);
508 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
509 ok(!memcmp(&fmtid, &FMTID_SummaryInformation, sizeof(fmtid)),
510 "Got unexpected FMTID, expected FMTID_SummaryInformation\n");
511 hr = pPropStgNameToFmtId(szDocSummaryInfo, &fmtid);
512 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
513 ok(!memcmp(&fmtid, &FMTID_DocSummaryInformation, sizeof(fmtid)),
514 "Got unexpected FMTID, expected FMTID_DocSummaryInformation\n");
515 /* test another GUID */
516 hr = pPropStgNameToFmtId(szIID_IPropSetStg, &fmtid);
517 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
518 ok(!memcmp(&fmtid, &IID_IPropertySetStorage, sizeof(fmtid)),
519 "Got unexpected FMTID, expected IID_IPropertySetStorage\n");
520 /* now check case matching */
521 CharUpperW(szDocSummaryInfo + 1);
522 hr = pPropStgNameToFmtId(szDocSummaryInfo, &fmtid);
523 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
524 ok(!memcmp(&fmtid, &FMTID_DocSummaryInformation, sizeof(fmtid)),
525 "Got unexpected FMTID, expected FMTID_DocSummaryInformation\n");
526 CharUpperW(szIID_IPropSetStg + 1);
527 hr = pPropStgNameToFmtId(szIID_IPropSetStg, &fmtid);
528 ok(hr == S_OK, "PropStgNameToFmtId failed: 0x%08x\n", hr);
529 ok(!memcmp(&fmtid, &IID_IPropertySetStorage, sizeof(fmtid)),
530 "Got unexpected FMTID, expected IID_IPropertySetStorage\n");
531 }
532 }
533
534 START_TEST(stg_prop)
535 {
536 init_function_pointers();
537 testProps();
538 testCodepage();
539 testFmtId();
540 }