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