projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
sync mlang winetest with wine 1.1.27
[reactos.git] / rostests / winetests / mlang / mlang.c
1 /*
2 * Unit test suite for MLANG APIs.
3 *
4 * Copyright 2004 Dmitry Timoshkov
5 * Copyright 2009 Detlef Riekenberg
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 */
21
22 #define COBJMACROS
23
24 #include <stdarg.h>
25 #include <stdio.h>
26
27 #include "windef.h"
28 #include "winbase.h"
29 #include "winerror.h"
30 #include "initguid.h"
31 #include "mlang.h"
32
33 #include "wine/test.h"
34
35 #ifndef CP_UNICODE
36 #define CP_UNICODE 1200
37 #endif
38
39 #if 0
40 #define DUMP_CP_INFO
41 #define DUMP_SCRIPT_INFO
42
43 #if defined DUMP_CP_INFO || defined DUMP_SCRIPT_INFO
44 #include "wine/debug.h"
45 #endif
46 #endif /* 0 */
47
48 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
49 static HRESULT (WINAPI *pConvertINetMultiByteToUnicode)(LPDWORD, DWORD, LPCSTR,
50 LPINT, LPWSTR, LPINT);
51 static HRESULT (WINAPI *pConvertINetUnicodeToMultiByte)(LPDWORD, DWORD, LPCWSTR,
52 LPINT, LPSTR, LPINT);
53 static HRESULT (WINAPI *pRfc1766ToLcidA)(LCID *, LPCSTR);
54 static HRESULT (WINAPI *pLcidToRfc1766A)(LCID, LPSTR, INT);
55
56 typedef struct lcid_tag_table {
57 LPCSTR rfc1766;
58 LCID lcid;
59 HRESULT hr;
60 LCID broken_lcid;
61 LPCSTR broken_rfc;
62 } lcid_table_entry;
63
64 /* en, ar and zh use SUBLANG_NEUTRAL for the rfc1766 name without the country
65 all others suppress the country with SUBLANG_DEFAULT.
66 For 3 letter language codes, the rfc1766 is too small for the country */
67
68 static const lcid_table_entry lcid_table[] = {
69 {"e", -1, E_FAIL},
70 {"", -1, E_FAIL},
71 {"-", -1, E_FAIL},
72 {"e-", -1, E_FAIL},
73
74 {"ar", 1, S_OK},
75 {"zh", 4, S_OK},
76
77 {"de", 0x0407, S_OK},
78 {"de-ch", 0x0807, S_OK},
79 {"de-at", 0x0c07, S_OK},
80 {"de-lu", 0x1007, S_OK},
81 {"de-li", 0x1407, S_OK},
82
83 {"en", 9, S_OK},
84 {"en-gb", 0x809, S_OK},
85 {"en-GB", 0x809, S_OK},
86 {"EN-GB", 0x809, S_OK},
87 {"en-US", 0x409, S_OK},
88 {"en-us", 0x409, S_OK},
89
90 {"fr", 0x040c, S_OK},
91 {"fr-be", 0x080c, S_OK},
92 {"fr-ca", 0x0c0c, S_OK},
93 {"fr-ch", 0x100c, S_OK},
94 {"fr-lu", 0x140c, S_OK},
95 {"fr-mc", 0x180c, S_OK, 0x040c, "fr"},
96
97 {"it", 0x0410, S_OK},
98 {"it-ch", 0x0810, S_OK},
99
100 {"nl", 0x0413, S_OK},
101 {"nl-be", 0x0813, S_OK},
102 {"pl", 0x0415, S_OK},
103 {"ru", 0x0419, S_OK},
104
105 {"kok", 0x0457, S_OK, 0x0412, "x-kok"}
106
107 };
108
109 #define TODO_NAME 1
110
111 typedef struct info_table_tag {
112 LCID lcid;
113 LANGID lang;
114 DWORD todo;
115 LPCSTR rfc1766;
116 LPCWSTR localename;
117 LPCWSTR broken_name;
118 } info_table_entry;
119
120 static const WCHAR de_en[] = {'E','n','g','l','i','s','c','h',0};
121 static const WCHAR de_enca[] = {'E','n','g','l','i','s','c','h',' ',
122 '(','K','a','n','a','d','a',')',0};
123 static const WCHAR de_engb[] = {'E','n','g','l','i','s','c','h',' ',
124 '(','G','r','o',0xDF,'b','r','i','t','a','n','n','i','e','n',')',0};
125 static const WCHAR de_engb2[] ={'E','n','g','l','i','s','c','h',' ',
126 '(','V','e','r','e','i','n','i','g','t','e','s',' ',
127 'K',0xF6,'n','i','g','r','e','i','c',0};
128 static const WCHAR de_enus[] = {'E','n','g','l','i','s','c','h',' ',
129 '(','U','S','A',')',0};
130 static const WCHAR de_de[] = {'D','e','u','t','s','c','h',' ',
131 '(','D','e','u','t','s','c','h','l','a','n','d',')',0};
132 static const WCHAR de_deat[] = {'D','e','u','t','s','c','h',' ',
133 '(',0xD6,'s','t','e','r','r','e','i','c','h',')',0};
134 static const WCHAR de_dech[] = {'D','e','u','t','s','c','h',' ',
135 '(','S','c','h','w','e','i','z',')',0};
136
137 static const WCHAR en_en[] = {'E','n','g','l','i','s','h',0};
138 static const WCHAR en_enca[] = {'E','n','g','l','i','s','h',' ',
139 '(','C','a','n','a','d','a',')',0};
140 static const WCHAR en_engb[] = {'E','n','g','l','i','s','h',' ',
141 '(','U','n','i','t','e','d',' ','K','i','n','g','d','o','m',')',0};
142 static const WCHAR en_enus[] = {'E','n','g','l','i','s','h',' ',
143 '(','U','n','i','t','e','d',' ','S','t','a','t','e','s',')',0};
144 static const WCHAR en_de[] = {'G','e','r','m','a','n',' ',
145 '(','G','e','r','m','a','n','y',')',0};
146 static const WCHAR en_deat[] = {'G','e','r','m','a','n',' ',
147 '(','A','u','s','t','r','i','a',')',0};
148 static const WCHAR en_dech[] = {'G','e','r','m','a','n',' ',
149 '(','S','w','i','t','z','e','r','l','a','n','d',')',0};
150
151 static const WCHAR fr_en[] = {'A','n','g','l','a','i','s',0};
152 static const WCHAR fr_enca[] = {'A','n','g','l','a','i','s',' ',
153 '(','C','a','n','a','d','a',')',0};
154 static const WCHAR fr_engb[] = {'A','n','g','l','a','i','s',' ',
155 '(','R','o','y','a','u','m','e','-','U','n','i',')',0};
156 static const WCHAR fr_enus[] = {'A','n','g','l','a','i','s',' ',
157 '(',0xC9, 't','a','t','s','-','U','n','i','s',')',0};
158 static const WCHAR fr_enus2[] ={'A','n','g','l','a','i','s',' ',
159 '(','U','.','S','.',')',0};
160 static const WCHAR fr_de[] = {'A','l','l','e','m','a','n','d',' ',
161 '(','A','l','l','e','m','a','g','n','e',')',0};
162 static const WCHAR fr_de2[] = {'A','l','l','e','m','a','n','d',' ',
163 '(','S','t','a','n','d','a','r','d',')',0};
164 static const WCHAR fr_deat[] = {'A','l','l','e','m','a','n','d',' ',
165 '(','A','u','t','r','i','c','h','e',')',0};
166 static const WCHAR fr_dech[] = {'A','l','l','e','m','a','n','d',' ',
167 '(','S','u','i','s','s','e',')',0};
168
169 static const info_table_entry info_table[] = {
170 {MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
171 0, "en", en_en},
172 {MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
173 0, "en-us", en_enus},
174 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_UK), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
175 0, "en-gb", en_engb},
176 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
177 0, "en-us", en_enus},
178 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_CAN), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
179 0, "en-ca", en_enca},
180
181 {MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
182 0, "de", en_de},
183 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
184 0, "de", en_de},
185 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_SWISS), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
186 0, "de-ch", en_dech},
187 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_AUSTRIAN), MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL),
188 0, "de-at", en_deat},
189
190 {MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
191 TODO_NAME, "en", de_en},
192 {MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
193 TODO_NAME, "en-us", de_enus},
194 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_UK), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
195 TODO_NAME, "en-gb", de_engb, de_engb2},
196 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
197 TODO_NAME, "en-us", de_enus},
198 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_CAN), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
199 TODO_NAME, "en-ca", de_enca},
200
201 {MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
202 TODO_NAME, "de", de_de},
203 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
204 TODO_NAME, "de",de_de},
205 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_SWISS), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
206 TODO_NAME, "de-ch", de_dech},
207 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_AUSTRIAN), MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT),
208 TODO_NAME, "de-at", de_deat},
209
210 {MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
211 TODO_NAME, "en", fr_en},
212 {MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
213 TODO_NAME, "en-us", fr_enus, fr_enus2},
214 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_UK), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
215 TODO_NAME, "en-gb", fr_engb},
216 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
217 TODO_NAME, "en-us", fr_enus, fr_enus2},
218 {MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_CAN), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
219 TODO_NAME, "en-ca", fr_enca},
220
221 {MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
222 TODO_NAME, "de", fr_de, fr_de2},
223 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
224 TODO_NAME, "de", fr_de, fr_de2},
225 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_SWISS), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
226 TODO_NAME, "de-ch", fr_dech},
227 {MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN_AUSTRIAN), MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT),
228 TODO_NAME, "de-at", fr_deat}
229
230 };
231
232 static BOOL init_function_ptrs(void)
233 {
234 HMODULE hMlang;
235
236 hMlang = LoadLibraryA("mlang.dll");
237 if (!hMlang)
238 {
239 skip("mlang not available\n");
240 return FALSE;
241 }
242
243 pConvertINetMultiByteToUnicode = (void *)GetProcAddress(hMlang, "ConvertINetMultiByteToUnicode");
244 pConvertINetUnicodeToMultiByte = (void *)GetProcAddress(hMlang, "ConvertINetUnicodeToMultiByte");
245 pRfc1766ToLcidA = (void *)GetProcAddress(hMlang, "Rfc1766ToLcidA");
246 pLcidToRfc1766A = (void *)GetProcAddress(hMlang, "LcidToRfc1766A");
247
248 pGetCPInfoExA = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetCPInfoExA");
249
250 return TRUE;
251 }
252
253 #define ok_w2(format, szString1, szString2) \
254 \
255 if (lstrcmpW((szString1), (szString2)) != 0) \
256 { \
257 CHAR string1[256], string2[256]; \
258 WideCharToMultiByte(CP_ACP, 0, (szString1), -1, string1, 256, NULL, NULL); \
259 WideCharToMultiByte(CP_ACP, 0, (szString2), -1, string2, 256, NULL, NULL); \
260 ok(0, (format), string1, string2); \
261 }
262
263 /* lstrcmpW is not supported on Win9x! */
264 static int mylstrcmpW(const WCHAR* str1, const WCHAR* str2)
265 {
266 if (!str2) return 1;
267 while (*str1 && *str1==*str2) {
268 str1++;
269 str2++;
270 }
271 return *str1-*str2;
272 }
273
274 /* lstrcpyW is not supported on Win95 */
275 static void mylstrcpyW(WCHAR* str1, const WCHAR* str2)
276 {
277 while (str2 && *str2) {
278 *str1 = *str2;
279 str1++;
280 str2++;
281 }
282 *str1 = '\0';
283 }
284
285 #define DEBUGSTR_W_MAXLEN 64
286
287 static CHAR * debugstr_w(const WCHAR * strW)
288 {
289 static CHAR buffers[DEBUGSTR_W_MAXLEN * 2];
290 static DWORD pos = 0;
291 CHAR * strA;
292 DWORD len = DEBUGSTR_W_MAXLEN - 4;
293
294 strA = &buffers[pos];
295
296 *strA++ = 'L';
297 *strA++ = '"';
298
299 while (*strW && (len > 4)) {
300 if ((*strW < ' ') || (*strW > 126)) {
301 sprintf(strA, "\\%04x", *strW);
302 strA +=5;
303 len -=5;
304 }
305 else
306 {
307 *strA++ = *strW;
308 len--;
309 }
310 strW++;
311 }
312 *strA++ = '"';
313 *strA = '\0';
314
315 strA = &buffers[pos];
316 pos += DEBUGSTR_W_MAXLEN;
317 if (pos >= sizeof(buffers)) pos = 0;
318
319 return strA;
320
321 }
322
323 static void test_multibyte_to_unicode_translations(IMultiLanguage2 *iML2)
324 {
325 /* these APIs are broken regarding constness of the input buffer */
326 char stringA[] = "Just a test string\0"; /* double 0 for CP_UNICODE tests */
327 WCHAR stringW[] = {'J','u','s','t',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
328 char bufA[256];
329 WCHAR bufW[256];
330 UINT lenA, lenW, expected_len;
331 HRESULT ret;
332
333 /* IMultiLanguage2_ConvertStringToUnicode tests */
334
335 memset(bufW, 'x', sizeof(bufW));
336 lenA = 0;
337 lenW = sizeof(bufW)/sizeof(bufW[0]);
338 ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, bufW, &lenW);
339 ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
340 ok(lenA == 0, "expected lenA 0, got %u\n", lenA);
341 ok(lenW == 0, "expected lenW 0, got %u\n", lenW);
342
343 memset(bufW, 'x', sizeof(bufW));
344 lenA = -1;
345 lenW = sizeof(bufW)/sizeof(bufW[0]);
346 ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, bufW, &lenW);
347 ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
348 ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
349 ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
350 if (lenW < sizeof(bufW)/sizeof(bufW[0])) {
351 /* can only happen if the convert call fails */
352 ok(bufW[lenW] != 0, "buf should not be 0 terminated\n");
353 bufW[lenW] = 0; /* -1 doesn't include 0 terminator */
354 }
355 ok(!lstrcmpW(bufW, stringW), "bufW/stringW mismatch\n");
356
357 memset(bufW, 'x', sizeof(bufW));
358 lenA = -1;
359 lenW = 5;
360 ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, bufW, &lenW);
361 ok(ret == E_FAIL, "IMultiLanguage2_ConvertStringToUnicode should fail: %08x\n", ret);
362 ok(lenW == 0, "expected lenW 0, got %u\n", lenW);
363 /* still has to do partial conversion */
364 ok(!memcmp(bufW, stringW, 5 * sizeof(WCHAR)), "bufW/stringW mismatch\n");
365
366 memset(bufW, 'x', sizeof(bufW));
367 lenA = -1;
368 lenW = sizeof(bufW)/sizeof(bufW[0]);
369 ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, CP_UNICODE, stringA, &lenA, bufW, &lenW);
370 ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
371 ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
372 ok(lenW == lstrlenW(stringW)/(int)sizeof(WCHAR), "wrong lenW %u\n", lenW);
373 ok(bufW[lenW] != 0, "buf should not be 0 terminated\n");
374 bufW[lenW] = 0; /* -1 doesn't include 0 terminator */
375 ok(!lstrcmpA((LPCSTR)bufW, stringA), "bufW/stringA mismatch\n");
376
377 memset(bufW, 'x', sizeof(bufW));
378 lenA = lstrlenA(stringA);
379 lenW = 0;
380 ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, NULL, &lenW);
381 ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
382 ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
383 expected_len = MultiByteToWideChar(1252, 0, stringA, lenA, NULL, 0);
384 ok(lenW == expected_len, "expected lenW %u, got %u\n", expected_len, lenW);
385
386 memset(bufW, 'x', sizeof(bufW));
387 lenA = lstrlenA(stringA);
388 lenW = sizeof(bufW)/sizeof(bufW[0]);
389 ret = pConvertINetMultiByteToUnicode(NULL, 1252, stringA, (INT *)&lenA, NULL, (INT *)&lenW);
390 ok(ret == S_OK, "ConvertINetMultiByteToUnicode failed: %08x\n", ret);
391 ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
392 expected_len = MultiByteToWideChar(1252, 0, stringA, lenA, NULL, 0);
393 ok(lenW == expected_len, "expected lenW %u, got %u\n", expected_len, lenW);
394
395 memset(bufW, 'x', sizeof(bufW));
396 lenA = lstrlenA(stringA);
397 lenW = 0;
398 ret = pConvertINetMultiByteToUnicode(NULL, 1252, stringA, (INT *)&lenA, NULL, (INT *)&lenW);
399 ok(ret == S_OK, "ConvertINetMultiByteToUnicode failed: %08x\n", ret);
400 ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
401 expected_len = MultiByteToWideChar(1252, 0, stringA, lenA, NULL, 0);
402 ok(lenW == expected_len, "expected lenW %u, got %u\n", expected_len, lenW);
403
404 /* IMultiLanguage2_ConvertStringFromUnicode tests */
405
406 memset(bufA, 'x', sizeof(bufA));
407 lenW = 0;
408 lenA = sizeof(bufA);
409 ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, bufA, &lenA);
410 ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
411 ok(lenA == 0, "expected lenA 0, got %u\n", lenA);
412 ok(lenW == 0, "expected lenW 0, got %u\n", lenW);
413
414 memset(bufA, 'x', sizeof(bufA));
415 lenW = -1;
416 lenA = sizeof(bufA);
417 ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, bufA, &lenA);
418 ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
419 ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
420 ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
421 ok(bufA[lenA] != 0, "buf should not be 0 terminated\n");
422 bufA[lenA] = 0; /* -1 doesn't include 0 terminator */
423 ok(!lstrcmpA(bufA, stringA), "bufA/stringA mismatch\n");
424
425 memset(bufA, 'x', sizeof(bufA));
426 lenW = -1;
427 lenA = 5;
428 ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, bufA, &lenA);
429 ok(ret == E_FAIL, "IMultiLanguage2_ConvertStringFromUnicode should fail: %08x\n", ret);
430 ok(lenA == 0, "expected lenA 0, got %u\n", lenA);
431 /* still has to do partial conversion */
432 ok(!memcmp(bufA, stringA, 5), "bufW/stringW mismatch\n");
433
434 memset(bufA, 'x', sizeof(bufA));
435 lenW = -1;
436 lenA = sizeof(bufA);
437 ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, CP_UNICODE, stringW, &lenW, bufA, &lenA);
438 ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
439 ok(lenA == lstrlenA(stringA) * (int)sizeof(WCHAR), "wrong lenA %u\n", lenA);
440 ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
441 ok(bufA[lenA] != 0 && bufA[lenA+1] != 0, "buf should not be 0 terminated\n");
442 bufA[lenA] = 0; /* -1 doesn't include 0 terminator */
443 bufA[lenA+1] = 0; /* sizeof(WCHAR) */
444 ok(!lstrcmpW((LPCWSTR)bufA, stringW), "bufA/stringW mismatch\n");
445
446 memset(bufA, 'x', sizeof(bufA));
447 lenW = lstrlenW(stringW);
448 lenA = 0;
449 ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, NULL, &lenA);
450 ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
451 ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
452 expected_len = WideCharToMultiByte(1252, 0, stringW, lenW, NULL, 0, NULL, NULL);
453 ok(lenA == expected_len, "expected lenA %u, got %u\n", expected_len, lenA);
454 }
455
456 static void cpinfo_cmp(MIMECPINFO *cpinfo1, MIMECPINFO *cpinfo2)
457 {
458 ok(cpinfo1->dwFlags == cpinfo2->dwFlags, "dwFlags mismatch: %08x != %08x\n", cpinfo1->dwFlags, cpinfo2->dwFlags);
459 ok(cpinfo1->uiCodePage == cpinfo2->uiCodePage, "uiCodePage mismatch: %u != %u\n", cpinfo1->uiCodePage, cpinfo2->uiCodePage);
460 ok(cpinfo1->uiFamilyCodePage == cpinfo2->uiFamilyCodePage, "uiFamilyCodePage mismatch: %u != %u\n", cpinfo1->uiFamilyCodePage, cpinfo2->uiFamilyCodePage);
461 ok(!lstrcmpW(cpinfo1->wszDescription, cpinfo2->wszDescription), "wszDescription mismatch\n");
462 ok(!lstrcmpW(cpinfo1->wszWebCharset, cpinfo2->wszWebCharset), "wszWebCharset mismatch\n");
463 ok(!lstrcmpW(cpinfo1->wszHeaderCharset, cpinfo2->wszHeaderCharset), "wszHeaderCharset mismatch\n");
464 ok(!lstrcmpW(cpinfo1->wszBodyCharset, cpinfo2->wszBodyCharset), "wszBodyCharset mismatch\n");
465 ok(!lstrcmpW(cpinfo1->wszFixedWidthFont, cpinfo2->wszFixedWidthFont), "wszFixedWidthFont mismatch\n");
466 ok(!lstrcmpW(cpinfo1->wszProportionalFont, cpinfo2->wszProportionalFont), "wszProportionalFont mismatch\n");
467 ok(cpinfo1->bGDICharset == cpinfo2->bGDICharset, "bGDICharset mismatch: %d != %d\n", cpinfo1->bGDICharset, cpinfo2->bGDICharset);
468 }
469
470 #ifdef DUMP_CP_INFO
471 static const char *dump_mime_flags(DWORD flags)
472 {
473 static char buf[1024];
474
475 buf[0] = 0;
476
477 if (flags & MIMECONTF_MAILNEWS) strcat(buf, " MIMECONTF_MAILNEWS");
478 if (flags & MIMECONTF_BROWSER) strcat(buf, " MIMECONTF_BROWSER");
479 if (flags & MIMECONTF_MINIMAL) strcat(buf, " MIMECONTF_MINIMAL");
480 if (flags & MIMECONTF_IMPORT) strcat(buf, " MIMECONTF_IMPORT");
481 if (flags & MIMECONTF_SAVABLE_MAILNEWS) strcat(buf, " MIMECONTF_SAVABLE_MAILNEWS");
482 if (flags & MIMECONTF_SAVABLE_BROWSER) strcat(buf, " MIMECONTF_SAVABLE_BROWSER");
483 if (flags & MIMECONTF_EXPORT) strcat(buf, " MIMECONTF_EXPORT");
484 if (flags & MIMECONTF_PRIVCONVERTER) strcat(buf, " MIMECONTF_PRIVCONVERTER");
485 if (flags & MIMECONTF_VALID) strcat(buf, " MIMECONTF_VALID");
486 if (flags & MIMECONTF_VALID_NLS) strcat(buf, " MIMECONTF_VALID_NLS");
487 if (flags & MIMECONTF_MIME_IE4) strcat(buf, " MIMECONTF_MIME_IE4");
488 if (flags & MIMECONTF_MIME_LATEST) strcat(buf, " MIMECONTF_MIME_LATEST");
489 if (flags & MIMECONTF_MIME_REGISTRY) strcat(buf, " MIMECONTF_MIME_REGISTRY");
490
491 return buf;
492 }
493 #endif
494
495 static HRESULT check_convertible(IMultiLanguage2 *iML2, UINT from, UINT to)
496 {
497 CHAR convert[MAX_PATH];
498 BYTE dest[MAX_PATH];
499 HRESULT hr;
500 UINT srcsz, destsz;
501
502 static WCHAR strW[] = {'a','b','c',0};
503
504 /* Check to see if the target codepage has these characters or not */
505 if (from != CP_UTF8)
506 {
507 BOOL fDefaultChar;
508 char ch[10];
509 int cb;
510 cb = WideCharToMultiByte( from, WC_NO_BEST_FIT_CHARS | WC_COMPOSITECHECK | WC_DEFAULTCHAR,
511 strW, 3, ch, sizeof(ch), NULL, &fDefaultChar);
512
513 if(cb == 0 || fDefaultChar)
514 {
515 trace("target codepage %i does not contain 'abc'\n",from);
516 return E_FAIL;
517 }
518 }
519
520 srcsz = lstrlenW(strW) + 1;
521 destsz = MAX_PATH;
522 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, from, strW,
523 &srcsz, convert, &destsz);
524 if (hr != S_OK)
525 return S_FALSE;
526
527 srcsz = -1;
528 destsz = MAX_PATH;
529 hr = IMultiLanguage2_ConvertString(iML2, NULL, from, to, (BYTE *)convert,
530 &srcsz, dest, &destsz);
531 if (hr != S_OK)
532 return S_FALSE;
533
534 return S_OK;
535 }
536
537 static void test_EnumCodePages(IMultiLanguage2 *iML2, DWORD flags)
538 {
539 IEnumCodePage *iEnumCP = NULL;
540 MIMECPINFO *cpinfo;
541 MIMECPINFO cpinfo2;
542 HRESULT ret;
543 ULONG i, n;
544 UINT total;
545
546 total = 0;
547 ret = IMultiLanguage2_GetNumberOfCodePageInfo(iML2, &total);
548 ok(ret == S_OK && total != 0, "IMultiLanguage2_GetNumberOfCodePageInfo: expected S_OK/!0, got %08x/%u\n", ret, total);
549
550 trace("total mlang supported codepages %u\n", total);
551
552 ret = IMultiLanguage2_EnumCodePages(iML2, flags, LANG_NEUTRAL, &iEnumCP);
553 ok(ret == S_OK && iEnumCP, "IMultiLanguage2_EnumCodePages: expected S_OK/!NULL, got %08x/%p\n", ret, iEnumCP);
554
555 ret = IEnumCodePage_Reset(iEnumCP);
556 ok(ret == S_OK, "IEnumCodePage_Reset: expected S_OK, got %08x\n", ret);
557 n = 65536;
558 ret = IEnumCodePage_Next(iEnumCP, 0, NULL, &n);
559 if (ret == S_FALSE)
560 ok(n == 0 && ret == S_FALSE, "IEnumCodePage_Next: expected 0/S_FALSE, got %u/%08x\n", n, ret);
561 else if (ret == E_FAIL)
562 ok(n == 65536 && ret == E_FAIL, "IEnumCodePage_Next: expected 65536/E_FAIL, got %u/%08x\n", n, ret);
563 ret = IEnumCodePage_Next(iEnumCP, 0, NULL, NULL);
564 if (ret == S_FALSE)
565 ok(ret == S_FALSE, "IEnumCodePage_Next: expected S_FALSE, got %08x\n", ret);
566 else if (ret == E_FAIL)
567 ok(n == 65536 && ret == E_FAIL, "IEnumCodePage_Next: expected 65536/E_FAIL, got %u/%08x\n", n, ret);
568
569 cpinfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*cpinfo) * total * 2);
570
571 n = total * 2;
572 ret = IEnumCodePage_Next(iEnumCP, 0, cpinfo, &n);
573 ok(ret == S_FALSE && n == 0, "IEnumCodePage_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
574
575 n = total * 2;
576 ret = IEnumCodePage_Next(iEnumCP, n, cpinfo, &n);
577 ok(ret == S_OK && n != 0, "IEnumCodePage_Next: expected S_OK/!0, got %08x/%u\n", ret, n);
578
579 trace("flags %08x, enumerated codepages %u\n", flags, n);
580
581 if (!flags)
582 {
583 ok(n == total, "IEnumCodePage_Next: expected %u, got %u\n", total, n);
584
585 flags = MIMECONTF_MIME_LATEST;
586 }
587
588 total = n;
589
590 for (i = 0; i < n; i++)
591 {
592 CHARSETINFO csi;
593 MIMECSETINFO mcsi;
594 HRESULT convertible = S_OK;
595 static const WCHAR autoW[] = {'_','a','u','t','o',0};
596 static const WCHAR feffW[] = {'u','n','i','c','o','d','e','F','E','F','F',0};
597
598 #ifdef DUMP_CP_INFO
599 trace("MIMECPINFO #%u:\n"
600 "dwFlags %08x %s\n"
601 "uiCodePage %u\n"
602 "uiFamilyCodePage %u\n"
603 "wszDescription %s\n"
604 "wszWebCharset %s\n"
605 "wszHeaderCharset %s\n"
606 "wszBodyCharset %s\n"
607 "wszFixedWidthFont %s\n"
608 "wszProportionalFont %s\n"
609 "bGDICharset %d\n\n",
610 i,
611 cpinfo[i].dwFlags, dump_mime_flags(cpinfo[i].dwFlags),
612 cpinfo[i].uiCodePage,
613 cpinfo[i].uiFamilyCodePage,
614 wine_dbgstr_w(cpinfo[i].wszDescription),
615 wine_dbgstr_w(cpinfo[i].wszWebCharset),
616 wine_dbgstr_w(cpinfo[i].wszHeaderCharset),
617 wine_dbgstr_w(cpinfo[i].wszBodyCharset),
618 wine_dbgstr_w(cpinfo[i].wszFixedWidthFont),
619 wine_dbgstr_w(cpinfo[i].wszProportionalFont),
620 cpinfo[i].bGDICharset);
621 #endif
622 ok(cpinfo[i].dwFlags & flags, "enumerated flags %08x do not include requested %08x\n", cpinfo[i].dwFlags, flags);
623
624 if (TranslateCharsetInfo((DWORD *)(INT_PTR)cpinfo[i].uiFamilyCodePage, &csi, TCI_SRCCODEPAGE))
625 ok(cpinfo[i].bGDICharset == csi.ciCharset, "%d != %d\n", cpinfo[i].bGDICharset, csi.ciCharset);
626 else
627 if (winetest_debug > 1)
628 trace("TranslateCharsetInfo failed for cp %u\n", cpinfo[i].uiFamilyCodePage);
629
630 #ifdef DUMP_CP_INFO
631 trace("%u: codepage %u family %u\n", i, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
632 #endif
633 /* Win95 does not support UTF-7 */
634 if (cpinfo[i].uiCodePage == CP_UTF7) continue;
635
636 /* support files for some codepages might be not installed, or
637 * the codepage is just an alias.
638 */
639 if (IsValidCodePage(cpinfo[i].uiCodePage))
640 {
641 ret = IMultiLanguage2_IsConvertible(iML2, cpinfo[i].uiCodePage, CP_UNICODE);
642 ok(ret == S_OK, "IMultiLanguage2_IsConvertible(%u -> CP_UNICODE) = %08x\n", cpinfo[i].uiCodePage, ret);
643 ret = IMultiLanguage2_IsConvertible(iML2, CP_UNICODE, cpinfo[i].uiCodePage);
644 ok(ret == S_OK, "IMultiLanguage2_IsConvertible(CP_UNICODE -> %u) = %08x\n", cpinfo[i].uiCodePage, ret);
645
646 convertible = check_convertible(iML2, cpinfo[i].uiCodePage, CP_UTF8);
647 if (convertible != E_FAIL)
648 {
649 ret = IMultiLanguage2_IsConvertible(iML2, cpinfo[i].uiCodePage, CP_UTF8);
650 ok(ret == convertible, "IMultiLanguage2_IsConvertible(%u -> CP_UTF8) = %08x\n", cpinfo[i].uiCodePage, ret);
651 ret = IMultiLanguage2_IsConvertible(iML2, CP_UTF8, cpinfo[i].uiCodePage);
652 ok(ret == convertible, "IMultiLanguage2_IsConvertible(CP_UTF8 -> %u) = %08x\n", cpinfo[i].uiCodePage, ret);
653 }
654 }
655 else
656 if (winetest_debug > 1)
657 trace("IsValidCodePage failed for cp %u\n", cpinfo[i].uiCodePage);
658
659 if (memcmp(cpinfo[i].wszWebCharset,feffW,sizeof(WCHAR)*11)==0)
660 skip("Legacy windows bug returning invalid charset of unicodeFEFF\n");
661 else
662 {
663 ret = IMultiLanguage2_GetCharsetInfo(iML2, cpinfo[i].wszWebCharset, &mcsi);
664 /* _autoxxx charsets are a fake and GetCharsetInfo fails for them */
665 if (memcmp(cpinfo[i].wszWebCharset, autoW, 5 * sizeof(WCHAR)))
666 {
667 ok (ret == S_OK, "IMultiLanguage2_GetCharsetInfo failed: %08x\n", ret);
668 #ifdef DUMP_CP_INFO
669 trace("%s: %u %u %s\n", wine_dbgstr_w(cpinfo[i].wszWebCharset), mcsi.uiCodePage, mcsi.uiInternetEncoding, wine_dbgstr_w(mcsi.wszCharset));
670 #endif
671 ok(!lstrcmpiW(cpinfo[i].wszWebCharset, mcsi.wszCharset),
672 #ifdef DUMP_CP_INFO
673 "%s != %s\n",
674 wine_dbgstr_w(cpinfo[i].wszWebCharset), wine_dbgstr_w(mcsi.wszCharset));
675 #else
676 "wszWebCharset mismatch\n");
677 #endif
678
679 if (0)
680 {
681 /* native mlang returns completely messed up encodings in some cases */
682 ok(mcsi.uiInternetEncoding == cpinfo[i].uiCodePage || mcsi.uiInternetEncoding == cpinfo[i].uiFamilyCodePage,
683 "%u != %u || %u\n", mcsi.uiInternetEncoding, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
684 ok(mcsi.uiCodePage == cpinfo[i].uiCodePage || mcsi.uiCodePage == cpinfo[i].uiFamilyCodePage,
685 "%u != %u || %u\n", mcsi.uiCodePage, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
686 }
687 }
688 }
689
690 if (memcmp(cpinfo[i].wszHeaderCharset,feffW,sizeof(WCHAR)*11)==0)
691 skip("Legacy windows bug returning invalid charset of unicodeFEFF\n");
692 else
693 {
694 ret = IMultiLanguage2_GetCharsetInfo(iML2, cpinfo[i].wszHeaderCharset, &mcsi);
695 /* _autoxxx charsets are a fake and GetCharsetInfo fails for them */
696 if (memcmp(cpinfo[i].wszHeaderCharset, autoW, 5 * sizeof(WCHAR)))
697 {
698 ok (ret == S_OK, "IMultiLanguage2_GetCharsetInfo failed: %08x\n", ret);
699 #ifdef DUMP_CP_INFO
700 trace("%s: %u %u %s\n", wine_dbgstr_w(cpinfo[i].wszHeaderCharset), mcsi.uiCodePage, mcsi.uiInternetEncoding, wine_dbgstr_w(mcsi.wszCharset));
701 #endif
702 ok(!lstrcmpiW(cpinfo[i].wszHeaderCharset, mcsi.wszCharset),
703 #ifdef DUMP_CP_INFO
704 "%s != %s\n",
705 wine_dbgstr_w(cpinfo[i].wszHeaderCharset), wine_dbgstr_w(mcsi.wszCharset));
706 #else
707 "wszHeaderCharset mismatch\n");
708 #endif
709
710 if (0)
711 {
712 /* native mlang returns completely messed up encodings in some cases */
713 ok(mcsi.uiInternetEncoding == cpinfo[i].uiCodePage || mcsi.uiInternetEncoding == cpinfo[i].uiFamilyCodePage,
714 "%u != %u || %u\n", mcsi.uiInternetEncoding, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
715 ok(mcsi.uiCodePage == cpinfo[i].uiCodePage || mcsi.uiCodePage == cpinfo[i].uiFamilyCodePage,
716 "%u != %u || %u\n", mcsi.uiCodePage, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
717 }
718 }
719 }
720
721 if (memcmp(cpinfo[i].wszBodyCharset,feffW,sizeof(WCHAR)*11)==0)
722 skip("Legacy windows bug returning invalid charset of unicodeFEFF\n");
723 else
724 {
725 ret = IMultiLanguage2_GetCharsetInfo(iML2, cpinfo[i].wszBodyCharset, &mcsi);
726 /* _autoxxx charsets are a fake and GetCharsetInfo fails for them */
727 if (memcmp(cpinfo[i].wszBodyCharset, autoW, 5 * sizeof(WCHAR)))
728 {
729 ok (ret == S_OK, "IMultiLanguage2_GetCharsetInfo failed: %08x\n", ret);
730 #ifdef DUMP_CP_INFO
731 trace("%s: %u %u %s\n", wine_dbgstr_w(cpinfo[i].wszBodyCharset), mcsi.uiCodePage, mcsi.uiInternetEncoding, wine_dbgstr_w(mcsi.wszCharset));
732 #endif
733 ok(!lstrcmpiW(cpinfo[i].wszBodyCharset, mcsi.wszCharset),
734 #ifdef DUMP_CP_INFO
735 "%s != %s\n",
736 wine_dbgstr_w(cpinfo[i].wszBodyCharset), wine_dbgstr_w(mcsi.wszCharset));
737 #else
738 "wszBodyCharset mismatch\n");
739 #endif
740
741 if (0)
742 {
743 /* native mlang returns completely messed up encodings in some cases */
744 ok(mcsi.uiInternetEncoding == cpinfo[i].uiCodePage || mcsi.uiInternetEncoding == cpinfo[i].uiFamilyCodePage,
745 "%u != %u || %u\n", mcsi.uiInternetEncoding, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
746 ok(mcsi.uiCodePage == cpinfo[i].uiCodePage || mcsi.uiCodePage == cpinfo[i].uiFamilyCodePage,
747 "%u != %u || %u\n", mcsi.uiCodePage, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
748 }
749 }
750 }
751 }
752
753 /* now IEnumCodePage_Next should fail, since pointer is at the end */
754 n = 1;
755 ret = IEnumCodePage_Next(iEnumCP, 1, &cpinfo2, &n);
756 ok(ret == S_FALSE && n == 0, "IEnumCodePage_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
757
758 ret = IEnumCodePage_Reset(iEnumCP);
759 ok(ret == S_OK, "IEnumCodePage_Reset: expected S_OK, got %08x\n", ret);
760 n = 0;
761 ret = IEnumCodePage_Next(iEnumCP, 1, &cpinfo2, &n);
762 ok(n == 1 && ret == S_OK, "IEnumCodePage_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
763 cpinfo_cmp(&cpinfo[0], &cpinfo2);
764
765 if (0)
766 {
767 /* Due to a bug in MS' implementation of IEnumCodePage_Skip
768 * it's not used here.
769 */
770 ret = IEnumCodePage_Skip(iEnumCP, 1);
771 ok(ret == S_OK, "IEnumCodePage_Skip: expected S_OK, got %08x\n", ret);
772 }
773 for (i = 0; i < total - 1; i++)
774 {
775 n = 0;
776 ret = IEnumCodePage_Next(iEnumCP, 1, &cpinfo2, &n);
777 ok(n == 1 && ret == S_OK, "IEnumCodePage_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
778 cpinfo_cmp(&cpinfo[i + 1], &cpinfo2);
779 }
780
781 HeapFree(GetProcessHeap(), 0, cpinfo);
782 IEnumCodePage_Release(iEnumCP);
783 }
784
785 static void scriptinfo_cmp(SCRIPTINFO *sinfo1, SCRIPTINFO *sinfo2)
786 {
787 ok(sinfo1->ScriptId == sinfo2->ScriptId, "ScriptId mismatch: %d != %d\n", sinfo1->ScriptId, sinfo2->ScriptId);
788 ok(sinfo1->uiCodePage == sinfo2->uiCodePage, "uiCodePage mismatch: %u != %u\n", sinfo1->uiCodePage, sinfo2->uiCodePage);
789 ok(!lstrcmpW(sinfo1->wszDescription, sinfo2->wszDescription), "wszDescription mismatch\n");
790 ok(!lstrcmpW(sinfo1->wszFixedWidthFont, sinfo2->wszFixedWidthFont), "wszFixedWidthFont mismatch\n");
791 ok(!lstrcmpW(sinfo1->wszProportionalFont, sinfo2->wszProportionalFont), "wszProportionalFont mismatch\n");
792 }
793
794 static void test_EnumScripts(IMultiLanguage2 *iML2, DWORD flags)
795 {
796 IEnumScript *iEnumScript = NULL;
797 SCRIPTINFO *sinfo;
798 SCRIPTINFO sinfo2;
799 HRESULT ret;
800 ULONG i, n;
801 UINT total;
802
803 total = 0;
804 ret = IMultiLanguage2_GetNumberOfScripts(iML2, &total);
805 ok(ret == S_OK && total != 0, "IMultiLanguage2_GetNumberOfScripts: expected S_OK/!0, got %08x/%u\n", ret, total);
806
807 trace("total mlang supported scripts %u\n", total);
808
809 ret = IMultiLanguage2_EnumScripts(iML2, flags, LANG_NEUTRAL, &iEnumScript);
810 ok(ret == S_OK && iEnumScript, "IMultiLanguage2_EnumScripts: expected S_OK/!NULL, got %08x/%p\n", ret, iEnumScript);
811
812 ret = IEnumScript_Reset(iEnumScript);
813 ok(ret == S_OK, "IEnumScript_Reset: expected S_OK, got %08x\n", ret);
814 n = 65536;
815 ret = IEnumScript_Next(iEnumScript, 0, NULL, &n);
816 ok(n == 65536 && ret == E_FAIL, "IEnumScript_Next: expected 65536/E_FAIL, got %u/%08x\n", n, ret);
817 ret = IEnumScript_Next(iEnumScript, 0, NULL, NULL);
818 ok(ret == E_FAIL, "IEnumScript_Next: expected E_FAIL, got %08x\n", ret);
819
820 sinfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*sinfo) * total * 2);
821
822 n = total * 2;
823 ret = IEnumScript_Next(iEnumScript, 0, sinfo, &n);
824 ok(ret == S_FALSE && n == 0, "IEnumScript_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
825
826 n = total * 2;
827 ret = IEnumScript_Next(iEnumScript, n, sinfo, &n);
828 ok(ret == S_OK && n != 0, "IEnumScript_Next: expected S_OK, got %08x/%u\n", ret, n);
829
830 trace("flags %08x, enumerated scripts %u\n", flags, n);
831
832 if (!flags)
833 {
834 ok(n == total, "IEnumScript_Next: expected %u, got %u\n", total, n);
835 flags = SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM;
836 }
837
838 total = n;
839
840 for (i = 0; pGetCPInfoExA && i < n; i++)
841 {
842 #ifdef DUMP_SCRIPT_INFO
843 trace("SCRIPTINFO #%u:\n"
844 "ScriptId %08x\n"
845 "uiCodePage %u\n"
846 "wszDescription %s\n"
847 "wszFixedWidthFont %s\n"
848 "wszProportionalFont %s\n\n",
849 i,
850 sinfo[i].ScriptId,
851 sinfo[i].uiCodePage,
852 wine_dbgstr_w(sinfo[i].wszDescription),
853 wine_dbgstr_w(sinfo[i].wszFixedWidthFont),
854 wine_dbgstr_w(sinfo[i].wszProportionalFont));
855 trace("%u codepage %u\n", i, sinfo[i].uiCodePage);
856 #endif
857 }
858
859 /* now IEnumScript_Next should fail, since pointer is at the end */
860 n = 1;
861 ret = IEnumScript_Next(iEnumScript, 1, &sinfo2, &n);
862 ok(ret == S_FALSE && n == 0, "IEnumScript_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
863
864 ret = IEnumScript_Reset(iEnumScript);
865 ok(ret == S_OK, "IEnumScript_Reset: expected S_OK, got %08x\n", ret);
866 n = 0;
867 ret = IEnumScript_Next(iEnumScript, 1, &sinfo2, &n);
868 ok(n == 1 && ret == S_OK, "IEnumScript_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
869 scriptinfo_cmp(&sinfo[0], &sinfo2);
870
871 if (0)
872 {
873 /* Due to a bug in MS' implementation of IEnumScript_Skip
874 * it's not used here.
875 */
876 ret = IEnumScript_Skip(iEnumScript, 1);
877 ok(ret == S_OK, "IEnumScript_Skip: expected S_OK, got %08x\n", ret);
878 }
879 for (i = 0; i < total - 1; i++)
880 {
881 n = 0;
882 ret = IEnumScript_Next(iEnumScript, 1, &sinfo2, &n);
883 ok(n == 1 && ret == S_OK, "IEnumScript_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
884 scriptinfo_cmp(&sinfo[i + 1], &sinfo2);
885 }
886
887 HeapFree(GetProcessHeap(), 0, sinfo);
888 IEnumScript_Release(iEnumScript);
889 }
890
891 static void IMLangFontLink_Test(IMLangFontLink* iMLFL)
892 {
893 DWORD dwCodePages, dwManyCodePages;
894 DWORD dwCmpCodePages;
895 UINT CodePage;
896 static const WCHAR str[3] = { 'd', 0x0436, 0xff90 };
897 LONG processed;
898 HRESULT ret;
899
900 dwCodePages = ~0u;
901 ret = IMLangFontLink_CodePageToCodePages(iMLFL, -1, &dwCodePages);
902 ok(ret == E_FAIL, "IMLangFontLink_CodePageToCodePages should fail: %x\n", ret);
903 ok(dwCodePages == 0, "expected 0, got %u\n", dwCodePages);
904
905 dwCodePages = 0;
906 ret = IMLangFontLink_CodePageToCodePages(iMLFL, 932, &dwCodePages);
907 ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
908 ok(dwCodePages == FS_JISJAPAN, "expected FS_JISJAPAN, got %08x\n", dwCodePages);
909 CodePage = 0;
910 ret = IMLangFontLink_CodePagesToCodePage(iMLFL, dwCodePages, 1035, &CodePage);
911 ok(ret == S_OK, "IMLangFontLink_CodePagesToCodePage error %x\n", ret);
912 ok(CodePage == 932, "Incorrect CodePage Returned (%i)\n",CodePage);
913
914 dwManyCodePages = 0;
915 ret = IMLangFontLink_CodePageToCodePages(iMLFL, 1252, &dwManyCodePages);
916 ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
917 ok(dwManyCodePages == FS_LATIN1, "expected FS_LATIN1, got %08x\n", dwManyCodePages);
918 dwCodePages = 0;
919 ret = IMLangFontLink_CodePageToCodePages(iMLFL, 1256, &dwCodePages);
920 ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
921 ok(dwCodePages == FS_ARABIC, "expected FS_ARABIC, got %08x\n", dwCodePages);
922 dwManyCodePages |= dwCodePages;
923 ret = IMLangFontLink_CodePageToCodePages(iMLFL, 874, &dwCodePages);
924 ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
925 ok(dwCodePages == FS_THAI, "expected FS_THAI, got %08x\n", dwCodePages);
926 dwManyCodePages |= dwCodePages;
927
928 ret = IMLangFontLink_CodePagesToCodePage(iMLFL, dwManyCodePages, 1256, &CodePage);
929 ok(ret == S_OK, "IMLangFontLink_CodePagesToCodePage error %x\n", ret);
930 ok(CodePage == 1256, "Incorrect CodePage Returned (%i)\n",CodePage);
931
932 ret = IMLangFontLink_CodePagesToCodePage(iMLFL, dwManyCodePages, 936, &CodePage);
933 ok(ret == S_OK, "IMLangFontLink_CodePagesToCodePage error %x\n", ret);
934 ok(CodePage == 1252, "Incorrect CodePage Returned (%i)\n",CodePage);
935
936 /* Tests for GetCharCodePages */
937
938 /* Latin 1 */
939 dwCmpCodePages = FS_LATIN1 | FS_LATIN2 | FS_CYRILLIC | FS_GREEK | FS_TURKISH
940 | FS_HEBREW | FS_ARABIC | FS_BALTIC | FS_VIETNAMESE | FS_THAI
941 | FS_JISJAPAN | FS_CHINESESIMP | FS_WANSUNG | FS_CHINESETRAD;
942 ret = IMLangFontLink_GetCharCodePages(iMLFL, 'd', &dwCodePages);
943 ok(ret == S_OK, "IMLangFontLink_GetCharCodePages error %x\n", ret);
944 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
945
946 dwCodePages = 0;
947 processed = 0;
948 ret = IMLangFontLink_GetStrCodePages(iMLFL, &str[0], 1, 0, &dwCodePages, &processed);
949 ok(ret == S_OK, "IMLangFontLink_GetStrCodePages error %x\n", ret);
950 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
951 ok(processed == 1, "expected 1, got %d\n", processed);
952
953 /* Cyrillic */
954 dwCmpCodePages = FS_CYRILLIC | FS_JISJAPAN | FS_CHINESESIMP | FS_WANSUNG;
955 ret = IMLangFontLink_GetCharCodePages(iMLFL, 0x0436, &dwCodePages);
956 ok(ret == S_OK, "IMLangFontLink_GetCharCodePages error %x\n", ret);
957 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
958
959 dwCodePages = 0;
960 processed = 0;
961 ret = IMLangFontLink_GetStrCodePages(iMLFL, &str[1], 1, 0, &dwCodePages, &processed);
962 ok(ret == S_OK, "IMLangFontLink_GetStrCodePages error %x\n", ret);
963 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
964 ok(processed == 1, "expected 1, got %d\n", processed);
965
966 /* Japanese */
967 dwCmpCodePages = FS_JISJAPAN;
968 ret = IMLangFontLink_GetCharCodePages(iMLFL, 0xff90, &dwCodePages);
969 ok(ret == S_OK, "IMLangFontLink_GetCharCodePages error %x\n", ret);
970 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
971
972 dwCodePages = 0;
973 processed = 0;
974 ret = IMLangFontLink_GetStrCodePages(iMLFL, &str[2], 1, 0, &dwCodePages, &processed);
975 ok(ret == S_OK, "IMLangFontLink_GetStrCodePages error %x\n", ret);
976 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
977 ok(processed == 1, "expected 1, got %d\n", processed);
978
979 dwCmpCodePages = FS_CYRILLIC | FS_JISJAPAN | FS_CHINESESIMP | FS_WANSUNG;
980 dwCodePages = 0;
981 processed = 0;
982 ret = IMLangFontLink_GetStrCodePages(iMLFL, str, 2, 0, &dwCodePages, &processed);
983 ok(ret == S_OK, "IMLangFontLink_GetStrCodePages error %x\n", ret);
984 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
985 ok(processed == 2, "expected 2, got %d\n", processed);
986
987 dwCmpCodePages = FS_JISJAPAN;
988 dwCodePages = 0;
989 processed = 0;
990 ret = IMLangFontLink_GetStrCodePages(iMLFL, str, 3, 0, &dwCodePages, &processed);
991 ok(ret == S_OK, "IMLangFontLink_GetStrCodePages error %x\n", ret);
992 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
993 ok(processed == 3, "expected 3, got %d\n", processed);
994
995 dwCodePages = 0xffff;
996 processed = -1;
997 ret = IMLangFontLink_GetStrCodePages(iMLFL, &str[2], 1, 0, &dwCodePages, &processed);
998 ok(ret == S_OK, "IMLangFontLink_GetStrCodePages error %x\n", ret);
999 ok(dwCodePages == dwCmpCodePages, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
1000 ok(processed == 1, "expected 0, got %d\n", processed);
1001
1002 ret = IMLangFontLink_GetStrCodePages(iMLFL, &str[2], 1, 0, NULL, NULL);
1003 ok(ret == S_OK, "IMLangFontLink_GetStrCodePages error %x\n", ret);
1004
1005 dwCodePages = 0xffff;
1006 processed = -1;
1007 ret = IMLangFontLink_GetStrCodePages(iMLFL, str, -1, 0, &dwCodePages, &processed);
1008 ok(ret == E_INVALIDARG, "IMLangFontLink_GetStrCodePages should fail: %x\n", ret);
1009 ok(dwCodePages == 0, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
1010 ok(processed == 0, "expected 0, got %d\n", processed);
1011
1012 dwCodePages = 0xffff;
1013 processed = -1;
1014 ret = IMLangFontLink_GetStrCodePages(iMLFL, NULL, 1, 0, &dwCodePages, &processed);
1015 ok(ret == E_INVALIDARG, "IMLangFontLink_GetStrCodePages should fail: %x\n", ret);
1016 ok(dwCodePages == 0, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
1017 ok(processed == 0, "expected 0, got %d\n", processed);
1018
1019 dwCodePages = 0xffff;
1020 processed = -1;
1021 ret = IMLangFontLink_GetStrCodePages(iMLFL, str, 0, 0, &dwCodePages, &processed);
1022 ok(ret == E_INVALIDARG, "IMLangFontLink_GetStrCodePages should fail: %x\n", ret);
1023 ok(dwCodePages == 0, "expected %x, got %x\n", dwCmpCodePages, dwCodePages);
1024 ok(processed == 0, "expected 0, got %d\n", processed);
1025 }
1026
1027 /* copied from libs/wine/string.c */
1028 static WCHAR *strstrW(const WCHAR *str, const WCHAR *sub)
1029 {
1030 while (*str)
1031 {
1032 const WCHAR *p1 = str, *p2 = sub;
1033 while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
1034 if (!*p2) return (WCHAR *)str;
1035 str++;
1036 }
1037 return NULL;
1038 }
1039
1040 static void test_rfc1766(IMultiLanguage2 *iML2)
1041 {
1042 IEnumRfc1766 *pEnumRfc1766;
1043 RFC1766INFO info;
1044 ULONG n;
1045 HRESULT ret;
1046 BSTR rfcstr;
1047
1048 ret = IMultiLanguage2_EnumRfc1766(iML2, LANG_NEUTRAL, &pEnumRfc1766);
1049 ok(ret == S_OK, "IMultiLanguage2_EnumRfc1766 error %08x\n", ret);
1050
1051 while (1)
1052 {
1053 ret = IEnumRfc1766_Next(pEnumRfc1766, 1, &info, &n);
1054 if (ret != S_OK) break;
1055
1056 #ifdef DUMP_CP_INFO
1057 trace("lcid %04x rfc_name %s locale_name %s\n",
1058 info.lcid, wine_dbgstr_w(info.wszRfc1766), wine_dbgstr_w(info.wszLocaleName));
1059 #endif
1060
1061 ok(n == 1, "couldn't fetch 1 RFC1766INFO structure\n");
1062
1063 /* verify the Rfc1766 value */
1064 ret = IMultiLanguage2_GetRfc1766FromLcid(iML2, info.lcid, &rfcstr);
1065 ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
1066
1067 /* not an exact 1:1 correspondence between lcid and rfc1766 in the
1068 * mlang database, e.g., nb-no -> 1044 -> no */
1069 ok(strstrW(info.wszRfc1766, rfcstr) != NULL,
1070 "Expected matching locale names\n");
1071
1072 SysFreeString(rfcstr);
1073 }
1074 IEnumRfc1766_Release(pEnumRfc1766);
1075 }
1076
1077 static void test_GetLcidFromRfc1766(IMultiLanguage2 *iML2)
1078 {
1079 WCHAR rfc1766W[MAX_RFC1766_NAME + 1];
1080 LCID lcid;
1081 HRESULT ret;
1082 DWORD i;
1083
1084 static WCHAR en[] = { 'e','n',0 };
1085 static WCHAR en_them[] = { 'e','n','-','t','h','e','m',0 };
1086 static WCHAR english[] = { 'e','n','g','l','i','s','h',0 };
1087
1088
1089 for(i = 0; i < sizeof(lcid_table) / sizeof(lcid_table[0]); i++) {
1090 lcid = -1;
1091 MultiByteToWideChar(CP_ACP, 0, lcid_table[i].rfc1766, -1, rfc1766W, MAX_RFC1766_NAME);
1092 ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, rfc1766W);
1093
1094 /* IE <6.0 guess 0x412 (ko) from "kok" */
1095 ok((ret == lcid_table[i].hr) ||
1096 broken(lcid_table[i].broken_lcid && (ret == S_FALSE)),
1097 "#%02d: HRESULT 0x%x (expected 0x%x)\n", i, ret, lcid_table[i].hr);
1098
1099 ok((lcid == lcid_table[i].lcid) ||
1100 broken(lcid == lcid_table[i].broken_lcid), /* IE <6.0 */
1101 "#%02d: got LCID 0x%x (expected 0x%x)\n", i, lcid, lcid_table[i].lcid);
1102 }
1103
1104
1105 ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, NULL, en);
1106 ok(ret == E_INVALIDARG, "GetLcidFromRfc1766 returned: %08x\n", ret);
1107
1108 ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, NULL);
1109 ok(ret == E_INVALIDARG, "GetLcidFromRfc1766 returned: %08x\n", ret);
1110
1111 ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, en_them);
1112 ok((ret == E_FAIL || ret == S_FALSE), "GetLcidFromRfc1766 returned: %08x\n", ret);
1113 if (ret == S_FALSE)
1114 {
1115 BSTR rfcstr;
1116 static WCHAR en[] = {'e','n',0};
1117
1118 ret = IMultiLanguage2_GetRfc1766FromLcid(iML2, lcid, &rfcstr);
1119 ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
1120 ok_w2("Expected \"%s\", got \"%s\"n", en, rfcstr);
1121 }
1122
1123 ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, english);
1124 ok((ret == E_FAIL || ret == S_FALSE), "GetLcidFromRfc1766 returned: %08x\n", ret);
1125 if (ret == S_FALSE)
1126 {
1127 BSTR rfcstr;
1128 static WCHAR en[] = {'e','n',0};
1129
1130 ret = IMultiLanguage2_GetRfc1766FromLcid(iML2, lcid, &rfcstr);
1131 ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
1132 ok_w2("Expected \"%s\", got \"%s\"n", en, rfcstr);
1133 }
1134
1135 }
1136
1137 static void test_Rfc1766ToLcid(void)
1138 {
1139 LCID lcid;
1140 HRESULT ret;
1141 DWORD i;
1142
1143 for(i = 0; i < sizeof(lcid_table) / sizeof(lcid_table[0]); i++) {
1144 lcid = -1;
1145 ret = pRfc1766ToLcidA(&lcid, lcid_table[i].rfc1766);
1146
1147 /* IE <6.0 guess 0x412 (ko) from "kok" */
1148 ok( (ret == lcid_table[i].hr) ||
1149 broken(lcid_table[i].broken_lcid && (ret == S_FALSE)),
1150 "#%02d: HRESULT 0x%x (expected 0x%x)\n", i, ret, lcid_table[i].hr);
1151
1152 ok( (lcid == lcid_table[i].lcid) ||
1153 broken(lcid == lcid_table[i].broken_lcid), /* IE <6.0 */
1154 "#%02d: got LCID 0x%x (expected 0x%x)\n", i, lcid, lcid_table[i].lcid);
1155 }
1156
1157 ret = pRfc1766ToLcidA(&lcid, NULL);
1158 ok(ret == E_INVALIDARG, "got 0x%08x (expected E_INVALIDARG)\n", ret);
1159
1160 ret = pRfc1766ToLcidA(NULL, "en");
1161 ok(ret == E_INVALIDARG, "got 0x%08x (expected E_INVALIDARG)\n", ret);
1162 }
1163
1164 static void test_GetNumberOfCodePageInfo(IMultiLanguage2 *iML2)
1165 {
1166 HRESULT hr;
1167 UINT value;
1168
1169 value = 0xdeadbeef;
1170 hr = IMultiLanguage2_GetNumberOfCodePageInfo(iML2, &value);
1171 ok( (hr == S_OK) && value,
1172 "got 0x%x with %d (expected S_OK with '!= 0')\n", hr, value);
1173
1174 hr = IMultiLanguage2_GetNumberOfCodePageInfo(iML2, NULL);
1175 ok(hr == E_INVALIDARG, "got 0x%x (expected E_INVALIDARG)\n", hr);
1176
1177 }
1178
1179 static void test_GetRfc1766FromLcid(IMultiLanguage2 *iML2)
1180 {
1181 CHAR expected[MAX_RFC1766_NAME];
1182 CHAR buffer[MAX_RFC1766_NAME + 1];
1183 DWORD i;
1184 HRESULT hr;
1185 BSTR rfcstr;
1186
1187 for(i = 0; i < sizeof(lcid_table) / sizeof(lcid_table[0]); i++) {
1188 buffer[0] = '\0';
1189
1190 rfcstr = NULL;
1191 hr = IMultiLanguage2_GetRfc1766FromLcid(iML2, lcid_table[i].lcid, &rfcstr);
1192 ok(hr == lcid_table[i].hr,
1193 "#%02d: HRESULT 0x%x (expected 0x%x)\n", i, hr, lcid_table[i].hr);
1194
1195 if (hr != S_OK)
1196 continue; /* no result-string created */
1197
1198 WideCharToMultiByte(CP_ACP, 0, rfcstr, -1, buffer, sizeof(buffer), NULL, NULL);
1199 LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, lcid_table[i].rfc1766,
1200 lstrlenA(lcid_table[i].rfc1766) + 1, expected, MAX_RFC1766_NAME);
1201
1202 /* IE <6.0 return "x-kok" for LCID 0x457 ("kok") */
1203 ok( (!lstrcmpA(buffer, expected)) ||
1204 broken(!lstrcmpA(buffer, lcid_table[i].broken_rfc)),
1205 "#%02d: got '%s' (expected '%s')\n", i, buffer, expected);
1206
1207 SysFreeString(rfcstr);
1208 }
1209
1210 hr = IMultiLanguage2_GetRfc1766FromLcid(iML2, MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), NULL);
1211 ok(hr == E_INVALIDARG, "got 0x%x (expected E_INVALIDARG)\n", hr);
1212 }
1213
1214 static void test_LcidToRfc1766(void)
1215 {
1216 CHAR expected[MAX_RFC1766_NAME];
1217 CHAR buffer[MAX_RFC1766_NAME * 2];
1218 HRESULT hr;
1219 DWORD i;
1220
1221 for(i = 0; i < sizeof(lcid_table) / sizeof(lcid_table[0]); i++) {
1222
1223 memset(buffer, '#', sizeof(buffer)-1);
1224 buffer[sizeof(buffer)-1] = '\0';
1225
1226 hr = pLcidToRfc1766A(lcid_table[i].lcid, buffer, MAX_RFC1766_NAME);
1227
1228 /* IE <5.0 does not recognize 0x180c (fr-mc) and 0x457 (kok) */
1229 ok( (hr == lcid_table[i].hr) ||
1230 broken(lcid_table[i].broken_lcid && (hr == E_FAIL)),
1231 "#%02d: HRESULT 0x%x (expected 0x%x)\n", i, hr, lcid_table[i].hr);
1232
1233 if (hr != S_OK)
1234 continue;
1235
1236 LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE, lcid_table[i].rfc1766,
1237 lstrlenA(lcid_table[i].rfc1766) + 1, expected, MAX_RFC1766_NAME);
1238
1239 /* IE <6.0 return "x-kok" for LCID 0x457 ("kok") */
1240 /* IE <5.0 return "fr" for LCID 0x180c ("fr-mc") */
1241 ok( (!lstrcmpA(buffer, expected)) ||
1242 broken(!lstrcmpA(buffer, lcid_table[i].broken_rfc)),
1243 "#%02d: got '%s' (expected '%s')\n", i, buffer, expected);
1244
1245 }
1246
1247 memset(buffer, '#', sizeof(buffer)-1);
1248 buffer[sizeof(buffer)-1] = '\0';
1249 hr = pLcidToRfc1766A(-1, buffer, MAX_RFC1766_NAME);
1250 ok(hr == E_FAIL, "got 0x%08x and '%s' (expected E_FAIL)\n", hr, buffer);
1251
1252 hr = pLcidToRfc1766A(LANG_ENGLISH, NULL, MAX_RFC1766_NAME);
1253 ok(hr == E_INVALIDARG, "got 0x%08x (expected E_INVALIDARG)\n", hr);
1254
1255 memset(buffer, '#', sizeof(buffer)-1);
1256 buffer[sizeof(buffer)-1] = '\0';
1257 hr = pLcidToRfc1766A(LANG_ENGLISH, buffer, -1);
1258 ok(hr == E_INVALIDARG, "got 0x%08x and '%s' (expected E_INVALIDARG)\n", hr, buffer);
1259
1260 memset(buffer, '#', sizeof(buffer)-1);
1261 buffer[sizeof(buffer)-1] = '\0';
1262 hr = pLcidToRfc1766A(LANG_ENGLISH, buffer, 0);
1263 ok(hr == E_INVALIDARG, "got 0x%08x and '%s' (expected E_INVALIDARG)\n", hr, buffer);
1264 }
1265
1266 static void test_GetRfc1766Info(IMultiLanguage2 *iML2)
1267 {
1268 WCHAR short_broken_name[MAX_LOCALE_NAME];
1269 CHAR rfc1766A[MAX_RFC1766_NAME + 1];
1270 BYTE buffer[sizeof(RFC1766INFO) + 4];
1271 PRFC1766INFO prfc = (RFC1766INFO *) buffer;
1272 HRESULT ret;
1273 DWORD i;
1274
1275 for(i = 0; i < sizeof(info_table) / sizeof(info_table[0]); i++) {
1276 memset(buffer, 'x', sizeof(RFC1766INFO) + 2);
1277 buffer[sizeof(buffer) -1] = 0;
1278 buffer[sizeof(buffer) -2] = 0;
1279
1280 ret = IMultiLanguage2_GetRfc1766Info(iML2, info_table[i].lcid, info_table[i].lang, prfc);
1281 WideCharToMultiByte(CP_ACP, 0, prfc->wszRfc1766, -1, rfc1766A, MAX_RFC1766_NAME, NULL, NULL);
1282 ok(ret == S_OK, "#%02d: got 0x%x (expected S_OK)\n", i, ret);
1283 ok(prfc->lcid == info_table[i].lcid,
1284 "#%02d: got 0x%04x (expected 0x%04x)\n", i, prfc->lcid, info_table[i].lcid);
1285
1286 ok(!lstrcmpA(rfc1766A, info_table[i].rfc1766),
1287 "#%02d: got '%s' (expected '%s')\n", i, rfc1766A, info_table[i].rfc1766);
1288
1289 /* Some IE versions truncate an oversized name one character to short */
1290 mylstrcpyW(short_broken_name, info_table[i].broken_name);
1291 short_broken_name[MAX_LOCALE_NAME - 2] = '\0';
1292
1293 if (info_table[i].todo & TODO_NAME) {
1294 todo_wine
1295 ok( (!mylstrcmpW(prfc->wszLocaleName, info_table[i].localename)) ||
1296 broken(!mylstrcmpW(prfc->wszLocaleName, info_table[i].broken_name)) || /* IE < 6.0 */
1297 broken(!mylstrcmpW(prfc->wszLocaleName, short_broken_name)),
1298 "#%02d: got %s (expected %s)\n", i,
1299 debugstr_w(prfc->wszLocaleName), debugstr_w(info_table[i].localename));
1300 }
1301 else
1302 ok( (!mylstrcmpW(prfc->wszLocaleName, info_table[i].localename)) ||
1303 broken(!mylstrcmpW(prfc->wszLocaleName, info_table[i].broken_name)) || /* IE < 6.0 */
1304 broken(!mylstrcmpW(prfc->wszLocaleName, short_broken_name)),
1305 "#%02d: got %s (expected %s)\n", i,
1306 debugstr_w(prfc->wszLocaleName), debugstr_w(info_table[i].localename));
1307
1308 }
1309
1310 /* SUBLANG_NEUTRAL only allowed for english, arabic, chinese */
1311 ret = IMultiLanguage2_GetRfc1766Info(iML2, MAKELANGID(LANG_GERMAN, SUBLANG_NEUTRAL), LANG_ENGLISH, prfc);
1312 ok(ret == E_FAIL, "got 0x%x (expected E_FAIL)\n", ret);
1313
1314 ret = IMultiLanguage2_GetRfc1766Info(iML2, MAKELANGID(LANG_ITALIAN, SUBLANG_NEUTRAL), LANG_ENGLISH, prfc);
1315 ok(ret == E_FAIL, "got 0x%x (expected E_FAIL)\n", ret);
1316
1317 /* NULL not allowed */
1318 ret = IMultiLanguage2_GetRfc1766Info(iML2, 0, LANG_ENGLISH, prfc);
1319 ok(ret == E_FAIL, "got 0x%x (expected E_FAIL)\n", ret);
1320
1321 ret = IMultiLanguage2_GetRfc1766Info(iML2, LANG_ENGLISH, LANG_ENGLISH, NULL);
1322 ok(ret == E_INVALIDARG, "got 0x%x (expected E_INVALIDARG)\n", ret);
1323 }
1324
1325 static void test_IMultiLanguage2_ConvertStringFromUnicode(IMultiLanguage2 *iML2)
1326 {
1327 CHAR dest[MAX_PATH];
1328 CHAR invariate[MAX_PATH];
1329 UINT srcsz, destsz;
1330 HRESULT hr;
1331
1332 static WCHAR src[] = {'a','b','c',0};
1333
1334 memset(invariate, 'x', sizeof(invariate));
1335
1336 /* pSrcStr NULL */
1337 memset(dest, 'x', sizeof(dest));
1338 srcsz = lstrlenW(src) + 1;
1339 destsz = sizeof(dest);
1340 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, NULL,
1341 &srcsz, dest, &destsz);
1342 ok(hr == S_OK || hr == E_FAIL,"expected S_OK or E_FAIL, got %08x\n",hr);
1343 if (hr == S_OK)
1344 {
1345 ok(srcsz == lstrlenW(src) + 1,
1346 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1347 }
1348 else if (hr == E_FAIL)
1349 {
1350 ok(srcsz == 0,
1351 "Expected %u, got %u\n", 0, srcsz);
1352 }
1353
1354 ok(!memcmp(dest, invariate, sizeof(dest)),
1355 "Expected dest to be unchanged, got %s\n", dest);
1356 ok(destsz == 0, "Expected 0, got %u\n", destsz);
1357
1358 /* pcSrcSize NULL */
1359 memset(dest, 'x', sizeof(dest));
1360 destsz = sizeof(dest);
1361 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1362 NULL, dest, &destsz);
1363 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1364 ok(!strncmp(dest, "abc", 3),
1365 "Expected first three chars to be \"abc\"\n");
1366 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1367 "Expected rest of dest to be unchanged, got %s\n", dest);
1368 ok(destsz == lstrlenW(src),
1369 "Expected %u, got %u\n", lstrlenW(src), destsz);
1370
1371 /* both pSrcStr and pcSrcSize NULL */
1372 memset(dest, 'x', sizeof(dest));
1373 destsz = sizeof(dest);
1374 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, NULL,
1375 NULL, dest, &destsz);
1376 ok(hr == S_OK || hr == E_FAIL, "Expected S_OK or E_FAIL, got %08x\n", hr);
1377 ok(!memcmp(dest, invariate, sizeof(dest)),
1378 "Expected dest to be unchanged, got %s\n", dest);
1379 ok(destsz == 0, "Expected 0, got %u\n", destsz);
1380
1381 /* pDstStr NULL */
1382 memset(dest, 'x', sizeof(dest));
1383 srcsz = lstrlenW(src) + 1;
1384 destsz = sizeof(dest);
1385 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1386 &srcsz, NULL, &destsz);
1387 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1388 ok(srcsz == lstrlenW(src) + 1,
1389 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1390 ok(destsz == lstrlenW(src) + 1,
1391 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1392
1393 /* pcDstSize NULL */
1394 memset(dest, 'x', sizeof(dest));
1395 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1396 &srcsz, dest, NULL);
1397 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1398 ok(srcsz == lstrlenW(src) + 1,
1399 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1400 ok(!memcmp(dest, invariate, sizeof(dest)),
1401 "Expected dest to be unchanged, got %s\n", dest);
1402
1403 /* pcSrcSize is 0 */
1404 memset(dest, 'x', sizeof(dest));
1405 srcsz = 0;
1406 destsz = sizeof(dest);
1407 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1408 &srcsz, dest, &destsz);
1409 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1410 ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
1411 ok(!memcmp(dest, invariate, sizeof(dest)),
1412 "Expected dest to be unchanged, got %s\n", dest);
1413 ok(destsz == 0, "Expected 0, got %u\n", destsz);
1414
1415 /* pcSrcSize does not include NULL terminator */
1416 memset(dest, 'x', sizeof(dest));
1417 srcsz = lstrlenW(src);
1418 destsz = sizeof(dest);
1419 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1420 &srcsz, dest, &destsz);
1421 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1422 ok(srcsz == lstrlenW(src),
1423 "Expected %u, got %u\n", lstrlenW(src), srcsz);
1424 ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1425 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1426 "Expected rest of dest to be unchanged, got %s\n", dest);
1427 ok(destsz == lstrlenW(src),
1428 "Expected %u, got %u\n", lstrlenW(src), destsz);
1429
1430 /* pcSrcSize includes NULL terminator */
1431 memset(dest, 'x', sizeof(dest));
1432 srcsz = lstrlenW(src) + 1;
1433 destsz = sizeof(dest);
1434 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1435 &srcsz, dest, &destsz);
1436 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1437 ok(srcsz == lstrlenW(src) + 1, "Expected 3, got %u\n", srcsz);
1438 ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
1439 ok(destsz == lstrlenW(src) + 1,
1440 "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1441
1442 /* pcSrcSize is -1 */
1443 memset(dest, 'x', sizeof(dest));
1444 srcsz = -1;
1445 destsz = sizeof(dest);
1446 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1447 &srcsz, dest, &destsz);
1448 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1449 ok(srcsz == lstrlenW(src),
1450 "Expected %u, got %u\n", lstrlenW(src), srcsz);
1451 ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1452 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1453 "Expected rest of dest to be unchanged, got %s\n", dest);
1454 ok(destsz == lstrlenW(src),
1455 "Expected %u, got %u\n", lstrlenW(src), destsz);
1456
1457 /* pcDstSize is 0 */
1458 memset(dest, 'x', sizeof(dest));
1459 srcsz = lstrlenW(src) + 1;
1460 destsz = 0;
1461 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1462 &srcsz, dest, &destsz);
1463 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1464 ok(srcsz == lstrlenW(src) + 1,
1465 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1466 ok(!memcmp(dest, invariate, sizeof(dest)),
1467 "Expected dest to be unchanged, got %s\n", dest);
1468 ok(destsz == lstrlenW(src) + 1,
1469 "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1470
1471 /* pcDstSize is not large enough */
1472 memset(dest, 'x', sizeof(dest));
1473 srcsz = lstrlenW(src) + 1;
1474 destsz = lstrlenW(src);
1475 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1476 &srcsz, dest, &destsz);
1477 ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
1478 ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
1479 ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1480 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1481 "Expected rest of dest to be unchanged, got %s\n", dest);
1482 ok(destsz == 0, "Expected 0, got %u\n", srcsz);
1483
1484 /* pcDstSize (bytes) does not leave room for NULL terminator */
1485 memset(dest, 'x', sizeof(dest));
1486 srcsz = lstrlenW(src) + 1;
1487 destsz = lstrlenW(src) * sizeof(WCHAR);
1488 hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
1489 &srcsz, dest, &destsz);
1490 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1491 ok(srcsz == lstrlenW(src) + 1,
1492 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1493 ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
1494 ok(destsz == lstrlenW(src) + 1,
1495 "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1496 }
1497
1498 static void test_ConvertINetUnicodeToMultiByte(void)
1499 {
1500 CHAR dest[MAX_PATH];
1501 CHAR invariate[MAX_PATH];
1502 INT srcsz, destsz;
1503 HRESULT hr;
1504
1505 static WCHAR src[] = {'a','b','c',0};
1506
1507 memset(invariate, 'x', sizeof(invariate));
1508
1509 /* lpSrcStr NULL */
1510 memset(dest, 'x', sizeof(dest));
1511 srcsz = lstrlenW(src) + 1;
1512 destsz = sizeof(dest);
1513 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, NULL, &srcsz, dest, &destsz);
1514 ok(hr == S_OK || hr == E_FAIL, "Expected S_OK or E_FAIL, got %08x\n", hr);
1515 if (hr == S_OK)
1516 ok(srcsz == lstrlenW(src) + 1,
1517 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1518 else if (hr == E_FAIL)
1519 ok(srcsz == 0,
1520 "Expected %u, got %u\n", 0, srcsz);
1521 ok(!memcmp(dest, invariate, sizeof(dest)),
1522 "Expected dest to be unchanged, got %s\n", dest);
1523 ok(destsz == 0, "Expected 0, got %u\n", destsz);
1524
1525 /* lpnWideCharCount NULL */
1526 memset(dest, 'x', sizeof(dest));
1527 destsz = sizeof(dest);
1528 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, NULL, dest, &destsz);
1529 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1530 ok(!strncmp(dest, "abc", 3),
1531 "Expected first three chars to be \"abc\"\n");
1532 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1533 "Expected rest of dest to be unchanged, got %s\n", dest);
1534 ok(destsz == lstrlenW(src),
1535 "Expected %u, got %u\n", lstrlenW(src), destsz);
1536
1537 /* both lpSrcStr and lpnWideCharCount NULL */
1538 memset(dest, 'x', sizeof(dest));
1539 destsz = sizeof(dest);
1540 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, NULL, NULL, dest, &destsz);
1541 ok(hr == S_OK || hr == E_FAIL, "Expected S_OK or E_FAIL, got %08x\n", hr);
1542 ok(!memcmp(dest, invariate, sizeof(dest)),
1543 "Expected dest to be unchanged, got %s\n", dest);
1544 ok(destsz == 0, "Expected 0, got %u\n", destsz);
1545
1546 /* lpDstStr NULL */
1547 memset(dest, 'x', sizeof(dest));
1548 srcsz = lstrlenW(src) + 1;
1549 destsz = sizeof(dest);
1550 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, NULL, &destsz);
1551 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1552 ok(srcsz == lstrlenW(src) + 1,
1553 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1554 ok(destsz == lstrlenW(src) + 1,
1555 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1556
1557 /* lpnMultiCharCount NULL */
1558 memset(dest, 'x', sizeof(dest));
1559 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, NULL);
1560 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1561 ok(srcsz == lstrlenW(src) + 1,
1562 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1563 ok(!memcmp(dest, invariate, sizeof(dest)),
1564 "Expected dest to be unchanged, got %s\n", dest);
1565
1566 /* lpnWideCharCount is 0 */
1567 memset(dest, 'x', sizeof(dest));
1568 srcsz = 0;
1569 destsz = sizeof(dest);
1570 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1571 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1572 ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
1573 ok(!memcmp(dest, invariate, sizeof(dest)),
1574 "Expected dest to be unchanged, got %s\n", dest);
1575 ok(destsz == 0, "Expected 0, got %u\n", destsz);
1576
1577 /* lpnWideCharCount does not include NULL terminator */
1578 memset(dest, 'x', sizeof(dest));
1579 srcsz = lstrlenW(src);
1580 destsz = sizeof(dest);
1581 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1582 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1583 ok(srcsz == lstrlenW(src),
1584 "Expected %u, got %u\n", lstrlenW(src), srcsz);
1585 ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1586 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1587 "Expected rest of dest to be unchanged, got %s\n", dest);
1588 ok(destsz == lstrlenW(src),
1589 "Expected %u, got %u\n", lstrlenW(src), destsz);
1590
1591 /* lpnWideCharCount includes NULL terminator */
1592 memset(dest, 'x', sizeof(dest));
1593 srcsz = lstrlenW(src) + 1;
1594 destsz = sizeof(dest);
1595 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1596 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1597 ok(srcsz == lstrlenW(src) + 1, "Expected 3, got %u\n", srcsz);
1598 ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
1599 ok(destsz == lstrlenW(src) + 1,
1600 "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1601
1602 /* lpnWideCharCount is -1 */
1603 memset(dest, 'x', sizeof(dest));
1604 srcsz = -1;
1605 destsz = sizeof(dest);
1606 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1607 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1608 ok(srcsz == lstrlenW(src),
1609 "Expected %u, got %u\n", lstrlenW(src), srcsz);
1610 ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1611 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1612 "Expected rest of dest to be unchanged, got %s\n", dest);
1613 ok(destsz == lstrlenW(src),
1614 "Expected %u, got %u\n", lstrlenW(src), destsz);
1615
1616 /* lpnMultiCharCount is 0 */
1617 memset(dest, 'x', sizeof(dest));
1618 srcsz = lstrlenW(src) + 1;
1619 destsz = 0;
1620 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1621 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1622 ok(srcsz == lstrlenW(src) + 1,
1623 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1624 ok(!memcmp(dest, invariate, sizeof(dest)),
1625 "Expected dest to be unchanged, got %s\n", dest);
1626 ok(destsz == lstrlenW(src) + 1,
1627 "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1628
1629 /* lpnMultiCharCount is not large enough */
1630 memset(dest, 'x', sizeof(dest));
1631 srcsz = lstrlenW(src) + 1;
1632 destsz = lstrlenW(src);
1633 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1634 ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
1635 ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
1636 ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1637 ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1638 "Expected rest of dest to be unchanged, got %s\n", dest);
1639 ok(destsz == 0, "Expected 0, got %u\n", srcsz);
1640
1641 /* lpnMultiCharCount (bytes) does not leave room for NULL terminator */
1642 memset(dest, 'x', sizeof(dest));
1643 srcsz = lstrlenW(src) + 1;
1644 destsz = lstrlenW(src) * sizeof(WCHAR);
1645 hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1646 ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1647 ok(srcsz == lstrlenW(src) + 1,
1648 "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1649 ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
1650 ok(destsz == lstrlenW(src) + 1,
1651 "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1652 }
1653
1654 static void test_JapaneseConversion(void)
1655 {
1656 /* Data */
1657 static WCHAR unc_jp[9][12] = {
1658 {9,0x31,0x20,0x3042,0x3044,0x3046,0x3048,0x304a,0x000d,0x000a},
1659 {9,0x31,0x20,0x30a2,0x30a4,0x30a6,0x30a8,0x30aa,0x000d,0x000a},
1660 {9,0x31,0x20,0xff71,0xff72,0xff73,0xff74,0xff75,0x000d,0x000a},
1661 {9,0x31,0x20,0x3041,0x3043,0x3045,0x3047,0x3049,0x000d,0x000a},
1662 {9,0x31,0x20,0x30a1,0x30a3,0x30a5,0x30a7,0x30a9,0x000d,0x000a},
1663 {9,0x31,0x20,0xff67,0xff68,0xff69,0xff6a,0xff6b,0x000d,0x000a},
1664 {9,0x31,0x20,0x300c,0x65e5,0x672c,0x8a9e,0x300d,0x000d,0x000a},
1665 {7,0x31,0x20,0x25c7,0x25c7,0x3012,0x000d,0x000a},
1666 {11,0x31,0x20,0x203b,0x3010,0x0074,0x0065,0x0073,0x0074,0x3011,0x000d,0x000a}
1667 };
1668 static CHAR jis_jp[9][27] = {
1669 {20,0x31,0x20,0x1b,0x24,0x42,0x24,0x22,0x24,0x24,0x24,0x26,0x24,0x28,
1670 0x24,0x2a,0x1b,0x28,0x42,0x0d,0x0a},
1671 {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x22,0x25,0x24,0x25,0x26,0x25,0x28,
1672 0x25,0x2a,0x1b,0x28,0x42,0x0d,0x0a},
1673 {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x22,0x25,0x24,0x25,0x26,0x25,0x28,
1674 0x25,0x2a,0x1b,0x28,0x42,0x0d,0x0a},
1675 {20,0x31,0x20,0x1b,0x24,0x42,0x24,0x21,0x24,0x23,0x24,0x25,0x24,0x27,
1676 0x24,0x29,0x1b,0x28,0x42,0x0d,0x0a},
1677 {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x21,0x25,0x23,0x25,0x25,0x25,0x27,
1678 0x25,0x29,0x1b,0x28,0x42,0x0d,0x0a},
1679 {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x21,0x25,0x23,0x25,0x25,0x25,0x27,
1680 0x25,0x29,0x1b,0x28,0x42,0x0d,0x0a},
1681 {20,0x31,0x20,0x1b,0x24,0x42,0x21,0x56,0x46,0x7c,0x4b,0x5c,0x38,0x6c,
1682 0x21,0x57,0x1b,0x28,0x42,0x0d,0x0a},
1683 {16,0x31,0x20,0x1b,0x24,0x42,0x21,0x7e,0x21,0x7e,0x22,0x29,0x1b,0x28,
1684 0x42,0x0d,0x0a},
1685 {26,0x31,0x20,0x1b,0x24,0x42,0x22,0x28,0x21,0x5a,0x1b,0x28,0x42,0x74,
1686 0x65,0x73,0x74,0x1b,0x24,0x42,0x21,0x5b,0x1b,0x28,0x42,0x0d,0x0a}
1687 };
1688 static CHAR sjis_jp[9][15] = {
1689 {14,0x31,0x20,0x82,0xa0,0x82,0xa2,0x82,0xa4,0x82,0xa6,0x82,0xa8,0x0d,0x0a},
1690 {14,0x31,0x20,0x83,0x41,0x83,0x43,0x83,0x45,0x83,0x47,0x83,0x49,0x0d,0x0a},
1691 {9,0x31,0x20,0xb1,0xb2,0xb3,0xb4,0xb5,0x0d,0x0a},
1692 {14,0x31,0x20,0x82,0x9f,0x82,0xa1,0x82,0xa3,0x82,0xa5,0x82,0xa7,0x0d,0x0a},
1693 {14,0x31,0x20,0x83,0x40,0x83,0x42,0x83,0x44,0x83,0x46,0x83,0x48,0x0d,0x0a},
1694 {9,0x31,0x20,0xa7,0xa8,0xa9,0xaa,0xab,0x0d,0x0a},
1695 {14,0x31,0x20,0x81,0x75,0x93,0xfa,0x96,0x7b,0x8c,0xea,0x81,0x76,0x0d,0x0a},
1696 {10,0x31,0x20,0x81,0x9e,0x81,0x9e,0x81,0xa7,0x0d,0x0a},
1697 {14,0x31,0x20,0x81,0xa6,0x81,0x79,0x74,0x65,0x73,0x74,0x81,0x7a,0x0d,0x0a}
1698 };
1699 static CHAR euc_jp[9][15] = {
1700 {14,0x31,0x20,0xa4,0xa2,0xa4,0xa4,0xa4,0xa6,0xa4,0xa8,0xa4,0xaa,0x0d,0x0a},
1701 {14,0x31,0x20,0xa5,0xa2,0xa5,0xa4,0xa5,0xa6,0xa5,0xa8,0xa5,0xaa,0x0d,0x0a},
1702 {14,0x31,0x20,0x8e,0xb1,0x8e,0xb2,0x8e,0xb3,0x8e,0xb4,0x8e,0xb5,0x0d,0x0a},
1703 {14,0x31,0x20,0xa4,0xa1,0xa4,0xa3,0xa4,0xa5,0xa4,0xa7,0xa4,0xa9,0x0d,0x0a},
1704 {14,0x31,0x20,0xa5,0xa1,0xa5,0xa3,0xa5,0xa5,0xa5,0xa7,0xa5,0xa9,0x0d,0x0a},
1705 {14,0x31,0x20,0x8e,0xa7,0x8e,0xa8,0x8e,0xa9,0x8e,0xaa,0x8e,0xab,0x0d,0x0a},
1706 {14,0x31,0x20,0xa1,0xd6,0xc6,0xfc,0xcb,0xdc,0xb8,0xec,0xa1,0xd7,0x0d,0x0a},
1707 {10,0x31,0x20,0xa1,0xfe,0xa1,0xfe,0xa2,0xa9,0x0d,0x0a},
1708 {14,0x31,0x20,0xa2,0xa8,0xa1,0xda,0x74,0x65,0x73,0x74,0xa1,0xdb,0x0d,0x0a}
1709 };
1710
1711 INT srcsz, destsz;
1712 INT i;
1713 HRESULT hr;
1714 CHAR output[30];
1715 WCHAR outputW[30];
1716 int outlen;
1717
1718 /* test unc->jis */
1719 for (i = 0; i < 9; i++)
1720 {
1721 int j;
1722 destsz = 30;
1723 outlen = jis_jp[i][0];
1724 srcsz = unc_jp[i][0];
1725 hr = pConvertINetUnicodeToMultiByte(NULL, 50220, &unc_jp[i][1], &srcsz, output, &destsz);
1726 if (hr == S_FALSE)
1727 {
1728 skip("Code page identifier 50220 is not supported\n");
1729 break;
1730 }
1731 ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n", i, hr);
1732 ok(destsz == outlen, "(%i) Expected %i, got %i\n",i,outlen,destsz);
1733 ok(srcsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],srcsz);
1734 ok(memcmp(output,&jis_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1735
1736 /* and back */
1737 srcsz = outlen;
1738 destsz = 30;
1739 hr = pConvertINetMultiByteToUnicode(NULL, 50220, output, &srcsz, outputW,&destsz);
1740
1741 /*
1742 * JIS does not have hankata so it get automatically converted to
1743 * zenkata. this means that strings 1 and 2 are identical as well as
1744 * strings 4 and 5.
1745 */
1746 j = i;
1747 if (i == 2) j = 1;
1748 if (i == 5) j = 4;
1749
1750 ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i, hr);
1751 ok(destsz == unc_jp[j][0],"(%i) Expected %i, got %i\n",i,unc_jp[j][0],destsz);
1752 ok(srcsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,srcsz);
1753 ok(memcmp(outputW,&unc_jp[j][1],destsz)==0,"(%i) Strings do not match\n",i);
1754 }
1755
1756 /* test unc->sjis */
1757 for (i = 0; i < 9; i++)
1758 {
1759 destsz = 30;
1760 outlen = sjis_jp[i][0];
1761 srcsz = unc_jp[i][0];
1762
1763 hr = pConvertINetUnicodeToMultiByte(NULL, 932, &unc_jp[i][1], &srcsz, output, &destsz);
1764 if (hr == S_FALSE)
1765 {
1766 skip("Code page identifier 932 is not supported\n");
1767 break;
1768 }
1769 ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1770 ok(destsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,destsz);
1771 ok(srcsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],srcsz);
1772 ok(memcmp(output,&sjis_jp[i][1],outlen)==0,"(%i) Strings do not match\n",i);
1773
1774 srcsz = outlen;
1775 destsz = 30;
1776 hr = pConvertINetMultiByteToUnicode(NULL, 932, output, &srcsz, outputW,&destsz);
1777
1778 ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n", i, hr);
1779 ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1780 ok(srcsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,srcsz);
1781 ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1782 }
1783
1784 /* test unc->euc */
1785 for (i = 0; i < 9; i++)
1786 {
1787 destsz = 30;
1788 outlen = euc_jp[i][0];
1789 srcsz = unc_jp[i][0];
1790
1791 hr = pConvertINetUnicodeToMultiByte(NULL, 51932, &unc_jp[i][1], &srcsz, output, &destsz);
1792 if (hr == S_FALSE)
1793 {
1794 skip("Code page identifier 51932 is not supported\n");
1795 break;
1796 }
1797 ok(hr == S_OK, "(%i) Expected S_OK, got %08x\n",i,hr);
1798 ok(destsz == outlen, "(%i) Expected %i, got %i\n",i,outlen,destsz);
1799 ok(srcsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1800 ok(memcmp(output,&euc_jp[i][1],outlen)==0,"(%i) Strings do not match\n",i);
1801
1802 srcsz = outlen;
1803 destsz = 30;
1804 hr = pConvertINetMultiByteToUnicode(NULL, 51932, output, &srcsz, outputW,&destsz);
1805
1806 ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1807 ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1808 ok(srcsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,srcsz);
1809 ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1810 }
1811
1812 /* Japanese autodetect */
1813 i = 0;
1814 destsz = 30;
1815 srcsz = jis_jp[i][0];
1816 hr = pConvertINetMultiByteToUnicode(NULL, 50932, &jis_jp[i][1], &srcsz, outputW, &destsz);
1817 if (hr == S_FALSE)
1818 {
1819 skip("Code page identifier 50932 is not supported\n");
1820 return;
1821 }
1822 ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1823 ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1824 ok(srcsz == jis_jp[i][0],"(%i) Expected %i, got %i\n",i,jis_jp[i][0],srcsz);
1825 ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1826
1827 i = 1;
1828 destsz = 30;
1829 srcsz = sjis_jp[i][0];
1830 hr = pConvertINetMultiByteToUnicode(NULL, 50932, &sjis_jp[i][1], &srcsz, outputW, &destsz);
1831 ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1832 ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1833 ok(srcsz == sjis_jp[i][0],"(%i) Expected %i, got %i\n",i,sjis_jp[i][0],srcsz);
1834 ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1835 }
1836
1837 static void test_GetScriptFontInfo(IMLangFontLink2 *font_link)
1838 {
1839 HRESULT hr;
1840 UINT nfonts;
1841 SCRIPTFONTINFO sfi[1];
1842
1843 nfonts = 0;
1844 hr = IMLangFontLink2_GetScriptFontInfo(font_link, sidAsciiLatin, 0, &nfonts, NULL);
1845 ok(hr == S_OK, "GetScriptFontInfo failed %u\n", GetLastError());
1846 ok(nfonts, "unexpected result\n");
1847
1848 nfonts = 0;
1849 hr = IMLangFontLink2_GetScriptFontInfo(font_link, sidAsciiLatin, SCRIPTCONTF_FIXED_FONT, &nfonts, NULL);
1850 ok(hr == S_OK, "GetScriptFontInfo failed %u\n", GetLastError());
1851 ok(nfonts, "unexpected result\n");
1852
1853 nfonts = 0;
1854 hr = IMLangFontLink2_GetScriptFontInfo(font_link, sidAsciiLatin, SCRIPTCONTF_PROPORTIONAL_FONT, &nfonts, NULL);
1855 ok(hr == S_OK, "GetScriptFontInfo failed %u\n", GetLastError());
1856 ok(nfonts, "unexpected result\n");
1857
1858 nfonts = 1;
1859 memset(sfi, 0, sizeof(sfi));
1860 hr = IMLangFontLink2_GetScriptFontInfo(font_link, sidAsciiLatin, SCRIPTCONTF_FIXED_FONT, &nfonts, sfi);
1861 ok(hr == S_OK, "GetScriptFontInfo failed %u\n", GetLastError());
1862 ok(nfonts == 1, "got %u, expected 1\n", nfonts);
1863 ok(sfi[0].scripts != 0, "unexpected result\n");
1864 ok(sfi[0].wszFont[0], "unexpected result\n");
1865
1866 nfonts = 1;
1867 memset(sfi, 0, sizeof(sfi));
1868 hr = IMLangFontLink2_GetScriptFontInfo(font_link, sidAsciiLatin, SCRIPTCONTF_PROPORTIONAL_FONT, &nfonts, sfi);
1869 ok(hr == S_OK, "GetScriptFontInfo failed %u\n", GetLastError());
1870 ok(nfonts == 1, "got %u, expected 1\n", nfonts);
1871 ok(sfi[0].scripts != 0, "unexpected result\n");
1872 ok(sfi[0].wszFont[0], "unexpected result\n");
1873 }
1874
1875 static void test_CodePageToScriptID(IMLangFontLink2 *font_link)
1876 {
1877 HRESULT hr;
1878 UINT i;
1879 SCRIPT_ID sid;
1880 static const struct
1881 {
1882 UINT cp;
1883 SCRIPT_ID sid;
1884 HRESULT hr;
1885 }
1886 cp_sid[] =
1887 {
1888 {874, sidThai},
1889 {932, sidKana},
1890 {936, sidHan},
1891 {949, sidHangul},
1892 {950, sidBopomofo},
1893 {1250, sidAsciiLatin},
1894 {1251, sidCyrillic},
1895 {1252, sidAsciiLatin},
1896 {1253, sidGreek},
1897 {1254, sidAsciiLatin},
1898 {1255, sidHebrew},
1899 {1256, sidArabic},
1900 {1257, sidAsciiLatin},
1901 {1258, sidAsciiLatin},
1902 {CP_UNICODE, 0, E_FAIL}
1903 };
1904
1905 for (i = 0; i < sizeof(cp_sid)/sizeof(cp_sid[0]); i++)
1906 {
1907 hr = IMLangFontLink2_CodePageToScriptID(font_link, cp_sid[i].cp, &sid);
1908 ok(hr == cp_sid[i].hr, "%u CodePageToScriptID failed 0x%08x %u\n", i, hr, GetLastError());
1909 if (SUCCEEDED(hr))
1910 {
1911 ok(sid == cp_sid[i].sid,
1912 "%u got sid %u for codepage %u, expected %u\n", i, sid, cp_sid[i].cp, cp_sid[i].sid);
1913 }
1914 }
1915 }
1916
1917 static void test_GetFontUnicodeRanges(IMLangFontLink2 *font_link)
1918 {
1919 HRESULT hr;
1920 UINT count;
1921 HFONT hfont, old_hfont;
1922 LOGFONTA lf;
1923 HDC hdc;
1924 UNICODERANGE *ur;
1925
1926 hdc = CreateCompatibleDC(0);
1927 memset(&lf, 0, sizeof(lf));
1928 lstrcpyA(lf.lfFaceName, "Arial");
1929 hfont = CreateFontIndirectA(&lf);
1930 old_hfont = SelectObject(hdc, hfont);
1931
1932 count = 0;
1933 hr = IMLangFontLink2_GetFontUnicodeRanges(font_link, NULL, &count, NULL);
1934 ok(hr == E_FAIL, "expected E_FAIL, got 0x%08x\n", hr);
1935
1936 hr = IMLangFontLink2_GetFontUnicodeRanges(font_link, hdc, NULL, NULL);
1937 ok(hr == E_INVALIDARG, "expected E_FAIL, got 0x%08x\n", hr);
1938
1939 count = 0;
1940 hr = IMLangFontLink2_GetFontUnicodeRanges(font_link, hdc, &count, NULL);
1941 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1942 ok(count, "expected count > 0\n");
1943
1944 ur = HeapAlloc(GetProcessHeap(), 0, sizeof(*ur) * count);
1945
1946 hr = IMLangFontLink2_GetFontUnicodeRanges(font_link, hdc, &count, ur);
1947 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1948
1949 count--;
1950 hr = IMLangFontLink2_GetFontUnicodeRanges(font_link, hdc, &count, ur);
1951 ok(hr == S_OK, "expected S_OK, got 0x%08x\n", hr);
1952
1953 HeapFree(GetProcessHeap(), 0, ur);
1954
1955 SelectObject(hdc, old_hfont);
1956 DeleteObject(hfont);
1957 DeleteDC(hdc);
1958 }
1959
1960 static void test_IsCodePageInstallable(IMultiLanguage2 *ml2)
1961 {
1962 UINT i;
1963 HRESULT hr;
1964
1965 SetLastError(0xdeadbeef);
1966 lstrcmpW(NULL, NULL);
1967 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1968 {
1969 /* This corruption leads (sometimes) to test failures in oleaut32 but also
1970 * to the inability to use the Regional Settings.
1971 * This only seems to be an issue with Win98 and IE6 (mlang version 6.0.2800.1106).
1972 *
1973 * A reboot restores the codepages again.
1974 */
1975 win_skip("IsCodePageInstallable could mess up the codepages on Win98\n");
1976 return;
1977 }
1978
1979 for (i = 0; i < 0xffff; i++)
1980 {
1981 hr = IMultiLanguage2_IsCodePageInstallable(ml2, i);
1982
1983 /* it would be better to use IMultiLanguage2_ValidateCodePageEx here but that brings
1984 * up an installation dialog on some platforms, even when specifying CPIOD_PEEK.
1985 */
1986 if (IsValidCodePage(i))
1987 ok(hr == S_OK, "code page %u is valid but not installable 0x%08x\n", i, hr);
1988 }
1989 }
1990
1991 START_TEST(mlang)
1992 {
1993 IMultiLanguage *iML = NULL;
1994 IMultiLanguage2 *iML2 = NULL;
1995 IMLangFontLink *iMLFL = NULL;
1996 IMLangFontLink2 *iMLFL2 = NULL;
1997 HRESULT ret;
1998
1999 if (!init_function_ptrs())
2000 return;
2001
2002 CoInitialize(NULL);
2003 test_Rfc1766ToLcid();
2004 test_LcidToRfc1766();
2005
2006 test_ConvertINetUnicodeToMultiByte();
2007 test_JapaneseConversion();
2008
2009
2010 trace("IMultiLanguage\n");
2011 ret = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
2012 &IID_IMultiLanguage, (void **)&iML);
2013 if (ret != S_OK || !iML) return;
2014
2015 test_GetNumberOfCodePageInfo((IMultiLanguage2 *)iML);
2016 IMultiLanguage_Release(iML);
2017
2018
2019 /* IMultiLanguage2 (IE5.0 and above) */
2020 trace("IMultiLanguage2\n");
2021 ret = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
2022 &IID_IMultiLanguage2, (void **)&iML2);
2023 if (ret != S_OK || !iML2) return;
2024
2025 test_rfc1766(iML2);
2026 test_GetLcidFromRfc1766(iML2);
2027 test_GetRfc1766FromLcid(iML2);
2028 test_GetRfc1766Info(iML2);
2029 test_GetNumberOfCodePageInfo(iML2);
2030
2031 test_EnumCodePages(iML2, 0);
2032 test_EnumCodePages(iML2, MIMECONTF_MIME_LATEST);
2033 test_EnumCodePages(iML2, MIMECONTF_BROWSER);
2034 test_EnumCodePages(iML2, MIMECONTF_MINIMAL);
2035 test_EnumCodePages(iML2, MIMECONTF_VALID);
2036 /* FIXME: why MIMECONTF_MIME_REGISTRY returns 0 of supported codepages? */
2037 /*test_EnumCodePages(iML2, MIMECONTF_MIME_REGISTRY);*/
2038
2039 test_EnumScripts(iML2, 0);
2040 test_EnumScripts(iML2, SCRIPTCONTF_SCRIPT_USER);
2041 test_EnumScripts(iML2, SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM);
2042
2043 ret = IMultiLanguage2_IsConvertible(iML2, CP_UTF8, CP_UNICODE);
2044 ok(ret == S_OK, "IMultiLanguage2_IsConvertible(CP_UTF8 -> CP_UNICODE) = %08x\n", ret);
2045 ret = IMultiLanguage2_IsConvertible(iML2, CP_UNICODE, CP_UTF8);
2046 ok(ret == S_OK, "IMultiLanguage2_IsConvertible(CP_UNICODE -> CP_UTF8) = %08x\n", ret);
2047
2048 test_multibyte_to_unicode_translations(iML2);
2049 test_IMultiLanguage2_ConvertStringFromUnicode(iML2);
2050
2051 test_IsCodePageInstallable(iML2);
2052
2053 IMultiLanguage2_Release(iML2);
2054
2055
2056 /* IMLangFontLink */
2057 ret = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
2058 &IID_IMLangFontLink, (void **)&iMLFL);
2059 if (ret != S_OK || !iMLFL) return;
2060
2061 IMLangFontLink_Test(iMLFL);
2062 IMLangFontLink_Release(iMLFL);
2063
2064 /* IMLangFontLink2 */
2065 ret = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
2066 &IID_IMLangFontLink2, (void **)&iMLFL2);
2067 if (ret != S_OK || !iMLFL2) return;
2068
2069 test_GetScriptFontInfo(iMLFL2);
2070 test_GetFontUnicodeRanges(iMLFL2);
2071 test_CodePageToScriptID(iMLFL2);
2072 IMLangFontLink2_Release(iMLFL2);
2073
2074 CoUninitialize();
2075 }
A free Windows-compatible Operating System