dlls/mlang/tests/mlang.c

   1 /*
   2  * Unit test suite for MLANG APIs.
   3  *
   4  * Copyright 2004 Dmitry Timoshkov
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2.1 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, write to the Free Software
  18  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  19  */
  20
  21 #define COBJMACROS
  22
  23 #include <stdarg.h>
  24
  25 #include "windef.h"
  26 #include "winbase.h"
  27 #include "winerror.h"
  28 #include "initguid.h"
  29 #include "mlang.h"
  30
  31 #include "wine/test.h"
  32
  33 #ifndef CP_UNICODE
  34 #define CP_UNICODE 1200
  35 #endif
  36
  37 #if 0
  38 #define DUMP_CP_INFO
  39 #define DUMP_SCRIPT_INFO
  40
  41 #if defined DUMP_CP_INFO || defined DUMP_SCRIPT_INFO
  42 #include "wine/debug.h"
  43 #endif
  44 #endif /* 0 */
  45
  46 static BOOL (WINAPI *pGetCPInfoExA)(UINT, DWORD, LPCPINFOEXA);
  47 static HRESULT (WINAPI *pConvertINetMultiByteToUnicode)(LPDWORD, DWORD, LPCSTR,
  48                                                         LPINT, LPWSTR, LPINT);
  49 static HRESULT (WINAPI *pConvertINetUnicodeToMultiByte)(LPDWORD, DWORD, LPCWSTR,
  50                                                         LPINT, LPSTR, LPINT);
  51
  52 static BOOL init_function_ptrs(void)
  53 {
  54     HMODULE hMlang;
  55
  56     hMlang = LoadLibraryA("mlang.dll");
  57     if (!hMlang)
  58     {
  59         skip("mlang not available\n");
  60         return FALSE;
  61     }
  62
  63     pConvertINetMultiByteToUnicode = (void *)GetProcAddress(hMlang, "ConvertINetMultiByteToUnicode");
  64     pConvertINetUnicodeToMultiByte = (void *)GetProcAddress(hMlang, "ConvertINetUnicodeToMultiByte");
  65
  66     pGetCPInfoExA = (void *)GetProcAddress(GetModuleHandleA("kernel32.dll"), "GetCPInfoExA");
  67
  68     return TRUE;
  69 }
  70
  71 #define ok_w2(format, szString1, szString2) \
  72 \
  73     if (lstrcmpW((szString1), (szString2)) != 0) \
  74     { \
  75         CHAR string1[256], string2[256]; \
  76         WideCharToMultiByte(CP_ACP, 0, (szString1), -1, string1, 256, NULL, NULL); \
  77         WideCharToMultiByte(CP_ACP, 0, (szString2), -1, string2, 256, NULL, NULL); \
  78         ok(0, (format), string1, string2); \
  79     }
  80
  81 static void test_multibyte_to_unicode_translations(IMultiLanguage2 *iML2)
  82 {
  83     /* these APIs are broken regarding constness of the input buffer */
  84     char stringA[] = "Just a test string\0"; /* double 0 for CP_UNICODE tests */
  85     WCHAR stringW[] = {'J','u','s','t',' ','a',' ','t','e','s','t',' ','s','t','r','i','n','g',0};
  86     char bufA[256];
  87     WCHAR bufW[256];
  88     UINT lenA, lenW, expected_len;
  89     HRESULT ret;
  90
  91     /* IMultiLanguage2_ConvertStringToUnicode tests */
  92
  93     memset(bufW, 'x', sizeof(bufW));
  94     lenA = 0;
  95     lenW = sizeof(bufW)/sizeof(bufW[0]);
  96     ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, bufW, &lenW);
  97     ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
  98     ok(lenA == 0, "expected lenA 0, got %u\n", lenA);
  99     ok(lenW == 0, "expected lenW 0, got %u\n", lenW);
 100
 101     memset(bufW, 'x', sizeof(bufW));
 102     lenA = -1;
 103     lenW = sizeof(bufW)/sizeof(bufW[0]);
 104     ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, bufW, &lenW);
 105     ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
 106     ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
 107     ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
 108     if (lenW < sizeof(bufW)/sizeof(bufW[0])) {
 109        /* can only happen if the convert call fails */
 110        ok(bufW[lenW] != 0, "buf should not be 0 terminated\n");
 111        bufW[lenW] = 0; /* -1 doesn't include 0 terminator */
 112     }
 113     ok(!lstrcmpW(bufW, stringW), "bufW/stringW mismatch\n");
 114
 115     memset(bufW, 'x', sizeof(bufW));
 116     lenA = -1;
 117     lenW = 5;
 118     ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, bufW, &lenW);
 119     ok(ret == E_FAIL, "IMultiLanguage2_ConvertStringToUnicode should fail: %08x\n", ret);
 120     ok(lenW == 0, "expected lenW 0, got %u\n", lenW);
 121     /* still has to do partial conversion */
 122     ok(!memcmp(bufW, stringW, 5 * sizeof(WCHAR)), "bufW/stringW mismatch\n");
 123
 124     memset(bufW, 'x', sizeof(bufW));
 125     lenA = -1;
 126     lenW = sizeof(bufW)/sizeof(bufW[0]);
 127     ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, CP_UNICODE, stringA, &lenA, bufW, &lenW);
 128     ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
 129     ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
 130     ok(lenW == lstrlenW(stringW)/(int)sizeof(WCHAR), "wrong lenW %u\n", lenW);
 131     ok(bufW[lenW] != 0, "buf should not be 0 terminated\n");
 132     bufW[lenW] = 0; /* -1 doesn't include 0 terminator */
 133     ok(!lstrcmpA((LPCSTR)bufW, stringA), "bufW/stringA mismatch\n");
 134
 135     memset(bufW, 'x', sizeof(bufW));
 136     lenA = lstrlenA(stringA);
 137     lenW = 0;
 138     ret = IMultiLanguage2_ConvertStringToUnicode(iML2, NULL, 1252, stringA, &lenA, NULL, &lenW);
 139     ok(ret == S_OK, "IMultiLanguage2_ConvertStringToUnicode failed: %08x\n", ret);
 140     ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
 141     expected_len = MultiByteToWideChar(1252, 0, stringA, lenA, NULL, 0);
 142     ok(lenW == expected_len, "expected lenW %u, got %u\n", expected_len, lenW);
 143
 144     memset(bufW, 'x', sizeof(bufW));
 145     lenA = lstrlenA(stringA);
 146     lenW = sizeof(bufW)/sizeof(bufW[0]);
 147     ret = pConvertINetMultiByteToUnicode(NULL, 1252, stringA, (INT *)&lenA, NULL, (INT *)&lenW);
 148     ok(ret == S_OK, "ConvertINetMultiByteToUnicode failed: %08x\n", ret);
 149     ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
 150     expected_len = MultiByteToWideChar(1252, 0, stringA, lenA, NULL, 0);
 151     ok(lenW == expected_len, "expected lenW %u, got %u\n", expected_len, lenW);
 152
 153     memset(bufW, 'x', sizeof(bufW));
 154     lenA = lstrlenA(stringA);
 155     lenW = 0;
 156     ret = pConvertINetMultiByteToUnicode(NULL, 1252, stringA, (INT *)&lenA, NULL, (INT *)&lenW);
 157     ok(ret == S_OK, "ConvertINetMultiByteToUnicode failed: %08x\n", ret);
 158     ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
 159     expected_len = MultiByteToWideChar(1252, 0, stringA, lenA, NULL, 0);
 160     ok(lenW == expected_len, "expected lenW %u, got %u\n", expected_len, lenW);
 161
 162     /* IMultiLanguage2_ConvertStringFromUnicode tests */
 163
 164     memset(bufA, 'x', sizeof(bufA));
 165     lenW = 0;
 166     lenA = sizeof(bufA);
 167     ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, bufA, &lenA);
 168     ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
 169     ok(lenA == 0, "expected lenA 0, got %u\n", lenA);
 170     ok(lenW == 0, "expected lenW 0, got %u\n", lenW);
 171
 172     memset(bufA, 'x', sizeof(bufA));
 173     lenW = -1;
 174     lenA = sizeof(bufA);
 175     ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, bufA, &lenA);
 176     ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
 177     ok(lenA == lstrlenA(stringA), "expected lenA %u, got %u\n", lstrlenA(stringA), lenA);
 178     ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
 179     ok(bufA[lenA] != 0, "buf should not be 0 terminated\n");
 180     bufA[lenA] = 0; /* -1 doesn't include 0 terminator */
 181     ok(!lstrcmpA(bufA, stringA), "bufA/stringA mismatch\n");
 182
 183     memset(bufA, 'x', sizeof(bufA));
 184     lenW = -1;
 185     lenA = 5;
 186     ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, bufA, &lenA);
 187     ok(ret == E_FAIL, "IMultiLanguage2_ConvertStringFromUnicode should fail: %08x\n", ret);
 188     ok(lenA == 0, "expected lenA 0, got %u\n", lenA);
 189     /* still has to do partial conversion */
 190     ok(!memcmp(bufA, stringA, 5), "bufW/stringW mismatch\n");
 191
 192     memset(bufA, 'x', sizeof(bufA));
 193     lenW = -1;
 194     lenA = sizeof(bufA);
 195     ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, CP_UNICODE, stringW, &lenW, bufA, &lenA);
 196     ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
 197     ok(lenA == lstrlenA(stringA) * (int)sizeof(WCHAR), "wrong lenA %u\n", lenA);
 198     ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
 199     ok(bufA[lenA] != 0 && bufA[lenA+1] != 0, "buf should not be 0 terminated\n");
 200     bufA[lenA] = 0; /* -1 doesn't include 0 terminator */
 201     bufA[lenA+1] = 0; /* sizeof(WCHAR) */
 202     ok(!lstrcmpW((LPCWSTR)bufA, stringW), "bufA/stringW mismatch\n");
 203
 204     memset(bufA, 'x', sizeof(bufA));
 205     lenW = lstrlenW(stringW);
 206     lenA = 0;
 207     ret = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, stringW, &lenW, NULL, &lenA);
 208     ok(ret == S_OK, "IMultiLanguage2_ConvertStringFromUnicode failed: %08x\n", ret);
 209     ok(lenW == lstrlenW(stringW), "expected lenW %u, got %u\n", lstrlenW(stringW), lenW);
 210     expected_len = WideCharToMultiByte(1252, 0, stringW, lenW, NULL, 0, NULL, NULL);
 211     ok(lenA == expected_len, "expected lenA %u, got %u\n", expected_len, lenA);
 212 }
 213
 214 static inline void cpinfo_cmp(MIMECPINFO *cpinfo1, MIMECPINFO *cpinfo2)
 215 {
 216     ok(cpinfo1->dwFlags == cpinfo2->dwFlags, "dwFlags mismatch: %08x != %08x\n", cpinfo1->dwFlags, cpinfo2->dwFlags);
 217     ok(cpinfo1->uiCodePage == cpinfo2->uiCodePage, "uiCodePage mismatch: %u != %u\n", cpinfo1->uiCodePage, cpinfo2->uiCodePage);
 218     ok(cpinfo1->uiFamilyCodePage == cpinfo2->uiFamilyCodePage, "uiFamilyCodePage mismatch: %u != %u\n", cpinfo1->uiFamilyCodePage, cpinfo2->uiFamilyCodePage);
 219     ok(!lstrcmpW(cpinfo1->wszDescription, cpinfo2->wszDescription), "wszDescription mismatch\n");
 220     ok(!lstrcmpW(cpinfo1->wszWebCharset, cpinfo2->wszWebCharset), "wszWebCharset mismatch\n");
 221     ok(!lstrcmpW(cpinfo1->wszHeaderCharset, cpinfo2->wszHeaderCharset), "wszHeaderCharset mismatch\n");
 222     ok(!lstrcmpW(cpinfo1->wszBodyCharset, cpinfo2->wszBodyCharset), "wszBodyCharset mismatch\n");
 223     ok(!lstrcmpW(cpinfo1->wszFixedWidthFont, cpinfo2->wszFixedWidthFont), "wszFixedWidthFont mismatch\n");
 224     ok(!lstrcmpW(cpinfo1->wszProportionalFont, cpinfo2->wszProportionalFont), "wszProportionalFont mismatch\n");
 225     ok(cpinfo1->bGDICharset == cpinfo2->bGDICharset, "bGDICharset mismatch: %d != %d\n", cpinfo1->bGDICharset, cpinfo2->bGDICharset);
 226 }
 227
 228 #ifdef DUMP_CP_INFO
 229 static const char *dump_mime_flags(DWORD flags)
 230 {
 231     static char buf[1024];
 232
 233     buf[0] = 0;
 234
 235     if (flags & MIMECONTF_MAILNEWS) strcat(buf, " MIMECONTF_MAILNEWS");
 236     if (flags & MIMECONTF_BROWSER) strcat(buf, " MIMECONTF_BROWSER");
 237     if (flags & MIMECONTF_MINIMAL) strcat(buf, " MIMECONTF_MINIMAL");
 238     if (flags & MIMECONTF_IMPORT) strcat(buf, " MIMECONTF_IMPORT");
 239     if (flags & MIMECONTF_SAVABLE_MAILNEWS) strcat(buf, " MIMECONTF_SAVABLE_MAILNEWS");
 240     if (flags & MIMECONTF_SAVABLE_BROWSER) strcat(buf, " MIMECONTF_SAVABLE_BROWSER");
 241     if (flags & MIMECONTF_EXPORT) strcat(buf, " MIMECONTF_EXPORT");
 242     if (flags & MIMECONTF_PRIVCONVERTER) strcat(buf, " MIMECONTF_PRIVCONVERTER");
 243     if (flags & MIMECONTF_VALID) strcat(buf, " MIMECONTF_VALID");
 244     if (flags & MIMECONTF_VALID_NLS) strcat(buf, " MIMECONTF_VALID_NLS");
 245     if (flags & MIMECONTF_MIME_IE4) strcat(buf, " MIMECONTF_MIME_IE4");
 246     if (flags & MIMECONTF_MIME_LATEST) strcat(buf, " MIMECONTF_MIME_LATEST");
 247     if (flags & MIMECONTF_MIME_REGISTRY) strcat(buf, " MIMECONTF_MIME_REGISTRY");
 248
 249     return buf;
 250 }
 251 #endif
 252
 253 static BOOL check_convertible(IMultiLanguage2 *iML2, UINT from, UINT to)
 254 {
 255     CHAR convert[MAX_PATH];
 256     BYTE dest[MAX_PATH];
 257     HRESULT hr;
 258     UINT srcsz, destsz;
 259
 260     static WCHAR strW[] = {'a','b','c',0};
 261
 262     srcsz = lstrlenW(strW) + 1;
 263     destsz = MAX_PATH;
 264     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, from, strW,
 265                                                   &srcsz, convert, &destsz);
 266     if (hr != S_OK)
 267         return FALSE;
 268
 269     srcsz = -1;
 270     destsz = MAX_PATH;
 271     hr = IMultiLanguage2_ConvertString(iML2, NULL, from, to, (BYTE *)convert,
 272                                        &srcsz, dest, &destsz);
 273     if (hr != S_OK)
 274         return FALSE;
 275
 276     return TRUE;
 277 }
 278
 279 static void test_EnumCodePages(IMultiLanguage2 *iML2, DWORD flags)
 280 {
 281     IEnumCodePage *iEnumCP = NULL;
 282     MIMECPINFO *cpinfo;
 283     MIMECPINFO cpinfo2;
 284     HRESULT ret;
 285     ULONG i, n;
 286     UINT total;
 287
 288     total = 0;
 289     ret = IMultiLanguage2_GetNumberOfCodePageInfo(iML2, &total);
 290     ok(ret == S_OK && total != 0, "IMultiLanguage2_GetNumberOfCodePageInfo: expected S_OK/!0, got %08x/%u\n", ret, total);
 291
 292     trace("total mlang supported codepages %u\n", total);
 293
 294     ret = IMultiLanguage2_EnumCodePages(iML2, flags, LANG_NEUTRAL, &iEnumCP);
 295     ok(ret == S_OK && iEnumCP, "IMultiLanguage2_EnumCodePages: expected S_OK/!NULL, got %08x/%p\n", ret, iEnumCP);
 296
 297     ret = IEnumCodePage_Reset(iEnumCP);
 298     ok(ret == S_OK, "IEnumCodePage_Reset: expected S_OK, got %08x\n", ret);
 299     n = 65536;
 300     ret = IEnumCodePage_Next(iEnumCP, 0, NULL, &n);
 301     ok(n == 0 && ret == S_FALSE, "IEnumCodePage_Next: expected 0/S_FALSE, got %u/%08x\n", n, ret);
 302     ret = IEnumCodePage_Next(iEnumCP, 0, NULL, NULL);
 303     ok(ret == S_FALSE, "IEnumCodePage_Next: expected S_FALSE, got %08x\n", ret);
 304
 305     cpinfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*cpinfo) * total * 2);
 306
 307     n = total * 2;
 308     ret = IEnumCodePage_Next(iEnumCP, 0, cpinfo, &n);
 309     ok(ret == S_FALSE && n == 0, "IEnumCodePage_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
 310
 311     n = total * 2;
 312     ret = IEnumCodePage_Next(iEnumCP, n, cpinfo, &n);
 313     ok(ret == S_OK && n != 0, "IEnumCodePage_Next: expected S_OK/!0, got %08x/%u\n", ret, n);
 314
 315     trace("flags %08x, enumerated codepages %u\n", flags, n);
 316
 317     if (!flags)
 318     {
 319         ok(n == total, "IEnumCodePage_Next: expected %u, got %u\n", total, n);
 320
 321         flags = MIMECONTF_MIME_LATEST;
 322     }
 323
 324     total = n;
 325
 326     for (i = 0; i < n; i++)
 327     {
 328         CHARSETINFO csi;
 329         MIMECSETINFO mcsi;
 330         BOOL convertible;
 331         HRESULT check = S_OK;
 332         static const WCHAR autoW[] = {'_','a','u','t','o',0};
 333
 334 #ifdef DUMP_CP_INFO
 335         trace("MIMECPINFO #%u:\n"
 336               "dwFlags %08x %s\n"
 337               "uiCodePage %u\n"
 338               "uiFamilyCodePage %u\n"
 339               "wszDescription %s\n"
 340               "wszWebCharset %s\n"
 341               "wszHeaderCharset %s\n"
 342               "wszBodyCharset %s\n"
 343               "wszFixedWidthFont %s\n"
 344               "wszProportionalFont %s\n"
 345               "bGDICharset %d\n\n",
 346               i,
 347               cpinfo[i].dwFlags, dump_mime_flags(cpinfo[i].dwFlags),
 348               cpinfo[i].uiCodePage,
 349               cpinfo[i].uiFamilyCodePage,
 350               wine_dbgstr_w(cpinfo[i].wszDescription),
 351               wine_dbgstr_w(cpinfo[i].wszWebCharset),
 352               wine_dbgstr_w(cpinfo[i].wszHeaderCharset),
 353               wine_dbgstr_w(cpinfo[i].wszBodyCharset),
 354               wine_dbgstr_w(cpinfo[i].wszFixedWidthFont),
 355               wine_dbgstr_w(cpinfo[i].wszProportionalFont),
 356               cpinfo[i].bGDICharset);
 357 #endif
 358         ok(cpinfo[i].dwFlags & flags, "enumerated flags %08x do not include requested %08x\n", cpinfo[i].dwFlags, flags);
 359
 360         if (TranslateCharsetInfo((DWORD *)cpinfo[i].uiFamilyCodePage, &csi, TCI_SRCCODEPAGE))
 361             ok(cpinfo[i].bGDICharset == csi.ciCharset, "%d != %d\n", cpinfo[i].bGDICharset, csi.ciCharset);
 362         else
 363             trace("TranslateCharsetInfo failed for cp %u\n", cpinfo[i].uiFamilyCodePage);
 364
 365 #ifdef DUMP_CP_INFO
 366         trace("%u: codepage %u family %u\n", i, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
 367 #endif
 368         /* Win95 does not support UTF-7 */
 369         if (cpinfo[i].uiCodePage == CP_UTF7) continue;
 370
 371         /* support files for some codepages might be not installed, or
 372          * the codepage is just an alias.
 373          */
 374         if (IsValidCodePage(cpinfo[i].uiCodePage))
 375         {
 376             ret = IMultiLanguage2_IsConvertible(iML2, cpinfo[i].uiCodePage, CP_UNICODE);
 377             ok(ret == S_OK, "IMultiLanguage2_IsConvertible(%u -> CP_UNICODE) = %08x\n", cpinfo[i].uiCodePage, ret);
 378             ret = IMultiLanguage2_IsConvertible(iML2, CP_UNICODE, cpinfo[i].uiCodePage);
 379             ok(ret == S_OK, "IMultiLanguage2_IsConvertible(CP_UNICODE -> %u) = %08x\n", cpinfo[i].uiCodePage, ret);
 380
 381             convertible = check_convertible(iML2, cpinfo[i].uiCodePage, CP_UTF8);
 382             if (!convertible)
 383                 check = S_FALSE;
 384
 385             ret = IMultiLanguage2_IsConvertible(iML2, cpinfo[i].uiCodePage, CP_UTF8);
 386             ok(ret == check, "IMultiLanguage2_IsConvertible(%u -> CP_UTF8) = %08x\n", cpinfo[i].uiCodePage, ret);
 387             ret = IMultiLanguage2_IsConvertible(iML2, CP_UTF8, cpinfo[i].uiCodePage);
 388             ok(ret == check, "IMultiLanguage2_IsConvertible(CP_UTF8 -> %u) = %08x\n", cpinfo[i].uiCodePage, ret);
 389         }
 390         else
 391             trace("IsValidCodePage failed for cp %u\n", cpinfo[i].uiCodePage);
 392
 393         ret = IMultiLanguage2_GetCharsetInfo(iML2, cpinfo[i].wszWebCharset, &mcsi);
 394         /* _autoxxx charsets are a fake and GetCharsetInfo fails for them */
 395         if (memcmp(cpinfo[i].wszWebCharset, autoW, 5 * sizeof(WCHAR)))
 396         {
 397             ok (ret == S_OK, "IMultiLanguage2_GetCharsetInfo failed: %08x\n", ret);
 398 #ifdef DUMP_CP_INFO
 399             trace("%s: %u %u %s\n", wine_dbgstr_w(cpinfo[i].wszWebCharset), mcsi.uiCodePage, mcsi.uiInternetEncoding, wine_dbgstr_w(mcsi.wszCharset));
 400 #endif
 401             ok(!lstrcmpiW(cpinfo[i].wszWebCharset, mcsi.wszCharset),
 402 #ifdef DUMP_CP_INFO
 403                 "%s != %s\n",
 404                 wine_dbgstr_w(cpinfo[i].wszWebCharset), wine_dbgstr_w(mcsi.wszCharset));
 405 #else
 406                 "wszWebCharset mismatch\n");
 407 #endif
 408
 409         if (0)
 410         {
 411             /* native mlang returns completely messed up encodings in some cases */
 412             ok(mcsi.uiInternetEncoding == cpinfo[i].uiCodePage || mcsi.uiInternetEncoding == cpinfo[i].uiFamilyCodePage,
 413                 "%u != %u || %u\n", mcsi.uiInternetEncoding, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
 414             ok(mcsi.uiCodePage == cpinfo[i].uiCodePage || mcsi.uiCodePage == cpinfo[i].uiFamilyCodePage,
 415                 "%u != %u || %u\n", mcsi.uiCodePage, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
 416         }
 417         }
 418
 419         ret = IMultiLanguage2_GetCharsetInfo(iML2, cpinfo[i].wszHeaderCharset, &mcsi);
 420         /* _autoxxx charsets are a fake and GetCharsetInfo fails for them */
 421         if (memcmp(cpinfo[i].wszHeaderCharset, autoW, 5 * sizeof(WCHAR)))
 422         {
 423             ok (ret == S_OK, "IMultiLanguage2_GetCharsetInfo failed: %08x\n", ret);
 424 #ifdef DUMP_CP_INFO
 425             trace("%s: %u %u %s\n", wine_dbgstr_w(cpinfo[i].wszHeaderCharset), mcsi.uiCodePage, mcsi.uiInternetEncoding, wine_dbgstr_w(mcsi.wszCharset));
 426 #endif
 427             ok(!lstrcmpiW(cpinfo[i].wszHeaderCharset, mcsi.wszCharset),
 428 #ifdef DUMP_CP_INFO
 429                 "%s != %s\n",
 430                 wine_dbgstr_w(cpinfo[i].wszHeaderCharset), wine_dbgstr_w(mcsi.wszCharset));
 431 #else
 432                 "wszHeaderCharset mismatch\n");
 433 #endif
 434
 435         if (0)
 436         {
 437             /* native mlang returns completely messed up encodings in some cases */
 438             ok(mcsi.uiInternetEncoding == cpinfo[i].uiCodePage || mcsi.uiInternetEncoding == cpinfo[i].uiFamilyCodePage,
 439                 "%u != %u || %u\n", mcsi.uiInternetEncoding, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
 440             ok(mcsi.uiCodePage == cpinfo[i].uiCodePage || mcsi.uiCodePage == cpinfo[i].uiFamilyCodePage,
 441                 "%u != %u || %u\n", mcsi.uiCodePage, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
 442         }
 443         }
 444
 445         ret = IMultiLanguage2_GetCharsetInfo(iML2, cpinfo[i].wszBodyCharset, &mcsi);
 446         /* _autoxxx charsets are a fake and GetCharsetInfo fails for them */
 447         if (memcmp(cpinfo[i].wszBodyCharset, autoW, 5 * sizeof(WCHAR)))
 448         {
 449             ok (ret == S_OK, "IMultiLanguage2_GetCharsetInfo failed: %08x\n", ret);
 450 #ifdef DUMP_CP_INFO
 451             trace("%s: %u %u %s\n", wine_dbgstr_w(cpinfo[i].wszBodyCharset), mcsi.uiCodePage, mcsi.uiInternetEncoding, wine_dbgstr_w(mcsi.wszCharset));
 452 #endif
 453             ok(!lstrcmpiW(cpinfo[i].wszBodyCharset, mcsi.wszCharset),
 454 #ifdef DUMP_CP_INFO
 455                 "%s != %s\n",
 456                 wine_dbgstr_w(cpinfo[i].wszBodyCharset), wine_dbgstr_w(mcsi.wszCharset));
 457 #else
 458                 "wszBodyCharset mismatch\n");
 459 #endif
 460
 461         if (0)
 462         {
 463             /* native mlang returns completely messed up encodings in some cases */
 464             ok(mcsi.uiInternetEncoding == cpinfo[i].uiCodePage || mcsi.uiInternetEncoding == cpinfo[i].uiFamilyCodePage,
 465                 "%u != %u || %u\n", mcsi.uiInternetEncoding, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
 466             ok(mcsi.uiCodePage == cpinfo[i].uiCodePage || mcsi.uiCodePage == cpinfo[i].uiFamilyCodePage,
 467                 "%u != %u || %u\n", mcsi.uiCodePage, cpinfo[i].uiCodePage, cpinfo[i].uiFamilyCodePage);
 468         }
 469         }
 470     }
 471
 472     /* now IEnumCodePage_Next should fail, since pointer is at the end */
 473     n = 1;
 474     ret = IEnumCodePage_Next(iEnumCP, 1, &cpinfo2, &n);
 475     ok(ret == S_FALSE && n == 0, "IEnumCodePage_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
 476
 477     ret = IEnumCodePage_Reset(iEnumCP);
 478     ok(ret == S_OK, "IEnumCodePage_Reset: expected S_OK, got %08x\n", ret);
 479     n = 0;
 480     ret = IEnumCodePage_Next(iEnumCP, 1, &cpinfo2, &n);
 481     ok(n == 1 && ret == S_OK, "IEnumCodePage_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
 482     cpinfo_cmp(&cpinfo[0], &cpinfo2);
 483
 484     if (0)
 485     {
 486     /* Due to a bug in MS' implementation of IEnumCodePage_Skip
 487      * it's not used here.
 488      */
 489     ret = IEnumCodePage_Skip(iEnumCP, 1);
 490     ok(ret == S_OK, "IEnumCodePage_Skip: expected S_OK, got %08x\n", ret);
 491     }
 492     for (i = 0; i < total - 1; i++)
 493     {
 494         n = 0;
 495         ret = IEnumCodePage_Next(iEnumCP, 1, &cpinfo2, &n);
 496         ok(n == 1 && ret == S_OK, "IEnumCodePage_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
 497         cpinfo_cmp(&cpinfo[i + 1], &cpinfo2);
 498     }
 499
 500     HeapFree(GetProcessHeap(), 0, cpinfo);
 501     IEnumCodePage_Release(iEnumCP);
 502 }
 503
 504 static inline void scriptinfo_cmp(SCRIPTINFO *sinfo1, SCRIPTINFO *sinfo2)
 505 {
 506     ok(sinfo1->ScriptId == sinfo2->ScriptId, "ScriptId mismatch: %d != %d\n", sinfo1->ScriptId, sinfo2->ScriptId);
 507     ok(sinfo1->uiCodePage == sinfo2->uiCodePage, "uiCodePage mismatch: %u != %u\n", sinfo1->uiCodePage, sinfo2->uiCodePage);
 508     ok(!lstrcmpW(sinfo1->wszDescription, sinfo2->wszDescription), "wszDescription mismatch\n");
 509     ok(!lstrcmpW(sinfo1->wszFixedWidthFont, sinfo2->wszFixedWidthFont), "wszFixedWidthFont mismatch\n");
 510     ok(!lstrcmpW(sinfo1->wszProportionalFont, sinfo2->wszProportionalFont), "wszProportionalFont mismatch\n");
 511 }
 512
 513 static void test_EnumScripts(IMultiLanguage2 *iML2, DWORD flags)
 514 {
 515     IEnumScript *iEnumScript = NULL;
 516     SCRIPTINFO *sinfo;
 517     SCRIPTINFO sinfo2;
 518     HRESULT ret;
 519     ULONG i, n;
 520     UINT total;
 521
 522     total = 0;
 523     ret = IMultiLanguage2_GetNumberOfScripts(iML2, &total);
 524     ok(ret == S_OK && total != 0, "IMultiLanguage2_GetNumberOfScripts: expected S_OK/!0, got %08x/%u\n", ret, total);
 525
 526     trace("total mlang supported scripts %u\n", total);
 527
 528     ret = IMultiLanguage2_EnumScripts(iML2, flags, LANG_NEUTRAL, &iEnumScript);
 529     ok(ret == S_OK && iEnumScript, "IMultiLanguage2_EnumScripts: expected S_OK/!NULL, got %08x/%p\n", ret, iEnumScript);
 530
 531     ret = IEnumScript_Reset(iEnumScript);
 532     ok(ret == S_OK, "IEnumScript_Reset: expected S_OK, got %08x\n", ret);
 533     n = 65536;
 534     ret = IEnumScript_Next(iEnumScript, 0, NULL, &n);
 535     ok(n == 65536 && ret == E_FAIL, "IEnumScript_Next: expected 65536/E_FAIL, got %u/%08x\n", n, ret);
 536     ret = IEnumScript_Next(iEnumScript, 0, NULL, NULL);
 537     ok(ret == E_FAIL, "IEnumScript_Next: expected E_FAIL, got %08x\n", ret);
 538
 539     sinfo = HeapAlloc(GetProcessHeap(), 0, sizeof(*sinfo) * total * 2);
 540
 541     n = total * 2;
 542     ret = IEnumScript_Next(iEnumScript, 0, sinfo, &n);
 543     ok(ret == S_FALSE && n == 0, "IEnumScript_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
 544
 545     n = total * 2;
 546     ret = IEnumScript_Next(iEnumScript, n, sinfo, &n);
 547     ok(ret == S_OK && n != 0, "IEnumScript_Next: expected S_OK, got %08x/%u\n", ret, n);
 548
 549     trace("flags %08x, enumerated scripts %u\n", flags, n);
 550
 551     if (!flags)
 552     {
 553         ok(n == total, "IEnumScript_Next: expected %u, got %u\n", total, n);
 554         flags = SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM;
 555     }
 556
 557     total = n;
 558
 559     for (i = 0; pGetCPInfoExA && i < n; i++)
 560     {
 561 #ifdef DUMP_SCRIPT_INFO
 562         trace("SCRIPTINFO #%u:\n"
 563               "ScriptId %08x\n"
 564               "uiCodePage %u\n"
 565               "wszDescription %s\n"
 566               "wszFixedWidthFont %s\n"
 567               "wszProportionalFont %s\n\n",
 568               i,
 569               sinfo[i].ScriptId,
 570               sinfo[i].uiCodePage,
 571               wine_dbgstr_w(sinfo[i].wszDescription),
 572               wine_dbgstr_w(sinfo[i].wszFixedWidthFont),
 573               wine_dbgstr_w(sinfo[i].wszProportionalFont));
 574         trace("%u codepage %u\n", i, sinfo[i].uiCodePage);
 575 #endif
 576     }
 577
 578     /* now IEnumScript_Next should fail, since pointer is at the end */
 579     n = 1;
 580     ret = IEnumScript_Next(iEnumScript, 1, &sinfo2, &n);
 581     ok(ret == S_FALSE && n == 0, "IEnumScript_Next: expected S_FALSE/0, got %08x/%u\n", ret, n);
 582
 583     ret = IEnumScript_Reset(iEnumScript);
 584     ok(ret == S_OK, "IEnumScript_Reset: expected S_OK, got %08x\n", ret);
 585     n = 0;
 586     ret = IEnumScript_Next(iEnumScript, 1, &sinfo2, &n);
 587     ok(n == 1 && ret == S_OK, "IEnumScript_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
 588     scriptinfo_cmp(&sinfo[0], &sinfo2);
 589
 590     if (0)
 591     {
 592     /* Due to a bug in MS' implementation of IEnumScript_Skip
 593      * it's not used here.
 594      */
 595     ret = IEnumScript_Skip(iEnumScript, 1);
 596     ok(ret == S_OK, "IEnumScript_Skip: expected S_OK, got %08x\n", ret);
 597     }
 598     for (i = 0; i < total - 1; i++)
 599     {
 600         n = 0;
 601         ret = IEnumScript_Next(iEnumScript, 1, &sinfo2, &n);
 602         ok(n == 1 && ret == S_OK, "IEnumScript_Next: expected 1/S_OK, got %u/%08x\n", n, ret);
 603         scriptinfo_cmp(&sinfo[i + 1], &sinfo2);
 604     }
 605
 606     HeapFree(GetProcessHeap(), 0, sinfo);
 607     IEnumScript_Release(iEnumScript);
 608 }
 609
 610 static void IMLangFontLink_Test(IMLangFontLink* iMLFL)
 611 {
 612     DWORD dwCodePages, dwManyCodePages;
 613     UINT CodePage;
 614     HRESULT ret;
 615
 616     dwCodePages = ~0u;
 617     ret = IMLangFontLink_CodePageToCodePages(iMLFL, -1, &dwCodePages);
 618     ok(ret == E_FAIL, "IMLangFontLink_CodePageToCodePages should fail: %x\n", ret);
 619     ok(dwCodePages == 0, "expected 0, got %u\n", dwCodePages);
 620
 621     dwCodePages = 0;
 622     ret = IMLangFontLink_CodePageToCodePages(iMLFL, 932, &dwCodePages);
 623     ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
 624     ok(dwCodePages == FS_JISJAPAN, "expected FS_JISJAPAN, got %08x\n", dwCodePages);
 625     CodePage = 0;
 626     ret = IMLangFontLink_CodePagesToCodePage(iMLFL, dwCodePages, 1035, &CodePage);
 627     ok(ret == S_OK, "IMLangFontLink_CodePagesToCodePage error %x\n", ret);
 628     ok(CodePage == 932, "Incorrect CodePage Returned (%i)\n",CodePage);
 629
 630     dwManyCodePages = 0;
 631     ret = IMLangFontLink_CodePageToCodePages(iMLFL, 1252, &dwManyCodePages);
 632     ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
 633     ok(dwManyCodePages == FS_LATIN1, "expected FS_LATIN1, got %08x\n", dwManyCodePages);
 634     dwCodePages = 0;
 635     ret = IMLangFontLink_CodePageToCodePages(iMLFL, 1256, &dwCodePages);
 636     ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
 637     ok(dwCodePages == FS_ARABIC, "expected FS_ARABIC, got %08x\n", dwCodePages);
 638     dwManyCodePages |= dwCodePages;
 639     ret = IMLangFontLink_CodePageToCodePages(iMLFL, 874, &dwCodePages);
 640     ok(ret == S_OK, "IMLangFontLink_CodePageToCodePages error %x\n", ret);
 641     ok(dwCodePages == FS_THAI, "expected FS_THAI, got %08x\n", dwCodePages);
 642     dwManyCodePages |= dwCodePages;
 643
 644     ret = IMLangFontLink_CodePagesToCodePage(iMLFL, dwManyCodePages, 1256, &CodePage);
 645     ok(ret == S_OK, "IMLangFontLink_CodePagesToCodePage error %x\n", ret);
 646     ok(CodePage == 1256, "Incorrect CodePage Returned (%i)\n",CodePage);
 647
 648     ret = IMLangFontLink_CodePagesToCodePage(iMLFL, dwManyCodePages, 936, &CodePage);
 649     ok(ret == S_OK, "IMLangFontLink_CodePagesToCodePage error %x\n", ret);
 650     ok(CodePage == 1252, "Incorrect CodePage Returned (%i)\n",CodePage);
 651 }
 652
 653 /* copied from libs/wine/string.c */
 654 WCHAR *strstrW(const WCHAR *str, const WCHAR *sub)
 655 {
 656     while (*str)
 657     {
 658         const WCHAR *p1 = str, *p2 = sub;
 659         while (*p1 && *p2 && *p1 == *p2) { p1++; p2++; }
 660         if (!*p2) return (WCHAR *)str;
 661         str++;
 662     }
 663     return NULL;
 664 }
 665
 666 static void test_rfc1766(IMultiLanguage2 *iML2)
 667 {
 668     IEnumRfc1766 *pEnumRfc1766;
 669     RFC1766INFO info;
 670     ULONG n;
 671     HRESULT ret;
 672     BSTR rfcstr;
 673
 674     ret = IMultiLanguage2_EnumRfc1766(iML2, LANG_NEUTRAL, &pEnumRfc1766);
 675     ok(ret == S_OK, "IMultiLanguage2_EnumRfc1766 error %08x\n", ret);
 676
 677     while (1)
 678     {
 679         ret = IEnumRfc1766_Next(pEnumRfc1766, 1, &info, &n);
 680         if (ret != S_OK) break;
 681
 682 #ifdef DUMP_CP_INFO
 683         trace("lcid %04x rfc_name %s locale_name %s\n",
 684               info.lcid, wine_dbgstr_w(info.wszRfc1766), wine_dbgstr_w(info.wszLocaleName));
 685 #endif
 686
 687         ok(n == 1, "couldn't fetch 1 RFC1766INFO structure\n");
 688
 689         /* verify the Rfc1766 value */
 690         ret = IMultiLanguage2_GetRfc1766FromLcid(iML2, info.lcid, &rfcstr);
 691         ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
 692
 693         /* not an exact 1:1 correspondence between lcid and rfc1766 in the
 694          * mlang database, e.g., nb-no -> 1044 -> no */
 695         ok(strstrW(info.wszRfc1766, rfcstr) != NULL,
 696            "Expected matching locale names\n");
 697
 698         SysFreeString(rfcstr);
 699     }
 700     IEnumRfc1766_Release(pEnumRfc1766);
 701 }
 702
 703 static void test_GetLcidFromRfc1766(IMultiLanguage2 *iML2)
 704 {
 705     LCID lcid;
 706     HRESULT ret;
 707
 708     static WCHAR e[] = { 'e',0 };
 709     static WCHAR en[] = { 'e','n',0 };
 710     static WCHAR empty[] = { 0 };
 711     static WCHAR dash[] = { '-',0 };
 712     static WCHAR e_dash[] = { 'e','-',0 };
 713     static WCHAR en_gb[] = { 'e','n','-','g','b',0 };
 714     static WCHAR en_us[] = { 'e','n','-','u','s',0 };
 715     static WCHAR en_them[] = { 'e','n','-','t','h','e','m',0 };
 716     static WCHAR english[] = { 'e','n','g','l','i','s','h',0 };
 717
 718     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, NULL, en);
 719     ok(ret == E_INVALIDARG, "GetLcidFromRfc1766 returned: %08x\n", ret);
 720
 721     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, NULL);
 722     ok(ret == E_INVALIDARG, "GetLcidFromRfc1766 returned: %08x\n", ret);
 723
 724     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, e);
 725     ok(ret == E_FAIL, "GetLcidFromRfc1766 returned: %08x\n", ret);
 726
 727     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, empty);
 728     ok(ret == E_FAIL, "GetLcidFromRfc1766 returned: %08x\n", ret);
 729
 730     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, dash);
 731     ok(ret == E_FAIL, "GetLcidFromRfc1766 returned: %08x\n", ret);
 732
 733     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, e_dash);
 734     ok(ret == E_FAIL, "GetLcidFromRfc1766 returned: %08x\n", ret);
 735
 736     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, en_them);
 737     ok((ret == E_FAIL || ret == S_FALSE), "GetLcidFromRfc1766 returned: %08x\n", ret);
 738     if (ret == S_FALSE)
 739     {
 740         BSTR rfcstr;
 741         static WCHAR en[] = {'e','n',0};
 742
 743         ret = IMultiLanguage2_GetRfc1766FromLcid(iML2, lcid, &rfcstr);
 744         ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
 745         ok_w2("Expected \"%s\",  got \"%s\"n", en, rfcstr);
 746     }
 747
 748     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, english);
 749     ok((ret == E_FAIL || ret == S_FALSE), "GetLcidFromRfc1766 returned: %08x\n", ret);
 750     if (ret == S_FALSE)
 751     {
 752         BSTR rfcstr;
 753         static WCHAR en[] = {'e','n',0};
 754
 755         ret = IMultiLanguage2_GetRfc1766FromLcid(iML2, lcid, &rfcstr);
 756         ok(ret == S_OK, "Expected S_OK, got %08x\n", ret);
 757         ok_w2("Expected \"%s\",  got \"%s\"n", en, rfcstr);
 758     }
 759
 760     lcid = 0;
 761
 762     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, en);
 763     ok(ret == S_OK, "GetLcidFromRfc1766 returned: %08x\n", ret);
 764     ok(lcid == 9, "got wrong lcid: %04x\n", lcid);
 765
 766     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, en_gb);
 767     ok(ret == S_OK, "GetLcidFromRfc1766 returned: %08x\n", ret);
 768     ok(lcid == 0x809, "got wrong lcid: %04x\n", lcid);
 769
 770     ret = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, en_us);
 771     ok(ret == S_OK, "GetLcidFromRfc1766 returned: %08x\n", ret);
 772     ok(lcid == 0x409, "got wrong lcid: %04x\n", lcid);
 773 }
 774
 775 static void test_GetRfc1766FromLcid(IMultiLanguage2 *iML2)
 776 {
 777     HRESULT hr;
 778     BSTR rfcstr;
 779     LCID lcid;
 780
 781     static WCHAR kok[] = {'k','o','k',0};
 782
 783     hr = IMultiLanguage2_GetLcidFromRfc1766(iML2, &lcid, kok);
 784     /*
 785      * S_FALSE happens when 'kok' instead matches to a different Rfc1766 name
 786      * for example 'ko' so it is not a failure but does not give us what
 787      * we are looking for
 788      */
 789     if (hr != S_FALSE)
 790     {
 791         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 792
 793         hr = IMultiLanguage2_GetRfc1766FromLcid(iML2, lcid, &rfcstr);
 794         ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 795         ok_w2("Expected \"%s\",  got \"%s\"n", kok, rfcstr);
 796     }
 797     SysFreeString(rfcstr);
 798 }
 799
 800 static void test_IMultiLanguage2_ConvertStringFromUnicode(IMultiLanguage2 *iML2)
 801 {
 802     CHAR dest[MAX_PATH];
 803     CHAR invariate[MAX_PATH];
 804     UINT srcsz, destsz;
 805     HRESULT hr;
 806
 807     static WCHAR src[] = {'a','b','c',0};
 808
 809     memset(invariate, 'x', sizeof(invariate));
 810
 811     /* pSrcStr NULL */
 812     memset(dest, 'x', sizeof(dest));
 813     srcsz = lstrlenW(src) + 1;
 814     destsz = sizeof(dest);
 815     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, NULL,
 816                                                   &srcsz, dest, &destsz);
 817     ok(hr == S_OK || hr == E_FAIL,"expected S_OK or E_FAIL, got %08x\n",hr);
 818     if (hr == S_OK)
 819     {
 820         ok(srcsz == lstrlenW(src) + 1,
 821            "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
 822     }
 823     else if (hr == E_FAIL)
 824     {
 825         ok(srcsz == 0,
 826            "Expected %u, got %u\n", 0, srcsz);
 827     }
 828
 829     ok(!memcmp(dest, invariate, sizeof(dest)),
 830        "Expected dest to be unchanged, got %s\n", dest);
 831     ok(destsz == 0, "Expected 0, got %u\n", destsz);
 832
 833     /* pcSrcSize NULL */
 834     memset(dest, 'x', sizeof(dest));
 835     destsz = sizeof(dest);
 836     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 837                                                   NULL, dest, &destsz);
 838     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 839     ok(!strncmp(dest, "abc", 3),
 840        "Expected first three chars to be \"abc\"\n");
 841     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
 842        "Expected rest of dest to be unchanged, got %s\n", dest);
 843     ok(destsz == lstrlenW(src),
 844        "Expected %u, got %u\n", lstrlenW(src), destsz);
 845
 846     /* both pSrcStr and pcSrcSize NULL */
 847     memset(dest, 'x', sizeof(dest));
 848     destsz = sizeof(dest);
 849     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, NULL,
 850                                                   NULL, dest, &destsz);
 851     ok(hr == S_OK || hr == E_FAIL, "Expected S_OK or E_FAIL, got %08x\n", hr);
 852     ok(!memcmp(dest, invariate, sizeof(dest)),
 853        "Expected dest to be unchanged, got %s\n", dest);
 854     ok(destsz == 0, "Expected 0, got %u\n", destsz);
 855
 856     /* pDstStr NULL */
 857     memset(dest, 'x', sizeof(dest));
 858     srcsz = lstrlenW(src) + 1;
 859     destsz = sizeof(dest);
 860     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 861                                                   &srcsz, NULL, &destsz);
 862     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 863     ok(srcsz == lstrlenW(src) + 1,
 864        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
 865     ok(destsz == lstrlenW(src) + 1,
 866        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
 867
 868     /* pcDstSize NULL */
 869     memset(dest, 'x', sizeof(dest));
 870     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 871                                                   &srcsz, dest, NULL);
 872     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 873     ok(srcsz == lstrlenW(src) + 1,
 874        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
 875     ok(!memcmp(dest, invariate, sizeof(dest)),
 876        "Expected dest to be unchanged, got %s\n", dest);
 877
 878     /* pcSrcSize is 0 */
 879     memset(dest, 'x', sizeof(dest));
 880     srcsz = 0;
 881     destsz = sizeof(dest);
 882     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 883                                                   &srcsz, dest, &destsz);
 884     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 885     ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
 886     ok(!memcmp(dest, invariate, sizeof(dest)),
 887        "Expected dest to be unchanged, got %s\n", dest);
 888     ok(destsz == 0, "Expected 0, got %u\n", destsz);
 889
 890     /* pcSrcSize does not include NULL terminator */
 891     memset(dest, 'x', sizeof(dest));
 892     srcsz = lstrlenW(src);
 893     destsz = sizeof(dest);
 894     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 895                                                   &srcsz, dest, &destsz);
 896     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 897     ok(srcsz == lstrlenW(src),
 898        "Expected %u, got %u\n", lstrlenW(src), srcsz);
 899     ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
 900     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
 901        "Expected rest of dest to be unchanged, got %s\n", dest);
 902     ok(destsz == lstrlenW(src),
 903        "Expected %u, got %u\n", lstrlenW(src), destsz);
 904
 905     /* pcSrcSize includes NULL terminator */
 906     memset(dest, 'x', sizeof(dest));
 907     srcsz = lstrlenW(src) + 1;
 908     destsz = sizeof(dest);
 909     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 910                                                   &srcsz, dest, &destsz);
 911     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 912     ok(srcsz == lstrlenW(src) + 1, "Expected 3, got %u\n", srcsz);
 913     ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
 914     ok(destsz == lstrlenW(src) + 1,
 915        "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
 916
 917     /* pcSrcSize is -1 */
 918     memset(dest, 'x', sizeof(dest));
 919     srcsz = -1;
 920     destsz = sizeof(dest);
 921     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 922                                                   &srcsz, dest, &destsz);
 923     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 924     ok(srcsz == lstrlenW(src),
 925        "Expected %u, got %u\n", lstrlenW(src), srcsz);
 926     ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
 927     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
 928        "Expected rest of dest to be unchanged, got %s\n", dest);
 929     ok(destsz == lstrlenW(src),
 930        "Expected %u, got %u\n", lstrlenW(src), destsz);
 931
 932     /* pcDstSize is 0 */
 933     memset(dest, 'x', sizeof(dest));
 934     srcsz = lstrlenW(src) + 1;
 935     destsz = 0;
 936     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 937                                                   &srcsz, dest, &destsz);
 938     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 939     ok(srcsz == lstrlenW(src) + 1,
 940        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
 941     ok(!memcmp(dest, invariate, sizeof(dest)),
 942        "Expected dest to be unchanged, got %s\n", dest);
 943     ok(destsz == lstrlenW(src) + 1,
 944        "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
 945
 946     /* pcDstSize is not large enough */
 947     memset(dest, 'x', sizeof(dest));
 948     srcsz = lstrlenW(src) + 1;
 949     destsz = lstrlenW(src);
 950     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 951                                                   &srcsz, dest, &destsz);
 952     ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
 953     ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
 954     ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
 955     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
 956        "Expected rest of dest to be unchanged, got %s\n", dest);
 957     ok(destsz == 0, "Expected 0, got %u\n", srcsz);
 958
 959     /* pcDstSize (bytes) does not leave room for NULL terminator */
 960     memset(dest, 'x', sizeof(dest));
 961     srcsz = lstrlenW(src) + 1;
 962     destsz = lstrlenW(src) * sizeof(WCHAR);
 963     hr = IMultiLanguage2_ConvertStringFromUnicode(iML2, NULL, 1252, src,
 964                                                   &srcsz, dest, &destsz);
 965     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
 966     ok(srcsz == lstrlenW(src) + 1,
 967        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
 968     ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
 969     ok(destsz == lstrlenW(src) + 1,
 970        "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
 971 }
 972
 973 static void test_ConvertINetUnicodeToMultiByte(void)
 974 {
 975     CHAR dest[MAX_PATH];
 976     CHAR invariate[MAX_PATH];
 977     INT srcsz, destsz;
 978     HRESULT hr;
 979
 980     static WCHAR src[] = {'a','b','c',0};
 981
 982     memset(invariate, 'x', sizeof(invariate));
 983
 984     /* lpSrcStr NULL */
 985     memset(dest, 'x', sizeof(dest));
 986     srcsz = lstrlenW(src) + 1;
 987     destsz = sizeof(dest);
 988     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, NULL, &srcsz, dest, &destsz);
 989     ok(hr == S_OK || hr == E_FAIL, "Expected S_OK or E_FAIL, got %08x\n", hr);
 990     if (hr == S_OK)
 991         ok(srcsz == lstrlenW(src) + 1,
 992            "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
 993     else if (hr == E_FAIL)
 994         ok(srcsz == 0,
 995            "Expected %u, got %u\n", 0, srcsz);
 996     ok(!memcmp(dest, invariate, sizeof(dest)),
 997        "Expected dest to be unchanged, got %s\n", dest);
 998     ok(destsz == 0, "Expected 0, got %u\n", destsz);
 999
1000     /* lpnWideCharCount NULL */
1001     memset(dest, 'x', sizeof(dest));
1002     destsz = sizeof(dest);
1003     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, NULL, dest, &destsz);
1004     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1005     ok(!strncmp(dest, "abc", 3),
1006        "Expected first three chars to be \"abc\"\n");
1007     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1008        "Expected rest of dest to be unchanged, got %s\n", dest);
1009     ok(destsz == lstrlenW(src),
1010        "Expected %u, got %u\n", lstrlenW(src), destsz);
1011
1012     /* both lpSrcStr and lpnWideCharCount NULL */
1013     memset(dest, 'x', sizeof(dest));
1014     destsz = sizeof(dest);
1015     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, NULL, NULL, dest, &destsz);
1016     ok(hr == S_OK || hr == E_FAIL, "Expected S_OK or E_FAIL, got %08x\n", hr);
1017     ok(!memcmp(dest, invariate, sizeof(dest)),
1018        "Expected dest to be unchanged, got %s\n", dest);
1019     ok(destsz == 0, "Expected 0, got %u\n", destsz);
1020
1021     /* lpDstStr NULL */
1022     memset(dest, 'x', sizeof(dest));
1023     srcsz = lstrlenW(src) + 1;
1024     destsz = sizeof(dest);
1025     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, NULL, &destsz);
1026     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1027     ok(srcsz == lstrlenW(src) + 1,
1028        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1029     ok(destsz == lstrlenW(src) + 1,
1030        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1031
1032     /* lpnMultiCharCount NULL */
1033     memset(dest, 'x', sizeof(dest));
1034     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, NULL);
1035     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1036     ok(srcsz == lstrlenW(src) + 1,
1037        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1038     ok(!memcmp(dest, invariate, sizeof(dest)),
1039        "Expected dest to be unchanged, got %s\n", dest);
1040
1041     /* lpnWideCharCount is 0 */
1042     memset(dest, 'x', sizeof(dest));
1043     srcsz = 0;
1044     destsz = sizeof(dest);
1045     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1046     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1047     ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
1048     ok(!memcmp(dest, invariate, sizeof(dest)),
1049        "Expected dest to be unchanged, got %s\n", dest);
1050     ok(destsz == 0, "Expected 0, got %u\n", destsz);
1051
1052     /* lpnWideCharCount does not include NULL terminator */
1053     memset(dest, 'x', sizeof(dest));
1054     srcsz = lstrlenW(src);
1055     destsz = sizeof(dest);
1056     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1057     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1058     ok(srcsz == lstrlenW(src),
1059        "Expected %u, got %u\n", lstrlenW(src), srcsz);
1060     ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1061     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1062        "Expected rest of dest to be unchanged, got %s\n", dest);
1063     ok(destsz == lstrlenW(src),
1064        "Expected %u, got %u\n", lstrlenW(src), destsz);
1065
1066     /* lpnWideCharCount includes NULL terminator */
1067     memset(dest, 'x', sizeof(dest));
1068     srcsz = lstrlenW(src) + 1;
1069     destsz = sizeof(dest);
1070     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1071     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1072     ok(srcsz == lstrlenW(src) + 1, "Expected 3, got %u\n", srcsz);
1073     ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
1074     ok(destsz == lstrlenW(src) + 1,
1075        "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1076
1077     /* lpnWideCharCount is -1 */
1078     memset(dest, 'x', sizeof(dest));
1079     srcsz = -1;
1080     destsz = sizeof(dest);
1081     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1082     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1083     ok(srcsz == lstrlenW(src),
1084        "Expected %u, got %u\n", lstrlenW(src), srcsz);
1085     ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1086     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1087        "Expected rest of dest to be unchanged, got %s\n", dest);
1088     ok(destsz == lstrlenW(src),
1089        "Expected %u, got %u\n", lstrlenW(src), destsz);
1090
1091     /* lpnMultiCharCount is 0 */
1092     memset(dest, 'x', sizeof(dest));
1093     srcsz = lstrlenW(src) + 1;
1094     destsz = 0;
1095     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1096     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1097     ok(srcsz == lstrlenW(src) + 1,
1098        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1099     ok(!memcmp(dest, invariate, sizeof(dest)),
1100        "Expected dest to be unchanged, got %s\n", dest);
1101     ok(destsz == lstrlenW(src) + 1,
1102        "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1103
1104     /* lpnMultiCharCount is not large enough */
1105     memset(dest, 'x', sizeof(dest));
1106     srcsz = lstrlenW(src) + 1;
1107     destsz = lstrlenW(src);
1108     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1109     ok(hr == E_FAIL, "Expected E_FAIL, got %08x\n", hr);
1110     ok(srcsz == 0, "Expected 0, got %u\n", srcsz);
1111     ok(!strncmp(dest, "abc", 3), "Expected first three chars to be \"abc\"\n");
1112     ok(!memcmp(&dest[3], invariate, sizeof(dest) - 3),
1113        "Expected rest of dest to be unchanged, got %s\n", dest);
1114     ok(destsz == 0, "Expected 0, got %u\n", srcsz);
1115
1116     /* lpnMultiCharCount (bytes) does not leave room for NULL terminator */
1117     memset(dest, 'x', sizeof(dest));
1118     srcsz = lstrlenW(src) + 1;
1119     destsz = lstrlenW(src) * sizeof(WCHAR);
1120     hr = pConvertINetUnicodeToMultiByte(NULL, 1252, src, &srcsz, dest, &destsz);
1121     ok(hr == S_OK, "Expected S_OK, got %08x\n", hr);
1122     ok(srcsz == lstrlenW(src) + 1,
1123        "Expected %u, got %u\n", lstrlenW(src) + 1, srcsz);
1124     ok(!lstrcmpA(dest, "abc"), "Expected \"abc\", got \"%s\"\n", dest);
1125     ok(destsz == lstrlenW(src) + 1,
1126        "Expected %u, got %u\n", lstrlenW(src) + 1, destsz);
1127 }
1128
1129 static void test_JapaneseConversion(void)
1130 {
1131     /* Data */
1132     static WCHAR unc_jp[9][12] = {
1133   {9,0x31,0x20,0x3042,0x3044,0x3046,0x3048,0x304a,0x000d,0x000a},
1134   {9,0x31,0x20,0x30a2,0x30a4,0x30a6,0x30a8,0x30aa,0x000d,0x000a},
1135   {9,0x31,0x20,0xff71,0xff72,0xff73,0xff74,0xff75,0x000d,0x000a},
1136   {9,0x31,0x20,0x3041,0x3043,0x3045,0x3047,0x3049,0x000d,0x000a},
1137   {9,0x31,0x20,0x30a1,0x30a3,0x30a5,0x30a7,0x30a9,0x000d,0x000a},
1138   {9,0x31,0x20,0xff67,0xff68,0xff69,0xff6a,0xff6b,0x000d,0x000a},
1139   {9,0x31,0x20,0x300c,0x65e5,0x672c,0x8a9e,0x300d,0x000d,0x000a},
1140   {7,0x31,0x20,0x25c7,0x25c7,0x3012,0x000d,0x000a},
1141   {11,0x31,0x20,0x203b,0x3010,0x0074,0x0065,0x0073,0x0074,0x3011,0x000d,0x000a}
1142     };
1143     static CHAR jis_jp[9][27] = {
1144   {20,0x31,0x20,0x1b,0x24,0x42,0x24,0x22,0x24,0x24,0x24,0x26,0x24,0x28,
1145       0x24,0x2a,0x1b,0x28,0x42,0x0d,0x0a},
1146   {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x22,0x25,0x24,0x25,0x26,0x25,0x28,\
1147       0x25,0x2a,0x1b,0x28,0x42,0x0d,0x0a},
1148   {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x22,0x25,0x24,0x25,0x26,0x25,0x28,\
1149       0x25,0x2a,0x1b,0x28,0x42,0x0d,0x0a},
1150   {20,0x31,0x20,0x1b,0x24,0x42,0x24,0x21,0x24,0x23,0x24,0x25,0x24,0x27,\
1151       0x24,0x29,0x1b,0x28,0x42,0x0d,0x0a},
1152   {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x21,0x25,0x23,0x25,0x25,0x25,0x27,\
1153       0x25,0x29,0x1b,0x28,0x42,0x0d,0x0a},
1154   {20,0x31,0x20,0x1b,0x24,0x42,0x25,0x21,0x25,0x23,0x25,0x25,0x25,0x27,\
1155       0x25,0x29,0x1b,0x28,0x42,0x0d,0x0a},
1156   {20,0x31,0x20,0x1b,0x24,0x42,0x21,0x56,0x46,0x7c,0x4b,0x5c,0x38,0x6c,\
1157       0x21,0x57,0x1b,0x28,0x42,0x0d,0x0a},
1158   {16,0x31,0x20,0x1b,0x24,0x42,0x21,0x7e,0x21,0x7e,0x22,0x29,0x1b,0x28,\
1159       0x42,0x0d,0x0a},
1160   {26,0x31,0x20,0x1b,0x24,0x42,0x22,0x28,0x21,0x5a,0x1b,0x28,0x42,0x74,\
1161       0x65,0x73,0x74,0x1b,0x24,0x42,0x21,0x5b,0x1b,0x28,0x42,0x0d,0x0a}
1162     };
1163     static CHAR sjis_jp[9][15] = {
1164   {14,0x31,0x20,0x82,0xa0,0x82,0xa2,0x82,0xa4,0x82,0xa6,0x82,0xa8,0x0d,0x0a},
1165   {14,0x31,0x20,0x83,0x41,0x83,0x43,0x83,0x45,0x83,0x47,0x83,0x49,0x0d,0x0a},
1166   {9,0x31,0x20,0xb1,0xb2,0xb3,0xb4,0xb5,0x0d,0x0a},
1167   {14,0x31,0x20,0x82,0x9f,0x82,0xa1,0x82,0xa3,0x82,0xa5,0x82,0xa7,0x0d,0x0a},
1168   {14,0x31,0x20,0x83,0x40,0x83,0x42,0x83,0x44,0x83,0x46,0x83,0x48,0x0d,0x0a},
1169   {9,0x31,0x20,0xa7,0xa8,0xa9,0xaa,0xab,0x0d,0x0a},
1170   {14,0x31,0x20,0x81,0x75,0x93,0xfa,0x96,0x7b,0x8c,0xea,0x81,0x76,0x0d,0x0a},
1171   {10,0x31,0x20,0x81,0x9e,0x81,0x9e,0x81,0xa7,0x0d,0x0a},
1172   {14,0x31,0x20,0x81,0xa6,0x81,0x79,0x74,0x65,0x73,0x74,0x81,0x7a,0x0d,0x0a}
1173     };
1174     static CHAR euc_jp[9][15] = {
1175   {14,0x31,0x20,0xa4,0xa2,0xa4,0xa4,0xa4,0xa6,0xa4,0xa8,0xa4,0xaa,0x0d,0x0a},
1176   {14,0x31,0x20,0xa5,0xa2,0xa5,0xa4,0xa5,0xa6,0xa5,0xa8,0xa5,0xaa,0x0d,0x0a},
1177   {14,0x31,0x20,0x8e,0xb1,0x8e,0xb2,0x8e,0xb3,0x8e,0xb4,0x8e,0xb5,0x0d,0x0a},
1178   {14,0x31,0x20,0xa4,0xa1,0xa4,0xa3,0xa4,0xa5,0xa4,0xa7,0xa4,0xa9,0x0d,0x0a},
1179   {14,0x31,0x20,0xa5,0xa1,0xa5,0xa3,0xa5,0xa5,0xa5,0xa7,0xa5,0xa9,0x0d,0x0a},
1180   {14,0x31,0x20,0x8e,0xa7,0x8e,0xa8,0x8e,0xa9,0x8e,0xaa,0x8e,0xab,0x0d,0x0a},
1181   {14,0x31,0x20,0xa1,0xd6,0xc6,0xfc,0xcb,0xdc,0xb8,0xec,0xa1,0xd7,0x0d,0x0a},
1182   {10,0x31,0x20,0xa1,0xfe,0xa1,0xfe,0xa2,0xa9,0x0d,0x0a},
1183   {14,0x31,0x20,0xa2,0xa8,0xa1,0xda,0x74,0x65,0x73,0x74,0xa1,0xdb,0x0d,0x0a}
1184     };
1185
1186     INT srcsz, destsz;
1187     INT i;
1188     HRESULT hr;
1189     CHAR output[30];
1190     WCHAR outputW[30];
1191     int outlen;
1192
1193     /* test unc->jis */
1194     for (i = 0; i < 9; i++)
1195     {
1196         int j;
1197         destsz = 30;
1198         outlen = jis_jp[i][0];
1199         srcsz = unc_jp[i][0];
1200         hr = pConvertINetUnicodeToMultiByte(NULL, 50220, &unc_jp[i][1], &srcsz, output, &destsz);
1201         if (hr == S_FALSE)
1202         {
1203             skip("Code page identifier 50220 is not supported\n");
1204             break;
1205         }
1206         ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n", i, hr);
1207         ok(destsz == outlen, "(%i) Expected %i, got %i\n",i,outlen,destsz);
1208         ok(srcsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],srcsz);
1209         ok(memcmp(output,&jis_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1210
1211         /* and back */
1212         srcsz = outlen;
1213         destsz = 30;
1214         hr = pConvertINetMultiByteToUnicode(NULL, 50220, output, &srcsz, outputW,&destsz);
1215
1216         /*
1217          * JIS does not have hankata so it get automatically converted to
1218          * zenkata. this means that strings 1 and 2 are identical as well as
1219          * strings 4 and 5.
1220          */
1221         j = i;
1222         if (i == 2) j = 1;
1223         if (i == 5) j = 4;
1224
1225         ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i, hr);
1226         ok(destsz == unc_jp[j][0],"(%i) Expected %i, got %i\n",i,unc_jp[j][0],destsz);
1227         ok(srcsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,srcsz);
1228         ok(memcmp(outputW,&unc_jp[j][1],destsz)==0,"(%i) Strings do not match\n",i);
1229     }
1230
1231     /* test unc->sjis */
1232     for (i = 0; i < 9; i++)
1233     {
1234         destsz = 30;
1235         outlen = sjis_jp[i][0];
1236         srcsz = unc_jp[i][0];
1237
1238         hr = pConvertINetUnicodeToMultiByte(NULL, 932, &unc_jp[i][1], &srcsz, output, &destsz);
1239         if (hr == S_FALSE)
1240         {
1241             skip("Code page identifier 932 is not supported\n");
1242             break;
1243         }
1244         ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1245         ok(destsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,destsz);
1246         ok(srcsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],srcsz);
1247         ok(memcmp(output,&sjis_jp[i][1],outlen)==0,"(%i) Strings do not match\n",i);
1248
1249         srcsz = outlen;
1250         destsz = 30;
1251         hr = pConvertINetMultiByteToUnicode(NULL, 932, output, &srcsz, outputW,&destsz);
1252
1253         ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n", i, hr);
1254         ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1255         ok(srcsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,srcsz);
1256         ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1257     }
1258
1259     /* test unc->euc */
1260     for (i = 0; i < 9; i++)
1261     {
1262         destsz = 30;
1263         outlen = euc_jp[i][0];
1264         srcsz = unc_jp[i][0];
1265
1266         hr = pConvertINetUnicodeToMultiByte(NULL, 51932, &unc_jp[i][1], &srcsz, output, &destsz);
1267         if (hr == S_FALSE)
1268         {
1269             skip("Code page identifier 51932 is not supported\n");
1270             break;
1271         }
1272         ok(hr == S_OK, "(%i) Expected S_OK, got %08x\n",i,hr);
1273         ok(destsz == outlen, "(%i) Expected %i, got %i\n",i,outlen,destsz);
1274         ok(srcsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1275         ok(memcmp(output,&euc_jp[i][1],outlen)==0,"(%i) Strings do not match\n",i);
1276
1277         srcsz = outlen;
1278         destsz = 30;
1279         hr = pConvertINetMultiByteToUnicode(NULL, 51932, output, &srcsz, outputW,&destsz);
1280
1281         ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1282         ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1283         ok(srcsz == outlen,"(%i) Expected %i, got %i\n",i,outlen,srcsz);
1284         ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1285     }
1286
1287     /* Japanese autodetect */
1288     i = 0;
1289     destsz = 30;
1290     srcsz = jis_jp[i][0];
1291     hr = pConvertINetMultiByteToUnicode(NULL, 50932, &jis_jp[i][1], &srcsz, outputW, &destsz);
1292     if (hr == S_FALSE)
1293     {
1294         skip("Code page identifier 50932 is not supported\n");
1295         return;
1296     }
1297     ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1298     ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1299     ok(srcsz == jis_jp[i][0],"(%i) Expected %i, got %i\n",i,jis_jp[i][0],srcsz);
1300     ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1301
1302     i = 1;
1303     destsz = 30;
1304     srcsz = sjis_jp[i][0];
1305     hr = pConvertINetMultiByteToUnicode(NULL, 50932, &sjis_jp[i][1], &srcsz, outputW, &destsz);
1306     ok(hr == S_OK,"(%i) Expected S_OK, got %08x\n",i,hr);
1307     ok(destsz == unc_jp[i][0],"(%i) Expected %i, got %i\n",i,unc_jp[i][0],destsz);
1308     ok(srcsz == sjis_jp[i][0],"(%i) Expected %i, got %i\n",i,sjis_jp[i][0],srcsz);
1309     ok(memcmp(outputW,&unc_jp[i][1],destsz)==0,"(%i) Strings do not match\n",i);
1310 }
1311
1312 START_TEST(mlang)
1313 {
1314     IMultiLanguage2 *iML2 = NULL;
1315     IMLangFontLink  *iMLFL = NULL;
1316     HRESULT ret;
1317
1318     if (!init_function_ptrs())
1319         return;
1320
1321     CoInitialize(NULL);
1322     ret = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
1323                            &IID_IMultiLanguage2, (void **)&iML2);
1324     if (ret != S_OK || !iML2) return;
1325
1326     test_rfc1766(iML2);
1327     test_GetLcidFromRfc1766(iML2);
1328     test_GetRfc1766FromLcid(iML2);
1329
1330     test_EnumCodePages(iML2, 0);
1331     test_EnumCodePages(iML2, MIMECONTF_MIME_LATEST);
1332     test_EnumCodePages(iML2, MIMECONTF_BROWSER);
1333     test_EnumCodePages(iML2, MIMECONTF_MINIMAL);
1334     test_EnumCodePages(iML2, MIMECONTF_VALID);
1335     /* FIXME: why MIMECONTF_MIME_REGISTRY returns 0 of supported codepages? */
1336     /*test_EnumCodePages(iML2, MIMECONTF_MIME_REGISTRY);*/
1337
1338     test_EnumScripts(iML2, 0);
1339     test_EnumScripts(iML2, SCRIPTCONTF_SCRIPT_USER);
1340     test_EnumScripts(iML2, SCRIPTCONTF_SCRIPT_USER | SCRIPTCONTF_SCRIPT_HIDE | SCRIPTCONTF_SCRIPT_SYSTEM);
1341
1342     ret = IMultiLanguage2_IsConvertible(iML2, CP_UTF8, CP_UNICODE);
1343     ok(ret == S_OK, "IMultiLanguage2_IsConvertible(CP_UTF8 -> CP_UNICODE) = %08x\n", ret);
1344     ret = IMultiLanguage2_IsConvertible(iML2, CP_UNICODE, CP_UTF8);
1345     ok(ret == S_OK, "IMultiLanguage2_IsConvertible(CP_UNICODE -> CP_UTF8) = %08x\n", ret);
1346
1347     test_multibyte_to_unicode_translations(iML2);
1348     test_IMultiLanguage2_ConvertStringFromUnicode(iML2);
1349
1350     IMultiLanguage2_Release(iML2);
1351
1352     test_ConvertINetUnicodeToMultiByte();
1353
1354     test_JapaneseConversion();
1355
1356     ret = CoCreateInstance(&CLSID_CMultiLanguage, NULL, CLSCTX_INPROC_SERVER,
1357                            &IID_IMLangFontLink, (void **)&iMLFL);
1358     if (ret != S_OK || !iML2) return;
1359
1360     IMLangFontLink_Test(iMLFL);
1361     IMLangFontLink_Release(iMLFL);
1362
1363     CoUninitialize();
1364 }