modules/rostests/winetests/kernel32/locale.c

   1 /*
   2  * Unit tests for locale functions
   3  *
   4  * Copyright 2002 YASAR Mehmet
   5  * Copyright 2003 Dmitry Timoshkov
   6  * Copyright 2003 Jon Griffiths
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2.1 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Lesser General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Lesser General Public
  19  * License along with this library; if not, write to the Free Software
  20  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
  21  *
  22  * NOTES
  23  *  We must pass LOCALE_NOUSEROVERRIDE (NUO) to formatting functions so that
  24  *  even when the user has overridden their default i8n settings (e.g. in
  25  *  the control panel i8n page), we will still get the expected results.
  26  */
  27
  28 #include <assert.h>
  29 #include <stdlib.h>
  30 #include <stdarg.h>
  31 #include <stdio.h>
  32
  33 #undef WINVER
  34 #define WINVER 0x0600
  35
  36 #include "wine/test.h"
  37 #include "windef.h"
  38 #include "winbase.h"
  39 #include "winerror.h"
  40 #include "winnls.h"
  41
  42 static const WCHAR upper_case[] = {'\t','J','U','S','T','!',' ','A',',',' ','T','E','S','T',';',' ','S','T','R','I','N','G',' ','1','/','*','+','-','.','\r','\n',0};
  43 static const WCHAR lower_case[] = {'\t','j','u','s','t','!',' ','a',',',' ','t','e','s','t',';',' ','s','t','r','i','n','g',' ','1','/','*','+','-','.','\r','\n',0};
  44 static const WCHAR title_case[] = {'\t','J','u','s','t','!',' ','A',',',' ','T','e','s','t',';',' ','S','t','r','i','n','g',' ','1','/','*','+','-','.','\r','\n',0};
  45 static const WCHAR symbols_stripped[] = {'j','u','s','t','a','t','e','s','t','s','t','r','i','n','g','1',0};
  46 static const WCHAR localeW[] = {'e','n','-','U','S',0};
  47 static const WCHAR fooW[] = {'f','o','o',0};
  48 static const WCHAR emptyW[] = {0};
  49 static const WCHAR invalidW[] = {'i','n','v','a','l','i','d',0};
  50
  51 static inline unsigned int strlenW( const WCHAR *str )
  52 {
  53     const WCHAR *s = str;
  54     while (*s) s++;
  55     return s - str;
  56 }
  57
  58 static inline int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
  59 {
  60     if (n <= 0) return 0;
  61     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
  62     return *str1 - *str2;
  63 }
  64
  65 static inline WCHAR *strchrW( const WCHAR *str, WCHAR ch )
  66 {
  67     do { if (*str == ch) return (WCHAR *)str; } while (*str++);
  68     return NULL;
  69 }
  70
  71 static inline BOOL isdigitW( WCHAR wc )
  72 {
  73     WORD type;
  74     GetStringTypeW( CT_CTYPE1, &wc, 1, &type );
  75     return type & C1_DIGIT;
  76 }
  77
  78 /* Some functions are only in later versions of kernel32.dll */
  79 static WORD enumCount;
  80
  81 static INT (WINAPI *pGetTimeFormatEx)(LPCWSTR, DWORD, const SYSTEMTIME *, LPCWSTR, LPWSTR, INT);
  82 static INT (WINAPI *pGetDateFormatEx)(LPCWSTR, DWORD, const SYSTEMTIME *, LPCWSTR, LPWSTR, INT, LPCWSTR);
  83 static BOOL (WINAPI *pEnumSystemLanguageGroupsA)(LANGUAGEGROUP_ENUMPROCA, DWORD, LONG_PTR);
  84 static BOOL (WINAPI *pEnumLanguageGroupLocalesA)(LANGGROUPLOCALE_ENUMPROCA, LGRPID, DWORD, LONG_PTR);
  85 static BOOL (WINAPI *pEnumUILanguagesA)(UILANGUAGE_ENUMPROCA, DWORD, LONG_PTR);
  86 static BOOL (WINAPI *pEnumSystemLocalesEx)(LOCALE_ENUMPROCEX, DWORD, LPARAM, LPVOID);
  87 static INT (WINAPI *pLCMapStringEx)(LPCWSTR, DWORD, LPCWSTR, INT, LPWSTR, INT, LPNLSVERSIONINFO, LPVOID, LPARAM);
  88 static LCID (WINAPI *pLocaleNameToLCID)(LPCWSTR, DWORD);
  89 static INT  (WINAPI *pLCIDToLocaleName)(LCID, LPWSTR, INT, DWORD);
  90 static INT (WINAPI *pFoldStringA)(DWORD, LPCSTR, INT, LPSTR, INT);
  91 static INT (WINAPI *pFoldStringW)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  92 static BOOL (WINAPI *pIsValidLanguageGroup)(LGRPID, DWORD);
  93 static INT (WINAPI *pIdnToNameprepUnicode)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  94 static INT (WINAPI *pIdnToAscii)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  95 static INT (WINAPI *pIdnToUnicode)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  96 static INT (WINAPI *pGetLocaleInfoEx)(LPCWSTR, LCTYPE, LPWSTR, INT);
  97 static BOOL (WINAPI *pIsValidLocaleName)(LPCWSTR);
  98 static INT (WINAPI *pCompareStringOrdinal)(const WCHAR *, INT, const WCHAR *, INT, BOOL);
  99 static INT (WINAPI *pCompareStringEx)(LPCWSTR, DWORD, LPCWSTR, INT, LPCWSTR, INT,
 100                                       LPNLSVERSIONINFO, LPVOID, LPARAM);
 101 static INT (WINAPI *pGetGeoInfoA)(GEOID, GEOTYPE, LPSTR, INT, LANGID);
 102 static INT (WINAPI *pGetGeoInfoW)(GEOID, GEOTYPE, LPWSTR, INT, LANGID);
 103 static BOOL (WINAPI *pEnumSystemGeoID)(GEOCLASS, GEOID, GEO_ENUMPROC);
 104 static BOOL (WINAPI *pGetSystemPreferredUILanguages)(DWORD, ULONG*, WCHAR*, ULONG*);
 105 static BOOL (WINAPI *pGetThreadPreferredUILanguages)(DWORD, ULONG*, WCHAR*, ULONG*);
 106 static BOOL (WINAPI *pGetUserPreferredUILanguages)(DWORD, ULONG*, WCHAR*, ULONG*);
 107 static WCHAR (WINAPI *pRtlUpcaseUnicodeChar)(WCHAR);
 108 static INT (WINAPI *pGetNumberFormatEx)(LPCWSTR, DWORD, LPCWSTR, const NUMBERFMTW *, LPWSTR, int);
 109
 110 static void InitFunctionPointers(void)
 111 {
 112   HMODULE mod = GetModuleHandleA("kernel32");
 113
 114 #define X(f) p##f = (void*)GetProcAddress(mod, #f)
 115   X(GetTimeFormatEx);
 116   X(GetDateFormatEx);
 117   X(EnumSystemLanguageGroupsA);
 118   X(EnumLanguageGroupLocalesA);
 119   X(LocaleNameToLCID);
 120   X(LCIDToLocaleName);
 121   X(LCMapStringEx);
 122   X(FoldStringA);
 123   X(FoldStringW);
 124   X(IsValidLanguageGroup);
 125   X(EnumUILanguagesA);
 126   X(EnumSystemLocalesEx);
 127   X(IdnToNameprepUnicode);
 128   X(IdnToAscii);
 129   X(IdnToUnicode);
 130   X(GetLocaleInfoEx);
 131   X(IsValidLocaleName);
 132   X(CompareStringOrdinal);
 133   X(CompareStringEx);
 134   X(GetGeoInfoA);
 135   X(GetGeoInfoW);
 136   X(EnumSystemGeoID);
 137   X(GetSystemPreferredUILanguages);
 138   X(GetThreadPreferredUILanguages);
 139   X(GetUserPreferredUILanguages);
 140   X(GetNumberFormatEx);
 141
 142   mod = GetModuleHandleA("ntdll");
 143   X(RtlUpcaseUnicodeChar);
 144 #undef X
 145 }
 146
 147 #define eq(received, expected, label, type) \
 148         ok((received) == (expected), "%s: got " type " instead of " type "\n", \
 149            (label), (received), (expected))
 150
 151 #define BUFFER_SIZE    128
 152 #define COUNTOF(x) (sizeof(x)/sizeof(x)[0])
 153
 154 #define STRINGSA(x,y) strcpy(input, x); strcpy(Expected, y); SetLastError(0xdeadbeef); buffer[0] = '\0'
 155 #define EXPECT_LENA ok(ret == lstrlenA(Expected)+1, "Expected len %d, got %d\n", lstrlenA(Expected)+1, ret)
 156 #define EXPECT_EQA ok(strncmp(buffer, Expected, strlen(Expected)) == 0, \
 157   "Expected '%s', got '%s'\n", Expected, buffer)
 158
 159 #define STRINGSW(x,y) MultiByteToWideChar(CP_ACP,0,x,-1,input,COUNTOF(input)); \
 160    MultiByteToWideChar(CP_ACP,0,y,-1,Expected,COUNTOF(Expected)); \
 161    SetLastError(0xdeadbeef); buffer[0] = '\0'
 162 #define EXPECT_LENW ok(ret == lstrlenW(Expected)+1, "Expected Len %d, got %d\n", lstrlenW(Expected)+1, ret)
 163 #define EXPECT_EQW  ok(strncmpW(buffer, Expected, strlenW(Expected)) == 0, "Bad conversion\n")
 164
 165 #define NUO LOCALE_NOUSEROVERRIDE
 166
 167 static void test_GetLocaleInfoA(void)
 168 {
 169   int ret;
 170   int len;
 171   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 172   char buffer[BUFFER_SIZE];
 173   char expected[BUFFER_SIZE];
 174   DWORD val;
 175
 176   ok(lcid == 0x409, "wrong LCID calculated - %d\n", lcid);
 177
 178   ret = GetLocaleInfoA(lcid, LOCALE_ILANGUAGE|LOCALE_RETURN_NUMBER, (char*)&val, sizeof(val));
 179   ok(ret, "got %d\n", ret);
 180   ok(val == lcid, "got 0x%08x\n", val);
 181
 182   /* en and ar use SUBLANG_NEUTRAL, but GetLocaleInfo assume SUBLANG_DEFAULT
 183      Same is true for zh on pre-Vista, but on Vista and higher GetLocaleInfo
 184      assumes SUBLANG_NEUTRAL for zh */
 185   memset(expected, 0, COUNTOF(expected));
 186   len = GetLocaleInfoA(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
 187   SetLastError(0xdeadbeef);
 188   memset(buffer, 0, COUNTOF(buffer));
 189   ret = GetLocaleInfoA(LANG_ENGLISH, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
 190   ok((ret == len) && !lstrcmpA(buffer, expected),
 191       "got %d with '%s' (expected %d with '%s')\n",
 192       ret, buffer, len, expected);
 193
 194   memset(expected, 0, COUNTOF(expected));
 195   len = GetLocaleInfoA(MAKELANGID(LANG_ARABIC, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
 196   if (len) {
 197       SetLastError(0xdeadbeef);
 198       memset(buffer, 0, COUNTOF(buffer));
 199       ret = GetLocaleInfoA(LANG_ARABIC, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
 200       ok((ret == len) && !lstrcmpA(buffer, expected),
 201           "got %d with '%s' (expected %d with '%s')\n",
 202           ret, buffer, len, expected);
 203   }
 204   else
 205       win_skip("LANG_ARABIC not installed\n");
 206
 207   /* SUBLANG_DEFAULT is required for mlang.dll, but optional for GetLocaleInfo */
 208   memset(expected, 0, COUNTOF(expected));
 209   len = GetLocaleInfoA(MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
 210   SetLastError(0xdeadbeef);
 211   memset(buffer, 0, COUNTOF(buffer));
 212   ret = GetLocaleInfoA(LANG_GERMAN, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
 213   ok((ret == len) && !lstrcmpA(buffer, expected),
 214       "got %d with '%s' (expected %d with '%s')\n",
 215       ret, buffer, len, expected);
 216
 217
 218   /* HTMLKit and "Font xplorer lite" expect GetLocaleInfoA to
 219    * partially fill the buffer even if it is too short. See bug 637.
 220    */
 221   SetLastError(0xdeadbeef);
 222   memset(buffer, 0, COUNTOF(buffer));
 223   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 0);
 224   ok(ret == 7 && !buffer[0], "Expected len=7, got %d\n", ret);
 225
 226   SetLastError(0xdeadbeef);
 227   memset(buffer, 0, COUNTOF(buffer));
 228   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 3);
 229   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 230       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 231   ok(!strcmp(buffer, "Mon"), "Expected 'Mon', got '%s'\n", buffer);
 232
 233   SetLastError(0xdeadbeef);
 234   memset(buffer, 0, COUNTOF(buffer));
 235   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 10);
 236   ok(ret == 7, "Expected ret == 7, got %d, error %d\n", ret, GetLastError());
 237   ok(!strcmp(buffer, "Monday"), "Expected 'Monday', got '%s'\n", buffer);
 238 }
 239
 240 struct neutralsublang_name2_t {
 241     WCHAR name[3];
 242     WCHAR sname[15];
 243     LCID lcid;
 244     LCID lcid_broken;
 245     WCHAR sname_broken[15];
 246     int todo;
 247 };
 248
 249 static const struct neutralsublang_name2_t neutralsublang_names2[] = {
 250     { {'a','r',0}, {'a','r','-','S','A',0},
 251       MAKELCID(MAKELANGID(LANG_ARABIC, SUBLANG_ARABIC_SAUDI_ARABIA), SORT_DEFAULT) },
 252     { {'a','z',0}, {'a','z','-','L','a','t','n','-','A','Z',0},
 253       MAKELCID(MAKELANGID(LANG_AZERI, SUBLANG_AZERI_LATIN), SORT_DEFAULT) },
 254     { {'d','e',0}, {'d','e','-','D','E',0},
 255       MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT) },
 256     { {'e','n',0}, {'e','n','-','U','S',0},
 257       MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) },
 258     { {'e','s',0}, {'e','s','-','E','S',0},
 259       MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH_MODERN), SORT_DEFAULT),
 260       MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH), SORT_DEFAULT) /* vista */,
 261       {'e','s','-','E','S','_','t','r','a','d','n','l',0} },
 262     { {'g','a',0}, {'g','a','-','I','E',0},
 263       MAKELCID(MAKELANGID(LANG_IRISH, SUBLANG_IRISH_IRELAND), SORT_DEFAULT), 0, {0}, 0x3 },
 264     { {'i','t',0}, {'i','t','-','I','T',0},
 265       MAKELCID(MAKELANGID(LANG_ITALIAN, SUBLANG_ITALIAN), SORT_DEFAULT) },
 266     { {'m','s',0}, {'m','s','-','M','Y',0},
 267       MAKELCID(MAKELANGID(LANG_MALAY, SUBLANG_MALAY_MALAYSIA), SORT_DEFAULT) },
 268     { {'n','l',0}, {'n','l','-','N','L',0},
 269       MAKELCID(MAKELANGID(LANG_DUTCH, SUBLANG_DUTCH), SORT_DEFAULT) },
 270     { {'p','t',0}, {'p','t','-','B','R',0},
 271       MAKELCID(MAKELANGID(LANG_PORTUGUESE, SUBLANG_PORTUGUESE_BRAZILIAN), SORT_DEFAULT) },
 272     { {'s','r',0}, {'h','r','-','H','R',0},
 273       MAKELCID(MAKELANGID(LANG_SERBIAN, SUBLANG_SERBIAN_CROATIA), SORT_DEFAULT) },
 274     { {'s','v',0}, {'s','v','-','S','E',0},
 275       MAKELCID(MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH), SORT_DEFAULT) },
 276     { {'u','z',0}, {'u','z','-','L','a','t','n','-','U','Z',0},
 277       MAKELCID(MAKELANGID(LANG_UZBEK, SUBLANG_UZBEK_LATIN), SORT_DEFAULT) },
 278     { {'z','h',0}, {'z','h','-','C','N',0},
 279       MAKELCID(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED), SORT_DEFAULT) },
 280     { {0} }
 281 };
 282
 283 static void test_GetLocaleInfoW(void)
 284 {
 285   LCID lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 286   LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
 287   LCID lcid_en_neut = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_NEUTRAL), SORT_DEFAULT);
 288   WCHAR bufferW[80], buffer2W[80];
 289   CHAR bufferA[80];
 290   DWORD val;
 291   DWORD ret;
 292   INT i;
 293
 294   ret = GetLocaleInfoW(lcid_en, LOCALE_SMONTHNAME1, bufferW, COUNTOF(bufferW));
 295   if (!ret) {
 296       win_skip("GetLocaleInfoW() isn't implemented\n");
 297       return;
 298   }
 299
 300   ret = GetLocaleInfoW(lcid_en, LOCALE_ILANGUAGE|LOCALE_RETURN_NUMBER, (WCHAR*)&val, sizeof(val)/sizeof(WCHAR));
 301   ok(ret, "got %d\n", ret);
 302   ok(val == lcid_en, "got 0x%08x\n", val);
 303
 304   ret = GetLocaleInfoW(lcid_en_neut, LOCALE_SNAME, bufferW, COUNTOF(bufferW));
 305   if (ret)
 306   {
 307       static const WCHAR slangW[] = {'E','n','g','l','i','s','h',' ','(','U','n','i','t','e','d',' ',
 308                                                                      'S','t','a','t','e','s',')',0};
 309       static const WCHAR statesW[] = {'U','n','i','t','e','d',' ','S','t','a','t','e','s',0};
 310       static const WCHAR enW[] = {'e','n','-','U','S',0};
 311       const struct neutralsublang_name2_t *ptr = neutralsublang_names2;
 312
 313       ok(!lstrcmpW(bufferW, enW), "got wrong name %s\n", wine_dbgstr_w(bufferW));
 314
 315       ret = GetLocaleInfoW(lcid_en_neut, LOCALE_SCOUNTRY, bufferW, COUNTOF(bufferW));
 316       ok(ret, "got %d\n", ret);
 317       if ((PRIMARYLANGID(LANGIDFROMLCID(GetSystemDefaultLCID())) != LANG_ENGLISH) ||
 318           (PRIMARYLANGID(LANGIDFROMLCID(GetThreadLocale())) != LANG_ENGLISH))
 319       {
 320           skip("Non-English locale\n");
 321       }
 322       else
 323           ok(!lstrcmpW(statesW, bufferW), "got wrong name %s\n", wine_dbgstr_w(bufferW));
 324
 325       ret = GetLocaleInfoW(lcid_en_neut, LOCALE_SLANGUAGE, bufferW, COUNTOF(bufferW));
 326       ok(ret, "got %d\n", ret);
 327       if ((PRIMARYLANGID(LANGIDFROMLCID(GetSystemDefaultLCID())) != LANG_ENGLISH) ||
 328           (PRIMARYLANGID(LANGIDFROMLCID(GetThreadLocale())) != LANG_ENGLISH))
 329       {
 330           skip("Non-English locale\n");
 331       }
 332       else
 333           ok(!lstrcmpW(slangW, bufferW), "got wrong name %s\n", wine_dbgstr_w(bufferW));
 334
 335       while (*ptr->name)
 336       {
 337           LANGID langid;
 338           LCID lcid;
 339
 340           /* make neutral lcid */
 341           langid = MAKELANGID(PRIMARYLANGID(LANGIDFROMLCID(ptr->lcid)), SUBLANG_NEUTRAL);
 342           lcid = MAKELCID(langid, SORT_DEFAULT);
 343
 344           val = 0;
 345           GetLocaleInfoW(lcid, LOCALE_ILANGUAGE|LOCALE_RETURN_NUMBER, (WCHAR*)&val, sizeof(val)/sizeof(WCHAR));
 346           todo_wine_if (ptr->todo & 0x1)
 347               ok(val == ptr->lcid || (val && broken(val == ptr->lcid_broken)), "%s: got wrong lcid 0x%04x, expected 0x%04x\n",
 348                   wine_dbgstr_w(ptr->name), val, ptr->lcid);
 349
 350           /* now check LOCALE_SNAME */
 351           GetLocaleInfoW(lcid, LOCALE_SNAME, bufferW, COUNTOF(bufferW));
 352           todo_wine_if (ptr->todo & 0x2)
 353               ok(!lstrcmpW(bufferW, ptr->sname) ||
 354                  (*ptr->sname_broken && broken(!lstrcmpW(bufferW, ptr->sname_broken))),
 355                   "%s: got %s\n", wine_dbgstr_w(ptr->name), wine_dbgstr_w(bufferW));
 356           ptr++;
 357       }
 358   }
 359   else
 360       win_skip("English neutral locale not supported\n");
 361
 362   ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1, bufferW, COUNTOF(bufferW));
 363   if (!ret) {
 364       win_skip("LANG_RUSSIAN locale data unavailable\n");
 365       return;
 366   }
 367   ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1|LOCALE_RETURN_GENITIVE_NAMES,
 368                        bufferW, COUNTOF(bufferW));
 369   if (!ret) {
 370       win_skip("LOCALE_RETURN_GENITIVE_NAMES isn't supported\n");
 371       return;
 372   }
 373
 374   /* LOCALE_RETURN_GENITIVE_NAMES isn't supported for GetLocaleInfoA */
 375   bufferA[0] = 'a';
 376   SetLastError(0xdeadbeef);
 377   ret = GetLocaleInfoA(lcid_ru, LOCALE_SMONTHNAME1|LOCALE_RETURN_GENITIVE_NAMES,
 378                        bufferA, COUNTOF(bufferA));
 379   ok(ret == 0, "LOCALE_RETURN_GENITIVE_NAMES should fail with GetLocaleInfoA\n");
 380   ok(bufferA[0] == 'a', "Expected buffer to be untouched\n");
 381   ok(GetLastError() == ERROR_INVALID_FLAGS,
 382      "Expected ERROR_INVALID_FLAGS, got %x\n", GetLastError());
 383
 384   bufferW[0] = 'a';
 385   SetLastError(0xdeadbeef);
 386   ret = GetLocaleInfoW(lcid_ru, LOCALE_RETURN_GENITIVE_NAMES,
 387                        bufferW, COUNTOF(bufferW));
 388   ok(ret == 0,
 389      "LOCALE_RETURN_GENITIVE_NAMES itself doesn't return anything, got %d\n", ret);
 390   ok(bufferW[0] == 'a', "Expected buffer to be untouched\n");
 391   ok(GetLastError() == ERROR_INVALID_FLAGS,
 392      "Expected ERROR_INVALID_FLAGS, got %x\n", GetLastError());
 393
 394   /* yes, test empty 13 month entry too */
 395   for (i = 0; i < 12; i++) {
 396       bufferW[0] = 0;
 397       ret = GetLocaleInfoW(lcid_ru, (LOCALE_SMONTHNAME1+i)|LOCALE_RETURN_GENITIVE_NAMES,
 398                            bufferW, COUNTOF(bufferW));
 399       ok(ret, "Expected non zero result\n");
 400       ok(ret == lstrlenW(bufferW)+1, "Expected actual length, got %d, length %d\n",
 401                                     ret, lstrlenW(bufferW));
 402       buffer2W[0] = 0;
 403       ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1+i,
 404                            buffer2W, COUNTOF(buffer2W));
 405       ok(ret, "Expected non zero result\n");
 406       ok(ret == lstrlenW(buffer2W)+1, "Expected actual length, got %d, length %d\n",
 407                                     ret, lstrlenW(buffer2W));
 408
 409       ok(lstrcmpW(bufferW, buffer2W) != 0,
 410            "Expected genitive name to differ, got the same for month %d\n", i+1);
 411
 412       /* for locale without genitive names nominative returned in both cases */
 413       bufferW[0] = 0;
 414       ret = GetLocaleInfoW(lcid_en, (LOCALE_SMONTHNAME1+i)|LOCALE_RETURN_GENITIVE_NAMES,
 415                            bufferW, COUNTOF(bufferW));
 416       ok(ret, "Expected non zero result\n");
 417       ok(ret == lstrlenW(bufferW)+1, "Expected actual length, got %d, length %d\n",
 418                                     ret, lstrlenW(bufferW));
 419       buffer2W[0] = 0;
 420       ret = GetLocaleInfoW(lcid_en, LOCALE_SMONTHNAME1+i,
 421                            buffer2W, COUNTOF(buffer2W));
 422       ok(ret, "Expected non zero result\n");
 423       ok(ret == lstrlenW(buffer2W)+1, "Expected actual length, got %d, length %d\n",
 424                                     ret, lstrlenW(buffer2W));
 425
 426       ok(lstrcmpW(bufferW, buffer2W) == 0,
 427          "Expected same names, got different for month %d\n", i+1);
 428   }
 429 }
 430
 431 static void test_GetTimeFormatA(void)
 432 {
 433   int ret;
 434   SYSTEMTIME  curtime;
 435   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 436   char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 437
 438   memset(&curtime, 2, sizeof(SYSTEMTIME));
 439   STRINGSA("tt HH':'mm'@'ss", ""); /* Invalid time */
 440   SetLastError(0xdeadbeef);
 441   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 442   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 443       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 444
 445   curtime.wHour = 8;
 446   curtime.wMinute = 56;
 447   curtime.wSecond = 13;
 448   curtime.wMilliseconds = 22;
 449   STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Valid time */
 450   SetLastError(0xdeadbeef);
 451   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 452   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 453   EXPECT_LENA; EXPECT_EQA;
 454
 455   /* MSDN: LOCALE_NOUSEROVERRIDE can't be specified with a format string */
 456   SetLastError(0xdeadbeef);
 457   ret = GetTimeFormatA(lcid, NUO|TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 458   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 459      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 460
 461   STRINGSA("tt HH':'mm'@'ss", "A"); /* Insufficient buffer */
 462   SetLastError(0xdeadbeef);
 463   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, 2);
 464   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 465       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 466
 467   STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Calculate length only */
 468   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, NULL, 0);
 469   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 470   EXPECT_LENA;
 471
 472   STRINGSA("", "8 AM"); /* TIME_NOMINUTESORSECONDS, default format */
 473   ret = GetTimeFormatA(lcid, NUO|TIME_NOMINUTESORSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 474   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 475   EXPECT_LENA; EXPECT_EQA;
 476
 477   STRINGSA("m1s2m3s4", ""); /* TIME_NOMINUTESORSECONDS/complex format */
 478   ret = GetTimeFormatA(lcid, TIME_NOMINUTESORSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 479   ok(ret == strlen(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 480   ok( !strcmp( buffer, "" ) || broken( !strcmp( buffer, "4" )), /* win9x */
 481       "Expected '', got '%s'\n", buffer );
 482
 483   STRINGSA("", "8:56 AM"); /* TIME_NOSECONDS/Default format */
 484   ret = GetTimeFormatA(lcid, NUO|TIME_NOSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 485   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 486   EXPECT_LENA; EXPECT_EQA;
 487
 488   STRINGSA("h:m:s tt", "8:56 AM"); /* TIME_NOSECONDS */
 489   strcpy(Expected, "8:56 AM");
 490   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 491   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 492   EXPECT_LENA; EXPECT_EQA;
 493
 494   STRINGSA("h.@:m.@:s.@:tt", "8.@:56AM"); /* Multiple delimiters */
 495   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 496   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 497   ok( !strcmp( buffer, "8.@:56AM" ) || broken( !strcmp( buffer, "8.@:56.@:AM" )) /* win9x */,
 498       "Expected '8.@:56AM', got '%s'\n", buffer );
 499
 500   STRINGSA("s1s2s3", ""); /* Duplicate tokens */
 501   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 502   ok(ret == strlen(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 503   ok( !strcmp( buffer, "" ) || broken( !strcmp( buffer, "3" )), /* win9x */
 504       "Expected '', got '%s'\n", buffer );
 505
 506   STRINGSA("t/tt", "A/AM"); /* AM time marker */
 507   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 508   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 509   EXPECT_LENA; EXPECT_EQA;
 510
 511   curtime.wHour = 13;
 512   STRINGSA("t/tt", "P/PM"); /* PM time marker */
 513   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 514   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 515   EXPECT_LENA; EXPECT_EQA;
 516
 517   STRINGSA("h1t2tt3m", "156"); /* TIME_NOTIMEMARKER: removes text around time marker token */
 518   ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 519   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 520   EXPECT_LENA; EXPECT_EQA;
 521
 522   STRINGSA("h:m:s tt", "13:56:13 PM"); /* TIME_FORCE24HOURFORMAT */
 523   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 524   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 525   EXPECT_LENA; EXPECT_EQA;
 526
 527   STRINGSA("h:m:s", "13:56:13"); /* TIME_FORCE24HOURFORMAT doesn't add time marker */
 528   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 529   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 530   EXPECT_LENA; EXPECT_EQA;
 531
 532   curtime.wHour = 14; /* change this to 14 or 2pm */
 533   curtime.wMinute = 5;
 534   curtime.wSecond = 3;
 535   STRINGSA("h hh H HH m mm s ss t tt", "2 02 14 14 5 05 3 03 P PM"); /* 24 hrs, leading 0 */
 536   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 537   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 538   EXPECT_LENA; EXPECT_EQA;
 539
 540   curtime.wHour = 0;
 541   STRINGSA("h/H/hh/HH", "12/0/12/00"); /* "hh" and "HH" */
 542   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 543   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 544   EXPECT_LENA; EXPECT_EQA;
 545
 546   STRINGSA("h:m:s tt", "12:5:3 AM"); /* non-zero flags should fail with format, doesn't */
 547   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 548   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 549   EXPECT_LENA; EXPECT_EQA;
 550
 551   /* try to convert formatting strings with more than two letters
 552    * "h:hh:hhh:H:HH:HHH:m:mm:mmm:M:MM:MMM:s:ss:sss:S:SS:SSS"
 553    * NOTE: We expect any letter for which there is an upper case value
 554    *       we should see a replacement.  For letters that DO NOT have
 555    *       upper case values we should see NO REPLACEMENT.
 556    */
 557   curtime.wHour = 8;
 558   curtime.wMinute = 56;
 559   curtime.wSecond = 13;
 560   curtime.wMilliseconds = 22;
 561   STRINGSA("h:hh:hhh H:HH:HHH m:mm:mmm M:MM:MMM s:ss:sss S:SS:SSS",
 562            "8:08:08 8:08:08 56:56:56 M:MM:MMM 13:13:13 S:SS:SSS");
 563   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 564   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 565   EXPECT_LENA; EXPECT_EQA;
 566
 567   STRINGSA("h", "text"); /* Don't write to buffer if len is 0 */
 568   strcpy(buffer, "text");
 569   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, 0);
 570   ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
 571   EXPECT_EQA;
 572
 573   STRINGSA("h 'h' H 'H' HH 'HH' m 'm' s 's' t 't' tt 'tt'",
 574            "8 h 8 H 08 HH 56 m 13 s A t AM tt"); /* "'" preserves tokens */
 575   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 576   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 577   EXPECT_LENA; EXPECT_EQA;
 578
 579   STRINGSA("'''", "'"); /* invalid quoted string */
 580   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 581   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 582   EXPECT_LENA; EXPECT_EQA;
 583
 584   /* test that msdn suggested single quotation usage works as expected */
 585   STRINGSA("''''", "'"); /* single quote mark */
 586   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 587   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 588   EXPECT_LENA; EXPECT_EQA;
 589
 590   STRINGSA("''HHHHHH", "08"); /* Normal use */
 591   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 592   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 593   EXPECT_LENA; EXPECT_EQA;
 594
 595   /* and test for normal use of the single quotation mark */
 596   STRINGSA("'''HHHHHH'", "'HHHHHH"); /* Normal use */
 597   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 598   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 599   EXPECT_LENA; EXPECT_EQA;
 600
 601   STRINGSA("'''HHHHHH", "'HHHHHH"); /* Odd use */
 602   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 603   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 604   EXPECT_LENA; EXPECT_EQA;
 605
 606   STRINGSA("'123'tt", ""); /* TIME_NOTIMEMARKER drops literals too */
 607   ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 608   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 609   EXPECT_LENA; EXPECT_EQA;
 610
 611   curtime.wHour = 25;
 612   STRINGSA("'123'tt", ""); /* Invalid time */
 613   SetLastError(0xdeadbeef);
 614   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 615   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 616       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 617
 618   curtime.wHour = 12;
 619   curtime.wMonth = 60; /* Invalid */
 620   STRINGSA("h:m:s", "12:56:13"); /* Invalid date */
 621   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 622   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 623   EXPECT_LENA; EXPECT_EQA;
 624 }
 625
 626 static void test_GetTimeFormatEx(void)
 627 {
 628   int ret;
 629   SYSTEMTIME  curtime;
 630   WCHAR buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 631
 632   if (!pGetTimeFormatEx)
 633   {
 634       win_skip("GetTimeFormatEx not supported\n");
 635       return;
 636   }
 637
 638   memset(&curtime, 2, sizeof(SYSTEMTIME));
 639   STRINGSW("tt HH':'mm'@'ss", ""); /* Invalid time */
 640   SetLastError(0xdeadbeef);
 641   ret = pGetTimeFormatEx(localeW, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 642   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 643       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 644
 645   curtime.wHour = 8;
 646   curtime.wMinute = 56;
 647   curtime.wSecond = 13;
 648   curtime.wMilliseconds = 22;
 649   STRINGSW("tt HH':'mm'@'ss", "AM 08:56@13"); /* Valid time */
 650   SetLastError(0xdeadbeef);
 651   ret = pGetTimeFormatEx(localeW, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 652   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 653   EXPECT_LENW; EXPECT_EQW;
 654
 655   /* MSDN: LOCALE_NOUSEROVERRIDE can't be specified with a format string */
 656   SetLastError(0xdeadbeef);
 657   ret = pGetTimeFormatEx(localeW, NUO|TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 658   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 659      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 660
 661   STRINGSW("tt HH':'mm'@'ss", "A"); /* Insufficient buffer */
 662   SetLastError(0xdeadbeef);
 663   ret = pGetTimeFormatEx(localeW, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, 2);
 664   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 665       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 666
 667   STRINGSW("tt HH':'mm'@'ss", "AM 08:56@13"); /* Calculate length only */
 668   ret = pGetTimeFormatEx(localeW, TIME_FORCE24HOURFORMAT, &curtime, input, NULL, 0);
 669   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 670   EXPECT_LENW;
 671
 672   STRINGSW("", "8 AM"); /* TIME_NOMINUTESORSECONDS, default format */
 673   ret = pGetTimeFormatEx(localeW, NUO|TIME_NOMINUTESORSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 674   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 675   EXPECT_LENW; EXPECT_EQW;
 676
 677   STRINGSW("m1s2m3s4", ""); /* TIME_NOMINUTESORSECONDS/complex format */
 678   ret = pGetTimeFormatEx(localeW, TIME_NOMINUTESORSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 679   ok(ret == strlenW(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 680   EXPECT_LENW; EXPECT_EQW;
 681
 682   STRINGSW("", "8:56 AM"); /* TIME_NOSECONDS/Default format */
 683   ret = pGetTimeFormatEx(localeW, NUO|TIME_NOSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 684   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 685   EXPECT_LENW; EXPECT_EQW;
 686
 687   STRINGSW("h:m:s tt", "8:56 AM"); /* TIME_NOSECONDS */
 688   ret = pGetTimeFormatEx(localeW, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 689   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 690   EXPECT_LENW; EXPECT_EQW;
 691
 692   STRINGSW("h.@:m.@:s.@:tt", "8.@:56AM"); /* Multiple delimiters */
 693   ret = pGetTimeFormatEx(localeW, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 694   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 695   EXPECT_LENW; EXPECT_EQW;
 696
 697   STRINGSW("s1s2s3", ""); /* Duplicate tokens */
 698   ret = pGetTimeFormatEx(localeW, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 699   ok(ret == strlenW(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 700   EXPECT_LENW; EXPECT_EQW;
 701
 702   STRINGSW("t/tt", "A/AM"); /* AM time marker */
 703   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 704   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 705   EXPECT_LENW; EXPECT_EQW;
 706
 707   curtime.wHour = 13;
 708   STRINGSW("t/tt", "P/PM"); /* PM time marker */
 709   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 710   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 711   EXPECT_LENW; EXPECT_EQW;
 712
 713   STRINGSW("h1t2tt3m", "156"); /* TIME_NOTIMEMARKER: removes text around time marker token */
 714   ret = pGetTimeFormatEx(localeW, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 715   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 716   EXPECT_LENW; EXPECT_EQW;
 717
 718   STRINGSW("h:m:s tt", "13:56:13 PM"); /* TIME_FORCE24HOURFORMAT */
 719   ret = pGetTimeFormatEx(localeW, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 720   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 721   EXPECT_LENW; EXPECT_EQW;
 722
 723   STRINGSW("h:m:s", "13:56:13"); /* TIME_FORCE24HOURFORMAT doesn't add time marker */
 724   ret = pGetTimeFormatEx(localeW, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 725   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 726   EXPECT_LENW; EXPECT_EQW;
 727
 728   curtime.wHour = 14; /* change this to 14 or 2pm */
 729   curtime.wMinute = 5;
 730   curtime.wSecond = 3;
 731   STRINGSW("h hh H HH m mm s ss t tt", "2 02 14 14 5 05 3 03 P PM"); /* 24 hrs, leading 0 */
 732   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 733   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 734   EXPECT_LENW; EXPECT_EQW;
 735
 736   curtime.wHour = 0;
 737   STRINGSW("h/H/hh/HH", "12/0/12/00"); /* "hh" and "HH" */
 738   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 739   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 740   EXPECT_LENW; EXPECT_EQW;
 741
 742   STRINGSW("h:m:s tt", "12:5:3 AM"); /* non-zero flags should fail with format, doesn't */
 743   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 744   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 745   EXPECT_LENW; EXPECT_EQW;
 746
 747   /* try to convert formatting strings with more than two letters
 748    * "h:hh:hhh:H:HH:HHH:m:mm:mmm:M:MM:MMM:s:ss:sss:S:SS:SSS"
 749    * NOTE: We expect any letter for which there is an upper case value
 750    *       we should see a replacement.  For letters that DO NOT have
 751    *       upper case values we should see NO REPLACEMENT.
 752    */
 753   curtime.wHour = 8;
 754   curtime.wMinute = 56;
 755   curtime.wSecond = 13;
 756   curtime.wMilliseconds = 22;
 757   STRINGSW("h:hh:hhh H:HH:HHH m:mm:mmm M:MM:MMM s:ss:sss S:SS:SSS",
 758            "8:08:08 8:08:08 56:56:56 M:MM:MMM 13:13:13 S:SS:SSS");
 759   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 760   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 761   EXPECT_LENW; EXPECT_EQW;
 762
 763   STRINGSW("h", "text"); /* Don't write to buffer if len is 0 */
 764   lstrcpyW(buffer, Expected);
 765   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, 0);
 766   ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
 767   EXPECT_EQW;
 768
 769   STRINGSW("h 'h' H 'H' HH 'HH' m 'm' s 's' t 't' tt 'tt'",
 770            "8 h 8 H 08 HH 56 m 13 s A t AM tt"); /* "'" preserves tokens */
 771   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 772   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 773   EXPECT_LENW; EXPECT_EQW;
 774
 775   STRINGSW("'''", "'"); /* invalid quoted string */
 776   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 777   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 778   EXPECT_LENW; EXPECT_EQW;
 779
 780   /* test that msdn suggested single quotation usage works as expected */
 781   STRINGSW("''''", "'"); /* single quote mark */
 782   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 783   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 784   EXPECT_LENW; EXPECT_EQW;
 785
 786   STRINGSW("''HHHHHH", "08"); /* Normal use */
 787   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 788   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 789   EXPECT_LENW; EXPECT_EQW;
 790
 791   /* and test for normal use of the single quotation mark */
 792   STRINGSW("'''HHHHHH'", "'HHHHHH"); /* Normal use */
 793   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 794   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 795   EXPECT_LENW; EXPECT_EQW;
 796
 797   STRINGSW("'''HHHHHH", "'HHHHHH"); /* Odd use */
 798   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 799   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 800   EXPECT_LENW; EXPECT_EQW;
 801
 802   STRINGSW("'123'tt", ""); /* TIME_NOTIMEMARKER drops literals too */
 803   ret = pGetTimeFormatEx(localeW, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 804   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 805   EXPECT_LENW; EXPECT_EQW;
 806
 807   curtime.wHour = 25;
 808   STRINGSW("'123'tt", ""); /* Invalid time */
 809   SetLastError(0xdeadbeef);
 810   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 811   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 812       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 813
 814   curtime.wHour = 12;
 815   curtime.wMonth = 60; /* Invalid */
 816   STRINGSW("h:m:s", "12:56:13"); /* Invalid date */
 817   ret = pGetTimeFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer));
 818   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 819   EXPECT_LENW; EXPECT_EQW;
 820 }
 821
 822 static void test_GetDateFormatA(void)
 823 {
 824   int ret;
 825   SYSTEMTIME  curtime;
 826   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 827   LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
 828   char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 829   char Broken[BUFFER_SIZE];
 830   char short_day[10], month[10], genitive_month[10];
 831
 832   memset(&curtime, 2, sizeof(SYSTEMTIME)); /* Invalid time */
 833   STRINGSA("ddd',' MMM dd yy","");
 834   SetLastError(0xdeadbeef);
 835   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 836   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 837       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 838
 839   curtime.wYear = 2002;
 840   curtime.wMonth = 5;
 841   curtime.wDay = 4;
 842   curtime.wDayOfWeek = 3;
 843   STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Simple case */
 844   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 845   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 846   EXPECT_LENA; EXPECT_EQA;
 847
 848   /* Same as above but with LOCALE_NOUSEROVERRIDE */
 849   STRINGSA("ddd',' MMM dd yy",""); /* Simple case */
 850   SetLastError(0xdeadbeef);
 851   ret = GetDateFormatA(lcid, NUO, &curtime, input, buffer, COUNTOF(buffer));
 852   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 853      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 854   EXPECT_EQA;
 855
 856   STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Format containing "'" */
 857   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 858   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 859   EXPECT_LENA; EXPECT_EQA;
 860
 861   curtime.wHour = 36; /* Invalid */
 862   STRINGSA("ddd',' MMM dd ''''yy","Sat, May 04 '02"); /* Invalid time */
 863   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 864   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 865   EXPECT_LENA; EXPECT_EQA;
 866
 867   STRINGSA("ddd',' MMM dd ''''yy",""); /* Get size only */
 868   ret = GetDateFormatA(lcid, 0, &curtime, input, NULL, 0);
 869   ok(ret == 16, "Expected ret == 16, got %d, error %d\n", ret, GetLastError());
 870   EXPECT_EQA;
 871
 872   STRINGSA("ddd',' MMM dd ''''yy",""); /* Buffer too small */
 873   SetLastError(0xdeadbeef);
 874   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, 2);
 875   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 876       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 877
 878   STRINGSA("ddd',' MMM dd ''''yy","5/4/2002"); /* Default to DATE_SHORTDATE */
 879   ret = GetDateFormatA(lcid, NUO, &curtime, NULL, buffer, COUNTOF(buffer));
 880   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 881   if (strncmp(buffer, Expected, strlen(Expected)) && strncmp(buffer, "5/4/02", strlen(Expected)) != 0)
 882           ok (0, "Expected '%s' or '5/4/02', got '%s'\n", Expected, buffer);
 883
 884   SetLastError(0xdeadbeef); buffer[0] = '\0'; /* DATE_LONGDATE */
 885   ret = GetDateFormatA(lcid, NUO|DATE_LONGDATE, &curtime, NULL, buffer, COUNTOF(buffer));
 886   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 887   ok(strcmp(buffer, "Saturday, May 04, 2002") == 0 ||
 888      strcmp(buffer, "Saturday, May 4, 2002") == 0 /* Win 8 */,
 889      "got an unexpected date string '%s'\n", buffer);
 890
 891   /* test for expected DATE_YEARMONTH behavior with null format */
 892   /* NT4 returns ERROR_INVALID_FLAGS for DATE_YEARMONTH */
 893   STRINGSA("ddd',' MMM dd ''''yy", ""); /* DATE_YEARMONTH */
 894   SetLastError(0xdeadbeef);
 895   ret = GetDateFormatA(lcid, NUO|DATE_YEARMONTH, &curtime, input, buffer, COUNTOF(buffer));
 896   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 897      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 898   EXPECT_EQA;
 899
 900   /* Test that using invalid DATE_* flags results in the correct error */
 901   /* and return values */
 902   STRINGSA("m/d/y", ""); /* Invalid flags */
 903   SetLastError(0xdeadbeef);
 904   ret = GetDateFormatA(lcid, DATE_YEARMONTH|DATE_SHORTDATE|DATE_LONGDATE,
 905                       &curtime, input, buffer, COUNTOF(buffer));
 906   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 907      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 908
 909   ret = GetDateFormatA(lcid_ru, 0, &curtime, "ddMMMM", buffer, COUNTOF(buffer));
 910   if (!ret)
 911   {
 912     win_skip("LANG_RUSSIAN locale data unavailable\n");
 913     return;
 914   }
 915
 916   /* month part should be in genitive form */
 917   strcpy(genitive_month, buffer + 2);
 918   ret = GetDateFormatA(lcid_ru, 0, &curtime, "MMMM", buffer, COUNTOF(buffer));
 919   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 920   strcpy(month, buffer);
 921   ok(strcmp(genitive_month, month) != 0, "Expected different month forms\n");
 922
 923   ret = GetDateFormatA(lcid_ru, 0, &curtime, "ddd", buffer, COUNTOF(buffer));
 924   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 925   strcpy(short_day, buffer);
 926
 927   STRINGSA("dd MMMMddd dd", "");
 928   sprintf(Expected, "04 %s%s 04", genitive_month, short_day);
 929   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 930   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 931   EXPECT_EQA;
 932
 933   STRINGSA("MMMMddd dd", "");
 934   sprintf(Expected, "%s%s 04", month, short_day);
 935   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 936   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 937   EXPECT_EQA;
 938
 939   STRINGSA("MMMMddd", "");
 940   sprintf(Expected, "%s%s", month, short_day);
 941   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 942   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 943   EXPECT_EQA;
 944
 945   STRINGSA("MMMMdd", "");
 946   sprintf(Expected, "%s04", genitive_month);
 947   sprintf(Broken, "%s04", month);
 948   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 949   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 950   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 951      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 952      "Expected '%s', got '%s'\n", Expected, buffer);
 953
 954   STRINGSA("MMMMdd ddd", "");
 955   sprintf(Expected, "%s04 %s", genitive_month, short_day);
 956   sprintf(Broken, "%s04 %s", month, short_day);
 957   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 958   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 959   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 960      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 961      "Expected '%s', got '%s'\n", Expected, buffer);
 962
 963   STRINGSA("dd dddMMMM", "");
 964   sprintf(Expected, "04 %s%s", short_day, month);
 965   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 966   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 967   EXPECT_EQA;
 968
 969   STRINGSA("dd dddMMMM ddd MMMMdd", "");
 970   sprintf(Expected, "04 %s%s %s %s04", short_day, month, short_day, genitive_month);
 971   sprintf(Broken, "04 %s%s %s %s04", short_day, month, short_day, month);
 972   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 973   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 974   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 975      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 976      "Expected '%s', got '%s'\n", Expected, buffer);
 977
 978   /* with literal part */
 979   STRINGSA("ddd',' MMMM dd", "");
 980   sprintf(Expected, "%s, %s 04", short_day, genitive_month);
 981   sprintf(Broken, "%s, %s 04", short_day, month);
 982   ret = GetDateFormatA(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 983   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 984   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 985      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 986      "Expected '%s', got '%s'\n", Expected, buffer);
 987 }
 988
 989 static void test_GetDateFormatEx(void)
 990 {
 991   int ret;
 992   SYSTEMTIME  curtime;
 993   WCHAR buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 994
 995   if (!pGetDateFormatEx)
 996   {
 997       win_skip("GetDateFormatEx not supported\n");
 998       return;
 999   }
1000
1001   STRINGSW("",""); /* If flags are set, then format must be NULL */
1002   SetLastError(0xdeadbeef);
1003   ret = pGetDateFormatEx(localeW, DATE_LONGDATE, NULL,
1004                        input, buffer, COUNTOF(buffer), NULL);
1005   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
1006      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1007   EXPECT_EQW;
1008
1009   STRINGSW("",""); /* NULL buffer, len > 0 */
1010   SetLastError(0xdeadbeef);
1011   ret = pGetDateFormatEx(localeW, 0, NULL, input, NULL, COUNTOF(buffer), NULL);
1012   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1013       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1014
1015   STRINGSW("",""); /* NULL buffer, len == 0 */
1016   ret = pGetDateFormatEx(localeW, 0, NULL, input, NULL, 0, NULL);
1017   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1018   EXPECT_LENW; EXPECT_EQW;
1019
1020   STRINGSW("",""); /* Invalid flag combination */
1021   SetLastError(0xdeadbeef);
1022   ret = pGetDateFormatEx(localeW, DATE_LONGDATE|DATE_SHORTDATE, NULL,
1023                        input, NULL, 0, NULL);
1024   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
1025      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1026   EXPECT_EQW;
1027
1028   curtime.wYear = 2002;
1029   curtime.wMonth = 10;
1030   curtime.wDay = 23;
1031   curtime.wDayOfWeek = 45612; /* Should be 3 - Wednesday */
1032   curtime.wHour = 65432; /* Invalid */
1033   curtime.wMinute = 34512; /* Invalid */
1034   curtime.wSecond = 65535; /* Invalid */
1035   curtime.wMilliseconds = 12345;
1036   STRINGSW("dddd d MMMM yyyy","Wednesday 23 October 2002"); /* Incorrect DOW and time */
1037   ret = pGetDateFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer), NULL);
1038   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1039   EXPECT_LENW; EXPECT_EQW;
1040
1041   curtime.wYear = 2002;
1042   curtime.wMonth = 10;
1043   curtime.wDay = 23;
1044   curtime.wDayOfWeek = 45612; /* Should be 3 - Wednesday */
1045   curtime.wHour = 65432; /* Invalid */
1046   curtime.wMinute = 34512; /* Invalid */
1047   curtime.wSecond = 65535; /* Invalid */
1048   curtime.wMilliseconds = 12345;
1049   STRINGSW("dddd d MMMM yyyy","Wednesday 23 October 2002");
1050   ret = pGetDateFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer), emptyW); /* Use reserved arg */
1051   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1052       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1053
1054   /* Limit tests */
1055
1056   curtime.wYear = 1601;
1057   curtime.wMonth = 1;
1058   curtime.wDay = 1;
1059   curtime.wDayOfWeek = 0; /* Irrelevant */
1060   curtime.wHour = 0;
1061   curtime.wMinute = 0;
1062   curtime.wSecond = 0;
1063   curtime.wMilliseconds = 0;
1064   STRINGSW("dddd d MMMM yyyy","Monday 1 January 1601");
1065   SetLastError(0xdeadbeef);
1066   ret = pGetDateFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer), NULL);
1067   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1068   EXPECT_LENW; EXPECT_EQW;
1069
1070   curtime.wYear = 1600;
1071   curtime.wMonth = 12;
1072   curtime.wDay = 31;
1073   curtime.wDayOfWeek = 0; /* Irrelevant */
1074   curtime.wHour = 23;
1075   curtime.wMinute = 59;
1076   curtime.wSecond = 59;
1077   curtime.wMilliseconds = 999;
1078   STRINGSW("dddd d MMMM yyyy","Friday 31 December 1600");
1079   SetLastError(0xdeadbeef);
1080   ret = pGetDateFormatEx(localeW, 0, &curtime, input, buffer, COUNTOF(buffer), NULL);
1081   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1082       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1083 }
1084
1085 static void test_GetDateFormatW(void)
1086 {
1087   int ret;
1088   SYSTEMTIME  curtime;
1089   WCHAR buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
1090   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
1091
1092   STRINGSW("",""); /* If flags is not zero then format must be NULL */
1093   ret = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, DATE_LONGDATE, NULL,
1094                        input, buffer, COUNTOF(buffer));
1095   if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1096   {
1097     win_skip("GetDateFormatW is not implemented\n");
1098     return;
1099   }
1100   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
1101      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1102   EXPECT_EQW;
1103
1104   STRINGSW("",""); /* NULL buffer, len > 0 */
1105   SetLastError(0xdeadbeef);
1106   ret = GetDateFormatW (lcid, 0, NULL, input, NULL, COUNTOF(buffer));
1107   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1108       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1109
1110   STRINGSW("",""); /* NULL buffer, len == 0 */
1111   ret = GetDateFormatW (lcid, 0, NULL, input, NULL, 0);
1112   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1113   EXPECT_LENW; EXPECT_EQW;
1114
1115   curtime.wYear = 2002;
1116   curtime.wMonth = 10;
1117   curtime.wDay = 23;
1118   curtime.wDayOfWeek = 45612; /* Should be 3 - Wednesday */
1119   curtime.wHour = 65432; /* Invalid */
1120   curtime.wMinute = 34512; /* Invalid */
1121   curtime.wSecond = 65535; /* Invalid */
1122   curtime.wMilliseconds = 12345;
1123   STRINGSW("dddd d MMMM yyyy","Wednesday 23 October 2002"); /* Incorrect DOW and time */
1124   ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
1125   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1126   EXPECT_LENW; EXPECT_EQW;
1127
1128   /* Limit tests */
1129
1130   curtime.wYear = 1601;
1131   curtime.wMonth = 1;
1132   curtime.wDay = 1;
1133   curtime.wDayOfWeek = 0; /* Irrelevant */
1134   curtime.wHour = 0;
1135   curtime.wMinute = 0;
1136   curtime.wSecond = 0;
1137   curtime.wMilliseconds = 0;
1138   STRINGSW("dddd d MMMM yyyy","Monday 1 January 1601");
1139   SetLastError(0xdeadbeef);
1140   ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
1141   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1142   EXPECT_LENW; EXPECT_EQW;
1143
1144   curtime.wYear = 1600;
1145   curtime.wMonth = 12;
1146   curtime.wDay = 31;
1147   curtime.wDayOfWeek = 0; /* Irrelevant */
1148   curtime.wHour = 23;
1149   curtime.wMinute = 59;
1150   curtime.wSecond = 59;
1151   curtime.wMilliseconds = 999;
1152   STRINGSW("dddd d MMMM yyyy","Friday 31 December 1600");
1153   SetLastError(0xdeadbeef);
1154   ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
1155   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1156       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1157 }
1158
1159
1160 #define CY_POS_LEFT  0
1161 #define CY_POS_RIGHT 1
1162 #define CY_POS_LEFT_SPACE  2
1163 #define CY_POS_RIGHT_SPACE 3
1164
1165 static void test_GetCurrencyFormatA(void)
1166 {
1167   static char szDot[] = { '.', '\0' };
1168   static char szComma[] = { ',', '\0' };
1169   static char szDollar[] = { '$', '\0' };
1170   int ret;
1171   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
1172   char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
1173   CURRENCYFMTA format;
1174
1175   memset(&format, 0, sizeof(format));
1176
1177   STRINGSA("23",""); /* NULL output, length > 0 --> Error */
1178   SetLastError(0xdeadbeef);
1179   ret = GetCurrencyFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
1180   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1181       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1182
1183   STRINGSA("23,53",""); /* Invalid character --> Error */
1184   SetLastError(0xdeadbeef);
1185   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1186   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1187       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1188
1189   STRINGSA("--",""); /* Double '-' --> Error */
1190   SetLastError(0xdeadbeef);
1191   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1192   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1193       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1194
1195   STRINGSA("0-",""); /* Trailing '-' --> Error */
1196   SetLastError(0xdeadbeef);
1197   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1198   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1199       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1200
1201   STRINGSA("0..",""); /* Double '.' --> Error */
1202   SetLastError(0xdeadbeef);
1203   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1204   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1205       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1206
1207   STRINGSA(" 0.1",""); /* Leading space --> Error */
1208   SetLastError(0xdeadbeef);
1209   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1210   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1211       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1212
1213   STRINGSA("1234","$"); /* Length too small --> Write up to length chars */
1214   SetLastError(0xdeadbeef);
1215   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, 2);
1216   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1217       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
1218
1219   STRINGSA("2353",""); /* Format and flags given --> Error */
1220   SetLastError(0xdeadbeef);
1221   ret = GetCurrencyFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
1222   ok( !ret, "Expected ret == 0, got %d\n", ret);
1223   ok( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER,
1224       "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1225
1226   STRINGSA("2353",""); /* Invalid format --> Error */
1227   SetLastError(0xdeadbeef);
1228   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1229   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1230       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1231
1232   STRINGSA("2353","$2,353.00"); /* Valid number */
1233   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1234   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1235   EXPECT_LENA; EXPECT_EQA;
1236
1237   STRINGSA("-2353","($2,353.00)"); /* Valid negative number */
1238   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1239   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1240   EXPECT_LENA; EXPECT_EQA;
1241
1242   STRINGSA("2353.1","$2,353.10"); /* Valid real number */
1243   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1244   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1245   EXPECT_LENA; EXPECT_EQA;
1246
1247   STRINGSA("2353.111","$2,353.11"); /* Too many DP --> Truncated */
1248   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1249   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1250   EXPECT_LENA; EXPECT_EQA;
1251
1252   STRINGSA("2353.119","$2,353.12");  /* Too many DP --> Rounded */
1253   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1254   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1255   EXPECT_LENA; EXPECT_EQA;
1256
1257   format.NumDigits = 0; /* No decimal separator */
1258   format.LeadingZero = 0;
1259   format.Grouping = 0;  /* No grouping char */
1260   format.NegativeOrder = 0;
1261   format.PositiveOrder = CY_POS_LEFT;
1262   format.lpDecimalSep = szDot;
1263   format.lpThousandSep = szComma;
1264   format.lpCurrencySymbol = szDollar;
1265
1266   STRINGSA("2353","$2353"); /* No decimal or grouping chars expected */
1267   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1268   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1269   EXPECT_LENA; EXPECT_EQA;
1270
1271   format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
1272   STRINGSA("2353","$2353.0");
1273   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1274   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1275   EXPECT_LENA; EXPECT_EQA;
1276
1277   format.Grouping = 2; /* Group by 100's */
1278   STRINGSA("2353","$23,53.0");
1279   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1280   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1281   EXPECT_LENA; EXPECT_EQA;
1282
1283   STRINGSA("235","$235.0"); /* Grouping of a positive number */
1284   format.Grouping = 3;
1285   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1286   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1287   EXPECT_LENA; EXPECT_EQA;
1288
1289   STRINGSA("-235","$-235.0"); /* Grouping of a negative number */
1290   format.NegativeOrder = 2;
1291   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1292   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1293   EXPECT_LENA; EXPECT_EQA;
1294
1295   format.LeadingZero = 1; /* Always provide leading zero */
1296   STRINGSA(".5","$0.5");
1297   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1298   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1299   EXPECT_LENA; EXPECT_EQA;
1300
1301   format.PositiveOrder = CY_POS_RIGHT;
1302   STRINGSA("1","1.0$");
1303   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1304   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1305   EXPECT_LENA; EXPECT_EQA;
1306
1307   format.PositiveOrder = CY_POS_LEFT_SPACE;
1308   STRINGSA("1","$ 1.0");
1309   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1310   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1311   EXPECT_LENA; EXPECT_EQA;
1312
1313   format.PositiveOrder = CY_POS_RIGHT_SPACE;
1314   STRINGSA("1","1.0 $");
1315   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1316   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1317   EXPECT_LENA; EXPECT_EQA;
1318
1319   format.NegativeOrder = 0;
1320   STRINGSA("-1","($1.0)");
1321   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1322   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1323   EXPECT_LENA; EXPECT_EQA;
1324
1325   format.NegativeOrder = 1;
1326   STRINGSA("-1","-$1.0");
1327   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1328   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1329   EXPECT_LENA; EXPECT_EQA;
1330
1331   format.NegativeOrder = 2;
1332   STRINGSA("-1","$-1.0");
1333   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1334   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1335   EXPECT_LENA; EXPECT_EQA;
1336
1337   format.NegativeOrder = 3;
1338   STRINGSA("-1","$1.0-");
1339   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1340   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1341   EXPECT_LENA; EXPECT_EQA;
1342
1343   format.NegativeOrder = 4;
1344   STRINGSA("-1","(1.0$)");
1345   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1346   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1347   EXPECT_LENA; EXPECT_EQA;
1348
1349   format.NegativeOrder = 5;
1350   STRINGSA("-1","-1.0$");
1351   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1352   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1353   EXPECT_LENA; EXPECT_EQA;
1354
1355   format.NegativeOrder = 6;
1356   STRINGSA("-1","1.0-$");
1357   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1358   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1359   EXPECT_LENA; EXPECT_EQA;
1360
1361   format.NegativeOrder = 7;
1362   STRINGSA("-1","1.0$-");
1363   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1364   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1365   EXPECT_LENA; EXPECT_EQA;
1366
1367   format.NegativeOrder = 8;
1368   STRINGSA("-1","-1.0 $");
1369   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1370   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1371   EXPECT_LENA; EXPECT_EQA;
1372
1373   format.NegativeOrder = 9;
1374   STRINGSA("-1","-$ 1.0");
1375   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1376   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1377   EXPECT_LENA; EXPECT_EQA;
1378
1379   format.NegativeOrder = 10;
1380   STRINGSA("-1","1.0 $-");
1381   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1382   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1383   EXPECT_LENA; EXPECT_EQA;
1384
1385   format.NegativeOrder = 11;
1386   STRINGSA("-1","$ 1.0-");
1387   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1388   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1389   EXPECT_LENA; EXPECT_EQA;
1390
1391   format.NegativeOrder = 12;
1392   STRINGSA("-1","$ -1.0");
1393   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1394   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1395   EXPECT_LENA; EXPECT_EQA;
1396
1397   format.NegativeOrder = 13;
1398   STRINGSA("-1","1.0- $");
1399   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1400   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1401   EXPECT_LENA; EXPECT_EQA;
1402
1403   format.NegativeOrder = 14;
1404   STRINGSA("-1","($ 1.0)");
1405   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1406   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1407   EXPECT_LENA; EXPECT_EQA;
1408
1409   format.NegativeOrder = 15;
1410   STRINGSA("-1","(1.0 $)");
1411   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1412   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1413   EXPECT_LENA; EXPECT_EQA;
1414 }
1415
1416 #define NEG_PARENS      0 /* "(1.1)" */
1417 #define NEG_LEFT        1 /* "-1.1"  */
1418 #define NEG_LEFT_SPACE  2 /* "- 1.1" */
1419 #define NEG_RIGHT       3 /* "1.1-"  */
1420 #define NEG_RIGHT_SPACE 4 /* "1.1 -" */
1421
1422 static void test_GetNumberFormatA(void)
1423 {
1424   static char szDot[] = { '.', '\0' };
1425   static char szComma[] = { ',', '\0' };
1426   int ret;
1427   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
1428   char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
1429   NUMBERFMTA format;
1430
1431   memset(&format, 0, sizeof(format));
1432
1433   STRINGSA("23",""); /* NULL output, length > 0 --> Error */
1434   SetLastError(0xdeadbeef);
1435   ret = GetNumberFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
1436   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1437       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1438
1439   STRINGSA("23,53",""); /* Invalid character --> Error */
1440   SetLastError(0xdeadbeef);
1441   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1442   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1443       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1444
1445   STRINGSA("--",""); /* Double '-' --> Error */
1446   SetLastError(0xdeadbeef);
1447   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1448   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1449       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1450
1451   STRINGSA("0-",""); /* Trailing '-' --> Error */
1452   SetLastError(0xdeadbeef);
1453   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1454   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1455       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1456
1457   STRINGSA("0..",""); /* Double '.' --> Error */
1458   SetLastError(0xdeadbeef);
1459   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1460   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1461       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1462
1463   STRINGSA(" 0.1",""); /* Leading space --> Error */
1464   SetLastError(0xdeadbeef);
1465   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1466   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1467       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1468
1469   STRINGSA("1234","1"); /* Length too small --> Write up to length chars */
1470   SetLastError(0xdeadbeef);
1471   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, 2);
1472   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1473       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
1474
1475   STRINGSA("2353",""); /* Format and flags given --> Error */
1476   SetLastError(0xdeadbeef);
1477   ret = GetNumberFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
1478   ok( !ret, "Expected ret == 0, got %d\n", ret);
1479   ok( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER,
1480       "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1481
1482   STRINGSA("2353",""); /* Invalid format --> Error */
1483   SetLastError(0xdeadbeef);
1484   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1485   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1486       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1487
1488   STRINGSA("2353","2,353.00"); /* Valid number */
1489   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1490   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1491   EXPECT_LENA; EXPECT_EQA;
1492
1493   STRINGSA("-2353","-2,353.00"); /* Valid negative number */
1494   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1495   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1496   EXPECT_LENA; EXPECT_EQA;
1497
1498   STRINGSA("-353","-353.00"); /* test for off by one error in grouping */
1499   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1500   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1501   EXPECT_LENA; EXPECT_EQA;
1502
1503   STRINGSA("2353.1","2,353.10"); /* Valid real number */
1504   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1505   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1506   EXPECT_LENA; EXPECT_EQA;
1507
1508   STRINGSA("2353.111","2,353.11"); /* Too many DP --> Truncated */
1509   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1510   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1511   EXPECT_LENA; EXPECT_EQA;
1512
1513   STRINGSA("2353.119","2,353.12");  /* Too many DP --> Rounded */
1514   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1515   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1516   EXPECT_LENA; EXPECT_EQA;
1517
1518   format.NumDigits = 0; /* No decimal separator */
1519   format.LeadingZero = 0;
1520   format.Grouping = 0;  /* No grouping char */
1521   format.NegativeOrder = 0;
1522   format.lpDecimalSep = szDot;
1523   format.lpThousandSep = szComma;
1524
1525   STRINGSA("2353","2353"); /* No decimal or grouping chars expected */
1526   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1527   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1528   EXPECT_LENA; EXPECT_EQA;
1529
1530   format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
1531   STRINGSA("2353","2353.0");
1532   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1533   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1534   EXPECT_LENA; EXPECT_EQA;
1535
1536   format.Grouping = 2; /* Group by 100's */
1537   STRINGSA("2353","23,53.0");
1538   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1539   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1540   EXPECT_LENA; EXPECT_EQA;
1541
1542   STRINGSA("235","235.0"); /* Grouping of a positive number */
1543   format.Grouping = 3;
1544   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1545   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1546   EXPECT_LENA; EXPECT_EQA;
1547
1548   STRINGSA("-235","-235.0"); /* Grouping of a negative number */
1549   format.NegativeOrder = NEG_LEFT;
1550   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1551   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1552   EXPECT_LENA; EXPECT_EQA;
1553
1554   format.LeadingZero = 1; /* Always provide leading zero */
1555   STRINGSA(".5","0.5");
1556   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1557   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1558   EXPECT_LENA; EXPECT_EQA;
1559
1560   format.NegativeOrder = NEG_PARENS;
1561   STRINGSA("-1","(1.0)");
1562   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1563   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1564   EXPECT_LENA; EXPECT_EQA;
1565
1566   format.NegativeOrder = NEG_LEFT;
1567   STRINGSA("-1","-1.0");
1568   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1569   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1570   EXPECT_LENA; EXPECT_EQA;
1571
1572   format.NegativeOrder = NEG_LEFT_SPACE;
1573   STRINGSA("-1","- 1.0");
1574   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1575   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1576   EXPECT_LENA; EXPECT_EQA;
1577
1578   format.NegativeOrder = NEG_RIGHT;
1579   STRINGSA("-1","1.0-");
1580   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1581   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1582   EXPECT_LENA; EXPECT_EQA;
1583
1584   format.NegativeOrder = NEG_RIGHT_SPACE;
1585   STRINGSA("-1","1.0 -");
1586   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1587   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1588   EXPECT_LENA; EXPECT_EQA;
1589
1590   lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
1591
1592   if (IsValidLocale(lcid, 0))
1593   {
1594     STRINGSA("-12345","-12 345,00"); /* Try French formatting */
1595     Expected[3] = 160; /* Non breaking space */
1596     ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1597     ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1598     EXPECT_LENA; EXPECT_EQA;
1599   }
1600 }
1601
1602 static void test_GetNumberFormatEx(void)
1603 {
1604   int ret;
1605   NUMBERFMTW format;
1606   static WCHAR dotW[] = {'.',0};
1607   static WCHAR commaW[] = {',',0};
1608   static const WCHAR enW[] = {'e','n','-','U','S',0};
1609   static const WCHAR frW[] = {'f','r','-','F','R',0};
1610   static const WCHAR bogusW[] = {'b','o','g','u','s',0};
1611   WCHAR buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
1612
1613   if (!pGetNumberFormatEx)
1614   {
1615     win_skip("GetNumberFormatEx is not available.\n");
1616     return;
1617   }
1618
1619   STRINGSW("23",""); /* NULL output, length > 0 --> Error */
1620   ret = pGetNumberFormatEx(enW, 0, input, NULL, NULL, COUNTOF(buffer));
1621   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1622       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1623
1624   STRINGSW("23,53",""); /* Invalid character --> Error */
1625   ret = pGetNumberFormatEx(enW, 0, input, NULL, buffer, COUNTOF(buffer));
1626   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1627       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1628
1629   STRINGSW("--",""); /* Double '-' --> Error */
1630   ret = pGetNumberFormatEx(enW, 0, input, NULL, buffer, COUNTOF(buffer));
1631   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1632       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1633
1634   STRINGSW("0-",""); /* Trailing '-' --> Error */
1635   ret = pGetNumberFormatEx(enW, 0, input, NULL, buffer, COUNTOF(buffer));
1636   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1637       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1638
1639   STRINGSW("0..",""); /* Double '.' --> Error */
1640   ret = pGetNumberFormatEx(enW, 0, input, NULL, buffer, COUNTOF(buffer));
1641   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1642       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1643
1644   STRINGSW(" 0.1",""); /* Leading space --> Error */
1645   ret = pGetNumberFormatEx(enW, 0, input, NULL, buffer, COUNTOF(buffer));
1646   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1647       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1648
1649   STRINGSW("1234","1"); /* Length too small --> Write up to length chars */
1650   ret = pGetNumberFormatEx(enW, NUO, input, NULL, buffer, 2);
1651   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1652       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
1653
1654   STRINGSW("23",""); /* Bogus locale --> Error */
1655   ret = pGetNumberFormatEx(bogusW, NUO, input, NULL, buffer, COUNTOF(buffer));
1656   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1657       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1658
1659   memset(&format, 0, sizeof(format));
1660
1661   STRINGSW("2353",""); /* Format and flags given --> Error */
1662   ret = pGetNumberFormatEx(enW, NUO, input, &format, buffer, COUNTOF(buffer));
1663   ok( !ret, "Expected ret == 0, got %d\n", ret);
1664   ok( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER,
1665       "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1666
1667   STRINGSW("2353",""); /* Invalid format --> Error */
1668   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1669   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1670       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1671
1672   STRINGSW("2353","2,353.00"); /* Valid number */
1673   ret = pGetNumberFormatEx(enW, NUO, input, NULL, buffer, COUNTOF(buffer));
1674   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1675   EXPECT_LENW; EXPECT_EQW;
1676
1677   STRINGSW("-2353","-2,353.00"); /* Valid negative number */
1678   ret = pGetNumberFormatEx(enW, NUO, input, NULL, buffer, COUNTOF(buffer));
1679   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1680   EXPECT_LENW; EXPECT_EQW;
1681
1682   STRINGSW("-353","-353.00"); /* test for off by one error in grouping */
1683   ret = pGetNumberFormatEx(enW, NUO, input, NULL, buffer, COUNTOF(buffer));
1684   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1685   EXPECT_LENW; EXPECT_EQW;
1686
1687   STRINGSW("2353.1","2,353.10"); /* Valid real number */
1688   ret = pGetNumberFormatEx(enW, NUO, input, NULL, buffer, COUNTOF(buffer));
1689   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1690   EXPECT_LENW; EXPECT_EQW;
1691
1692   STRINGSW("2353.111","2,353.11"); /* Too many DP --> Truncated */
1693   ret = pGetNumberFormatEx(enW, NUO, input, NULL, buffer, COUNTOF(buffer));
1694   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1695   EXPECT_LENW; EXPECT_EQW;
1696
1697   STRINGSW("2353.119","2,353.12");  /* Too many DP --> Rounded */
1698   ret = pGetNumberFormatEx(enW, NUO, input, NULL, buffer, COUNTOF(buffer));
1699   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1700   EXPECT_LENW; EXPECT_EQW;
1701
1702   format.NumDigits = 0; /* No decimal separator */
1703   format.LeadingZero = 0;
1704   format.Grouping = 0;  /* No grouping char */
1705   format.NegativeOrder = 0;
1706   format.lpDecimalSep = dotW;
1707   format.lpThousandSep = commaW;
1708
1709   STRINGSW("2353","2353"); /* No decimal or grouping chars expected */
1710   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1711   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1712   EXPECT_LENW; EXPECT_EQW;
1713
1714   format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
1715   STRINGSW("2353","2353.0");
1716   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1717   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1718   EXPECT_LENW; EXPECT_EQW;
1719
1720   format.Grouping = 2; /* Group by 100's */
1721   STRINGSW("2353","23,53.0");
1722   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1723   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1724   EXPECT_LENW; EXPECT_EQW;
1725
1726   STRINGSW("235","235.0"); /* Grouping of a positive number */
1727   format.Grouping = 3;
1728   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1729   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1730   EXPECT_LENW; EXPECT_EQW;
1731
1732   STRINGSW("-235","-235.0"); /* Grouping of a negative number */
1733   format.NegativeOrder = NEG_LEFT;
1734   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1735   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1736   EXPECT_LENW; EXPECT_EQW;
1737
1738   format.LeadingZero = 1; /* Always provide leading zero */
1739   STRINGSW(".5","0.5");
1740   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1741   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1742   EXPECT_LENW; EXPECT_EQW;
1743
1744   format.NegativeOrder = NEG_PARENS;
1745   STRINGSW("-1","(1.0)");
1746   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1747   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1748   EXPECT_LENW; EXPECT_EQW;
1749
1750   format.NegativeOrder = NEG_LEFT;
1751   STRINGSW("-1","-1.0");
1752   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1753   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1754   EXPECT_LENW; EXPECT_EQW;
1755
1756   format.NegativeOrder = NEG_LEFT_SPACE;
1757   STRINGSW("-1","- 1.0");
1758   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1759   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1760   EXPECT_LENW; EXPECT_EQW;
1761
1762   format.NegativeOrder = NEG_RIGHT;
1763   STRINGSW("-1","1.0-");
1764   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1765   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1766   EXPECT_LENW; EXPECT_EQW;
1767
1768   format.NegativeOrder = NEG_RIGHT_SPACE;
1769   STRINGSW("-1","1.0 -");
1770   ret = pGetNumberFormatEx(enW, 0, input, &format, buffer, COUNTOF(buffer));
1771   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1772   EXPECT_LENW; EXPECT_EQW;
1773
1774   if (pIsValidLocaleName(frW))
1775   {
1776     STRINGSW("-12345","-12 345,00"); /* Try French formatting */
1777     Expected[3] = 160; /* Non breaking space */
1778     ret = pGetNumberFormatEx(frW, NUO, input, NULL, buffer, COUNTOF(buffer));
1779     ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1780     EXPECT_LENW; EXPECT_EQW;
1781   }
1782 }
1783
1784 struct comparestringa_entry {
1785   LCID lcid;
1786   DWORD flags;
1787   const char *first;
1788   int first_len;
1789   const char *second;
1790   int second_len;
1791   int ret;
1792 };
1793
1794 static const struct comparestringa_entry comparestringa_data[] = {
1795   { LOCALE_SYSTEM_DEFAULT, 0, "EndDialog", -1, "_Property", -1, CSTR_GREATER_THAN },
1796   { LOCALE_SYSTEM_DEFAULT, 0, "osp_vba.sreg0070", -1, "_IEWWBrowserComp", -1, CSTR_GREATER_THAN },
1797   { LOCALE_SYSTEM_DEFAULT, 0, "r", -1, "\\", -1, CSTR_GREATER_THAN },
1798   { LOCALE_SYSTEM_DEFAULT, 0, "osp_vba.sreg0031", -1, "OriginalDatabase", -1, CSTR_GREATER_THAN },
1799   { LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aaa", -1, CSTR_GREATER_THAN },
1800   { LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aab", -1, CSTR_LESS_THAN },
1801   { LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "Aab", -1, CSTR_LESS_THAN },
1802   { LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "Aab", -1, CSTR_LESS_THAN },
1803   { LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "A.ab", -1, CSTR_LESS_THAN },
1804   { LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "AB", -1, CSTR_LESS_THAN },
1805   { LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "Aab", -1, CSTR_LESS_THAN },
1806   { LOCALE_SYSTEM_DEFAULT, 0, "aB", -1, "Aab", -1, CSTR_GREATER_THAN },
1807   { LOCALE_SYSTEM_DEFAULT, 0, "Ba", -1, "bab", -1, CSTR_LESS_THAN },
1808   { LOCALE_SYSTEM_DEFAULT, 0, "{100}{83}{71}{71}{71}", -1, "Global_DataAccess_JRO", -1, CSTR_LESS_THAN },
1809   { LOCALE_SYSTEM_DEFAULT, 0, "a", -1, "{", -1, CSTR_GREATER_THAN },
1810   { LOCALE_SYSTEM_DEFAULT, 0, "A", -1, "{", -1, CSTR_GREATER_THAN },
1811   { LOCALE_SYSTEM_DEFAULT, 0, "3.5", 0, "4.0", -1, CSTR_LESS_THAN },
1812   { LOCALE_SYSTEM_DEFAULT, 0, "3.5", -1, "4.0", -1, CSTR_LESS_THAN },
1813   { LOCALE_SYSTEM_DEFAULT, 0, "3.520.4403.2", -1, "4.0.2927.10", -1, CSTR_LESS_THAN },
1814   /* hyphen and apostrophe are treated differently depending on whether SORT_STRINGSORT specified or not */
1815   { LOCALE_SYSTEM_DEFAULT, 0, "-o", -1, "/m", -1, CSTR_GREATER_THAN },
1816   { LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "-o", -1, CSTR_LESS_THAN },
1817   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-o", -1, "/m", -1, CSTR_LESS_THAN },
1818   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "-o", -1, CSTR_GREATER_THAN },
1819   { LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "/m", -1, CSTR_GREATER_THAN },
1820   { LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "'o", -1, CSTR_LESS_THAN },
1821   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "/m", -1, CSTR_LESS_THAN },
1822   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "'o", -1, CSTR_GREATER_THAN },
1823   { LOCALE_SYSTEM_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ", 9, CSTR_EQUAL },
1824   { LOCALE_SYSTEM_DEFAULT, 0, "aLuZkUtZ", 7, "aLuZkUtZ\0A", 10, CSTR_LESS_THAN },
1825   { LOCALE_SYSTEM_DEFAULT, 0, "a-", 3, "a\0", 3, CSTR_GREATER_THAN },
1826   { LOCALE_SYSTEM_DEFAULT, 0, "a'", 3, "a\0", 3, CSTR_GREATER_THAN },
1827   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "a-", 3, "a\0", 3, CSTR_GREATER_THAN },
1828   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "a'", 3, "a\0", 3, CSTR_GREATER_THAN },
1829   { LOCALE_SYSTEM_DEFAULT, NORM_IGNORESYMBOLS, "a.", 3, "a\0", 3, CSTR_EQUAL },
1830   { LOCALE_SYSTEM_DEFAULT, NORM_IGNORESYMBOLS, "a ", 3, "a\0", 3, CSTR_EQUAL },
1831   { LOCALE_SYSTEM_DEFAULT, 0, "a", 1, "a\0\0", 4, CSTR_EQUAL },
1832   { LOCALE_SYSTEM_DEFAULT, 0, "a", 2, "a\0\0", 4, CSTR_EQUAL },
1833   { LOCALE_SYSTEM_DEFAULT, 0, "a\0\0", 4, "a", 1, CSTR_EQUAL },
1834   { LOCALE_SYSTEM_DEFAULT, 0, "a\0\0", 4, "a", 2, CSTR_EQUAL },
1835   { LOCALE_SYSTEM_DEFAULT, 0, "a", 1, "a\0x", 4, CSTR_LESS_THAN },
1836   { LOCALE_SYSTEM_DEFAULT, 0, "a", 2, "a\0x", 4, CSTR_LESS_THAN },
1837   { LOCALE_SYSTEM_DEFAULT, 0, "a\0x", 4, "a", 1, CSTR_GREATER_THAN },
1838   { LOCALE_SYSTEM_DEFAULT, 0, "a\0x", 4, "a", 2, CSTR_GREATER_THAN },
1839 };
1840
1841 static void test_CompareStringA(void)
1842 {
1843   int ret, i;
1844   char a[256];
1845   LCID lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
1846
1847   for (i = 0; i < sizeof(comparestringa_data)/sizeof(struct comparestringa_entry); i++)
1848   {
1849       const struct comparestringa_entry *entry = &comparestringa_data[i];
1850
1851       ret = CompareStringA(entry->lcid, entry->flags, entry->first, entry->first_len,
1852           entry->second, entry->second_len);
1853       ok(ret == entry->ret, "%d: got %d, expected %d\n", i, ret, entry->ret);
1854   }
1855
1856   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "Salute", -1);
1857   ok (ret == CSTR_LESS_THAN, "(Salut/Salute) Expected CSTR_LESS_THAN, got %d\n", ret);
1858
1859   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "SaLuT", -1);
1860   ok (ret == CSTR_EQUAL, "(Salut/SaLuT) Expected CSTR_EQUAL, got %d\n", ret);
1861
1862   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "hola", -1);
1863   ok (ret == CSTR_GREATER_THAN, "(Salut/hola) Expected CSTR_GREATER_THAN, got %d\n", ret);
1864
1865   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
1866   ok (ret == CSTR_LESS_THAN, "(haha/hoho) Expected CSTR_LESS_THAN, got %d\n", ret);
1867
1868   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
1869
1870   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
1871   ok (ret == CSTR_LESS_THAN, "(haha/hoho) Expected CSTR_LESS_THAN, got %d\n", ret);
1872
1873   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", 0);
1874   ok (ret == CSTR_GREATER_THAN, "(haha/hoho) Expected CSTR_GREATER_THAN, got %d\n", ret);
1875
1876     ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", 5, "saLuT", -1);
1877     ok (ret == CSTR_EQUAL, "(Salut/saLuT) Expected CSTR_EQUAL, got %d\n", ret);
1878
1879     /* test for CompareStringA flags */
1880     SetLastError(0xdeadbeef);
1881     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0x8, "NULL", -1, "NULL", -1);
1882     ok(GetLastError() == ERROR_INVALID_FLAGS,
1883         "unexpected error code %d\n", GetLastError());
1884     ok(!ret, "CompareStringA must fail with invalid flag\n");
1885
1886     SetLastError(0xdeadbeef);
1887     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, LOCALE_USE_CP_ACP, "NULL", -1, "NULL", -1);
1888     ok(GetLastError() == 0xdeadbeef, "unexpected error code %d\n", GetLastError());
1889     ok(ret == CSTR_EQUAL, "CompareStringA error: %d != CSTR_EQUAL\n", ret);
1890     /* end of test for CompareStringA flags */
1891
1892     ret = lstrcmpA("", "");
1893     ok (ret == 0, "lstrcmpA(\"\", \"\") should return 0, got %d\n", ret);
1894
1895     ret = lstrcmpA(NULL, NULL);
1896     ok (ret == 0 || broken(ret == -2) /* win9x */, "lstrcmpA(NULL, NULL) should return 0, got %d\n", ret);
1897
1898     ret = lstrcmpA("", NULL);
1899     ok (ret == 1 || broken(ret == -2) /* win9x */, "lstrcmpA(\"\", NULL) should return 1, got %d\n", ret);
1900
1901     ret = lstrcmpA(NULL, "");
1902     ok (ret == -1 || broken(ret == -2) /* win9x */, "lstrcmpA(NULL, \"\") should return -1, got %d\n", ret);
1903
1904
1905     if (0) { /* this requires collation table patch to make it MS compatible */
1906     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "-o", -1 );
1907     ok(ret == CSTR_LESS_THAN, "'o vs -o expected CSTR_LESS_THAN, got %d\n", ret);
1908
1909     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "-o", -1 );
1910     ok(ret == CSTR_LESS_THAN, "'o vs -o expected CSTR_LESS_THAN, got %d\n", ret);
1911
1912     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'", -1, "-", -1 );
1913     ok(ret == CSTR_LESS_THAN, "' vs - expected CSTR_LESS_THAN, got %d\n", ret);
1914
1915     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'", -1, "-", -1 );
1916     ok(ret == CSTR_LESS_THAN, "' vs - expected CSTR_LESS_THAN, got %d\n", ret);
1917
1918     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "/m", -1 );
1919     ok(ret == CSTR_GREATER_THAN, "`o vs /m CSTR_GREATER_THAN got %d\n", ret);
1920
1921     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "`o", -1 );
1922     ok(ret == CSTR_LESS_THAN, "/m vs `o expected CSTR_LESS_THAN, got %d\n", ret);
1923
1924     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "/m", -1 );
1925     ok(ret == CSTR_GREATER_THAN, "`o vs /m CSTR_GREATER_THAN got %d\n", ret);
1926
1927     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "`o", -1 );
1928     ok(ret == CSTR_LESS_THAN, "/m vs `o expected CSTR_LESS_THAN, got %d\n", ret);
1929
1930     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "-m", -1 );
1931     ok(ret == CSTR_LESS_THAN, "`o vs -m expected CSTR_LESS_THAN, got %d\n", ret);
1932
1933     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "-m", -1, "`o", -1 );
1934     ok(ret == CSTR_GREATER_THAN, "-m vs `o CSTR_GREATER_THAN got %d\n", ret);
1935
1936     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "-m", -1 );
1937     ok(ret == CSTR_GREATER_THAN, "`o vs -m CSTR_GREATER_THAN got %d\n", ret);
1938
1939     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-m", -1, "`o", -1 );
1940     ok(ret == CSTR_LESS_THAN, "-m vs `o expected CSTR_LESS_THAN, got %d\n", ret);
1941     }
1942
1943
1944     /* WinXP handles embedded NULLs differently than earlier versions */
1945     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ\0A", 10);
1946     ok(ret == CSTR_LESS_THAN || ret == CSTR_EQUAL, "aLuZkUtZ vs aLuZkUtZ\\0A expected CSTR_LESS_THAN or CSTR_EQUAL, got %d\n", ret);
1947
1948     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLu\0ZkUtZ", 8, "aLu\0ZkUtZ\0A", 10);
1949     ok(ret == CSTR_LESS_THAN || ret == CSTR_EQUAL, "aLu\\0ZkUtZ vs aLu\\0ZkUtZ\\0A expected CSTR_LESS_THAN or CSTR_EQUAL, got %d\n", ret);
1950
1951     ret = CompareStringA(lcid, 0, "a\0b", -1, "a", -1);
1952     ok(ret == CSTR_EQUAL, "a vs a expected CSTR_EQUAL, got %d\n", ret);
1953
1954     ret = CompareStringA(lcid, 0, "a\0b", 4, "a", 2);
1955     ok(ret == CSTR_EQUAL || /* win2k */
1956        ret == CSTR_GREATER_THAN,
1957        "a\\0b vs a expected CSTR_EQUAL or CSTR_GREATER_THAN, got %d\n", ret);
1958
1959     ret = CompareStringA(lcid, 0, "\2", 2, "\1", 2);
1960     todo_wine ok(ret != CSTR_EQUAL, "\\2 vs \\1 expected unequal\n");
1961
1962     ret = CompareStringA(lcid, NORM_IGNORECASE | LOCALE_USE_CP_ACP, "#", -1, ".", -1);
1963     ok(ret == CSTR_LESS_THAN, "\"#\" vs \".\" expected CSTR_LESS_THAN, got %d\n", ret);
1964
1965     ret = CompareStringA(lcid, NORM_IGNORECASE, "_", -1, ".", -1);
1966     ok(ret == CSTR_GREATER_THAN, "\"_\" vs \".\" expected CSTR_GREATER_THAN, got %d\n", ret);
1967
1968     ret = lstrcmpiA("#", ".");
1969     ok(ret == -1, "\"#\" vs \".\" expected -1, got %d\n", ret);
1970
1971     lcid = MAKELCID(MAKELANGID(LANG_POLISH, SUBLANG_DEFAULT), SORT_DEFAULT);
1972
1973     /* \xB9 character lies between a and b */
1974     ret = CompareStringA(lcid, 0, "a", 1, "\xB9", 1);
1975     todo_wine ok(ret == CSTR_LESS_THAN, "\'\\xB9\' character should be greater than \'a\'\n");
1976     ret = CompareStringA(lcid, 0, "\xB9", 1, "b", 1);
1977     ok(ret == CSTR_LESS_THAN, "\'\\xB9\' character should be smaller than \'b\'\n");
1978
1979     memset(a, 'a', sizeof(a));
1980     SetLastError(0xdeadbeef);
1981     ret = CompareStringA(lcid, 0, a, sizeof(a), a, sizeof(a));
1982     ok (GetLastError() == 0xdeadbeef && ret == CSTR_EQUAL,
1983         "ret %d, error %d, expected value %d\n", ret, GetLastError(), CSTR_EQUAL);
1984 }
1985
1986 static void test_CompareStringW(void)
1987 {
1988     WCHAR *str1, *str2;
1989     SYSTEM_INFO si;
1990     DWORD old_prot;
1991     BOOL success;
1992     char *buf;
1993     int ret;
1994
1995     GetSystemInfo(&si);
1996     buf = VirtualAlloc(NULL, si.dwPageSize * 4, MEM_COMMIT, PAGE_READWRITE);
1997     ok(buf != NULL, "VirtualAlloc failed with %u\n", GetLastError());
1998     success = VirtualProtect(buf + si.dwPageSize, si.dwPageSize, PAGE_NOACCESS, &old_prot);
1999     ok(success, "VirtualProtect failed with %u\n", GetLastError());
2000     success = VirtualProtect(buf + 3 * si.dwPageSize, si.dwPageSize, PAGE_NOACCESS, &old_prot);
2001     ok(success, "VirtualProtect failed with %u\n", GetLastError());
2002
2003     str1 = (WCHAR *)(buf + si.dwPageSize - sizeof(WCHAR));
2004     str2 = (WCHAR *)(buf + 3 * si.dwPageSize - sizeof(WCHAR));
2005     *str1 = 'A';
2006     *str2 = 'B';
2007
2008     /* CompareStringW should abort on the first non-matching character */
2009     ret = CompareStringW(CP_ACP, 0, str1, 100, str2, 100);
2010     ok(ret == CSTR_LESS_THAN, "expected CSTR_LESS_THAN, got %d\n", ret);
2011
2012     success = VirtualFree(buf, 0, MEM_RELEASE);
2013     ok(success, "VirtualFree failed with %u\n", GetLastError());
2014 }
2015
2016 struct comparestringex_test {
2017     const char *locale;
2018     DWORD flags;
2019     const WCHAR first[2];
2020     const WCHAR second[2];
2021     INT ret;
2022     INT broken;
2023     BOOL todo;
2024 };
2025
2026 static const struct comparestringex_test comparestringex_tests[] = {
2027     /* default behavior */
2028     { /* 0 */
2029       "tr-TR", 0,
2030       {'i',0},   {'I',0},   CSTR_LESS_THAN,    -1,                FALSE
2031     },
2032     { /* 1 */
2033       "tr-TR", 0,
2034       {'i',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                FALSE
2035     },
2036     { /* 2 */
2037       "tr-TR", 0,
2038       {'i',0},   {0x131,0}, CSTR_LESS_THAN,    -1,                FALSE
2039     },
2040     { /* 3 */
2041       "tr-TR", 0,
2042       {'I',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                TRUE
2043     },
2044     { /* 4 */
2045       "tr-TR", 0,
2046       {'I',0},   {0x131,0}, CSTR_LESS_THAN,    -1,                FALSE
2047     },
2048     { /* 5 */
2049       "tr-TR", 0,
2050       {0x130,0}, {0x131,0}, CSTR_GREATER_THAN, -1,                TRUE
2051     },
2052     /* with NORM_IGNORECASE */
2053     { /* 6 */
2054       "tr-TR", NORM_IGNORECASE,
2055       {'i',0},   {'I',0},   CSTR_EQUAL,        -1,                FALSE
2056     },
2057     { /* 7 */
2058       "tr-TR", NORM_IGNORECASE,
2059       {'i',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                TRUE
2060     },
2061     { /* 8 */
2062       "tr-TR", NORM_IGNORECASE,
2063       {'i',0},   {0x131,0}, CSTR_LESS_THAN,    -1,                FALSE
2064     },
2065     { /* 9 */
2066       "tr-TR", NORM_IGNORECASE,
2067       {'I',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                TRUE
2068     },
2069     { /* 10 */
2070       "tr-TR", NORM_IGNORECASE,
2071       {'I',0},   {0x131,0}, CSTR_LESS_THAN,    -1,                FALSE
2072     },
2073     { /* 11 */
2074       "tr-TR", NORM_IGNORECASE,
2075       {0x130,0}, {0x131,0}, CSTR_GREATER_THAN, -1,                TRUE
2076     },
2077     /* with NORM_LINGUISTIC_CASING */
2078     { /* 12 */
2079       "tr-TR", NORM_LINGUISTIC_CASING,
2080       {'i',0},   {'I',0},   CSTR_GREATER_THAN, CSTR_LESS_THAN,    TRUE
2081     },
2082     { /* 13 */
2083       "tr-TR", NORM_LINGUISTIC_CASING,
2084       {'i',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                FALSE
2085     },
2086     { /* 14 */
2087       "tr-TR", NORM_LINGUISTIC_CASING,
2088       {'i',0},   {0x131,0}, CSTR_GREATER_THAN, CSTR_LESS_THAN,    TRUE
2089     },
2090     { /* 15 */
2091       "tr-TR", NORM_LINGUISTIC_CASING,
2092       {'I',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                TRUE
2093     },
2094     { /* 16 */
2095       "tr-TR", NORM_LINGUISTIC_CASING,
2096       {'I',0},   {0x131,0}, CSTR_GREATER_THAN, CSTR_LESS_THAN,    TRUE
2097     },
2098     { /* 17 */
2099       "tr-TR", NORM_LINGUISTIC_CASING,
2100       {0x130,0}, {0x131,0}, CSTR_GREATER_THAN, -1,                TRUE
2101     },
2102     /* with LINGUISTIC_IGNORECASE */
2103     { /* 18 */
2104       "tr-TR", LINGUISTIC_IGNORECASE,
2105       {'i',0},   {'I',0},   CSTR_EQUAL,        -1,                TRUE
2106     },
2107     { /* 19 */
2108       "tr-TR", LINGUISTIC_IGNORECASE,
2109       {'i',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                FALSE
2110     },
2111     { /* 20 */
2112       "tr-TR", LINGUISTIC_IGNORECASE,
2113       {'i',0},   {0x131,0}, CSTR_LESS_THAN,    -1,                FALSE
2114     },
2115     { /* 21 */
2116       "tr-TR", LINGUISTIC_IGNORECASE,
2117       {'I',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                TRUE
2118     },
2119     { /* 22 */
2120       "tr-TR", LINGUISTIC_IGNORECASE,
2121       {'I',0},   {0x131,0}, CSTR_LESS_THAN,    -1,                FALSE
2122     },
2123     { /* 23 */
2124       "tr-TR", LINGUISTIC_IGNORECASE,
2125       {0x130,0}, {0x131,0}, CSTR_GREATER_THAN, -1,                TRUE
2126     },
2127     /* with NORM_LINGUISTIC_CASING | NORM_IGNORECASE */
2128     { /* 24 */
2129       "tr-TR", NORM_LINGUISTIC_CASING | NORM_IGNORECASE,
2130       {'i',0},   {'I',0},   CSTR_GREATER_THAN, CSTR_EQUAL,        TRUE
2131     },
2132     { /* 25 */
2133       "tr-TR", NORM_LINGUISTIC_CASING | NORM_IGNORECASE,
2134       {'i',0},   {0x130,0}, CSTR_EQUAL,        CSTR_LESS_THAN,    FALSE
2135     },
2136     { /* 26 */
2137       "tr-TR", NORM_LINGUISTIC_CASING | NORM_IGNORECASE,
2138       {'i',0},   {0x131,0}, CSTR_GREATER_THAN, CSTR_LESS_THAN,    TRUE
2139     },
2140     { /* 27 */
2141       "tr-TR", NORM_LINGUISTIC_CASING | NORM_IGNORECASE,
2142       {'I',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                TRUE
2143      },
2144     { /* 28 */
2145       "tr-TR", NORM_LINGUISTIC_CASING | NORM_IGNORECASE,
2146       {'I',0},   {0x131,0}, CSTR_EQUAL,        CSTR_LESS_THAN,    TRUE
2147     },
2148     { /* 29 */
2149       "tr-TR", NORM_LINGUISTIC_CASING | NORM_IGNORECASE,
2150       {0x130,0}, {0x131,0}, CSTR_GREATER_THAN, -1,                TRUE
2151     },
2152     /* with NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE */
2153     { /* 30 */
2154       "tr-TR", NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE,
2155       {'i',0},   {'I',0},   CSTR_GREATER_THAN, CSTR_EQUAL,        TRUE
2156     },
2157     { /* 31 */
2158       "tr-TR", NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE,
2159       {'i',0},   {0x130,0}, CSTR_EQUAL,        CSTR_LESS_THAN,    TRUE
2160     },
2161     { /* 32 */
2162       "tr-TR", NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE,
2163       {'i',0},   {0x131,0}, CSTR_GREATER_THAN, CSTR_LESS_THAN,    TRUE
2164     },
2165     { /* 33 */
2166       "tr-TR", NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE,
2167       {'I',0},   {0x130,0}, CSTR_LESS_THAN,    -1,                TRUE
2168     },
2169     { /* 34 */
2170       "tr-TR", NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE,
2171       {'I',0},   {0x131,0}, CSTR_EQUAL,        CSTR_LESS_THAN,    TRUE
2172     },
2173     { /* 35 */
2174       "tr-TR", NORM_LINGUISTIC_CASING | LINGUISTIC_IGNORECASE,
2175       {0x130,0}, {0x131,0}, CSTR_GREATER_THAN, CSTR_LESS_THAN,    TRUE
2176     }
2177 };
2178
2179 static void test_CompareStringEx(void)
2180 {
2181     const char *op[] = {"ERROR", "CSTR_LESS_THAN", "CSTR_EQUAL", "CSTR_GREATER_THAN"};
2182     WCHAR locale[6];
2183     INT ret, i;
2184
2185     /* CompareStringEx is only available on Vista+ */
2186     if (!pCompareStringEx)
2187     {
2188         win_skip("CompareStringEx not supported\n");
2189         return;
2190     }
2191
2192     for (i = 0; i < sizeof(comparestringex_tests)/sizeof(comparestringex_tests[0]); i++)
2193     {
2194         const struct comparestringex_test *e = &comparestringex_tests[i];
2195
2196         MultiByteToWideChar(CP_ACP, 0, e->locale, -1, locale, sizeof(locale)/sizeof(WCHAR));
2197         ret = pCompareStringEx(locale, e->flags, e->first, -1, e->second, -1, NULL, NULL, 0);
2198         todo_wine_if (e->todo)
2199             ok(ret == e->ret || broken(ret == e->broken),
2200                "%d: got %s, expected %s\n", i, op[ret], op[e->ret]);
2201     }
2202
2203 }
2204
2205 static const DWORD lcmap_invalid_flags[] = {
2206     0,
2207     LCMAP_HIRAGANA | LCMAP_KATAKANA,
2208     LCMAP_HALFWIDTH | LCMAP_FULLWIDTH,
2209     LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE,
2210     LCMAP_LOWERCASE | SORT_STRINGSORT,
2211     LCMAP_UPPERCASE | NORM_IGNORESYMBOLS,
2212     LCMAP_LOWERCASE | NORM_IGNORESYMBOLS,
2213     LCMAP_UPPERCASE | NORM_IGNORENONSPACE,
2214     LCMAP_LOWERCASE | NORM_IGNORENONSPACE,
2215     LCMAP_HIRAGANA | NORM_IGNORENONSPACE,
2216     LCMAP_HIRAGANA | NORM_IGNORESYMBOLS,
2217     LCMAP_HIRAGANA | LCMAP_SIMPLIFIED_CHINESE,
2218     LCMAP_HIRAGANA | LCMAP_TRADITIONAL_CHINESE,
2219     LCMAP_KATAKANA | NORM_IGNORENONSPACE,
2220     LCMAP_KATAKANA | NORM_IGNORESYMBOLS,
2221     LCMAP_KATAKANA | LCMAP_SIMPLIFIED_CHINESE,
2222     LCMAP_KATAKANA | LCMAP_TRADITIONAL_CHINESE,
2223     LCMAP_FULLWIDTH | NORM_IGNORENONSPACE,
2224     LCMAP_FULLWIDTH | NORM_IGNORESYMBOLS,
2225     LCMAP_FULLWIDTH | LCMAP_SIMPLIFIED_CHINESE,
2226     LCMAP_FULLWIDTH | LCMAP_TRADITIONAL_CHINESE,
2227     LCMAP_HALFWIDTH | NORM_IGNORENONSPACE,
2228     LCMAP_HALFWIDTH | NORM_IGNORESYMBOLS,
2229     LCMAP_HALFWIDTH | LCMAP_SIMPLIFIED_CHINESE,
2230     LCMAP_HALFWIDTH | LCMAP_TRADITIONAL_CHINESE,
2231 };
2232
2233 static void test_LCMapStringA(void)
2234 {
2235     int ret, ret2, i;
2236     char buf[256], buf2[256];
2237     static const char upper_case[] = "\tJUST! A, TEST; STRING 1/*+-.\r\n";
2238     static const char lower_case[] = "\tjust! a, test; string 1/*+-.\r\n";
2239     static const char symbols_stripped[] = "justateststring1";
2240
2241     SetLastError(0xdeadbeef);
2242     ret = LCMapStringA(LOCALE_USER_DEFAULT, LOCALE_USE_CP_ACP | LCMAP_LOWERCASE,
2243                        lower_case, -1, buf, sizeof(buf));
2244     ok(ret == lstrlenA(lower_case) + 1,
2245        "ret %d, error %d, expected value %d\n",
2246        ret, GetLastError(), lstrlenA(lower_case) + 1);
2247     ok(!memcmp(buf, lower_case, ret), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
2248
2249     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | LCMAP_UPPERCASE,
2250                        upper_case, -1, buf, sizeof(buf));
2251     ok(!ret, "LCMAP_LOWERCASE and LCMAP_UPPERCASE are mutually exclusive\n");
2252     ok(GetLastError() == ERROR_INVALID_FLAGS,
2253        "unexpected error code %d\n", GetLastError());
2254
2255     /* test invalid flag combinations */
2256     for (i = 0; i < sizeof(lcmap_invalid_flags)/sizeof(lcmap_invalid_flags[0]); i++) {
2257         lstrcpyA(buf, "foo");
2258         SetLastError(0xdeadbeef);
2259         ret = LCMapStringA(LOCALE_USER_DEFAULT, lcmap_invalid_flags[i],
2260                            lower_case, -1, buf, sizeof(buf));
2261         ok(GetLastError() == ERROR_INVALID_FLAGS,
2262            "LCMapStringA (flag %08x) unexpected error code %d\n",
2263            lcmap_invalid_flags[i], GetLastError());
2264         ok(!ret, "LCMapStringA (flag %08x) should return 0, got %d\n",
2265            lcmap_invalid_flags[i], ret);
2266     }
2267
2268     /* test LCMAP_LOWERCASE */
2269     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
2270                        upper_case, -1, buf, sizeof(buf));
2271     ok(ret == lstrlenA(upper_case) + 1,
2272        "ret %d, error %d, expected value %d\n",
2273        ret, GetLastError(), lstrlenA(upper_case) + 1);
2274     ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
2275
2276     /* test LCMAP_UPPERCASE */
2277     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
2278                        lower_case, -1, buf, sizeof(buf));
2279     ok(ret == lstrlenA(lower_case) + 1,
2280        "ret %d, error %d, expected value %d\n",
2281        ret, GetLastError(), lstrlenA(lower_case) + 1);
2282     ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
2283
2284     /* test buffer overflow */
2285     SetLastError(0xdeadbeef);
2286     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
2287                        lower_case, -1, buf, 4);
2288     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2289        "should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", ret);
2290
2291     /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
2292     lstrcpyA(buf, lower_case);
2293     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
2294                        buf, -1, buf, sizeof(buf));
2295     if (!ret) /* Win9x */
2296         trace("Ignoring LCMapStringA(LCMAP_UPPERCASE, buf, buf) error on Win9x\n");
2297     else
2298     {
2299         ok(ret == lstrlenA(lower_case) + 1,
2300            "ret %d, error %d, expected value %d\n",
2301            ret, GetLastError(), lstrlenA(lower_case) + 1);
2302         ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
2303     }
2304     lstrcpyA(buf, upper_case);
2305     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
2306                        buf, -1, buf, sizeof(buf));
2307     if (!ret) /* Win9x */
2308         trace("Ignoring LCMapStringA(LCMAP_LOWERCASE, buf, buf) error on Win9x\n");
2309     else
2310     {
2311         ok(ret == lstrlenA(upper_case) + 1,
2312            "ret %d, error %d, expected value %d\n",
2313            ret, GetLastError(), lstrlenA(lower_case) + 1);
2314         ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
2315     }
2316
2317     /* otherwise src == dst should fail */
2318     SetLastError(0xdeadbeef);
2319     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | LCMAP_UPPERCASE,
2320                        buf, 10, buf, sizeof(buf));
2321     ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
2322        GetLastError() == ERROR_INVALID_PARAMETER /* Win9x */,
2323        "unexpected error code %d\n", GetLastError());
2324     ok(!ret, "src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n");
2325
2326     /* test whether '\0' is always appended */
2327     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
2328                        upper_case, -1, buf, sizeof(buf));
2329     ok(ret, "LCMapStringA must succeed\n");
2330     ok(buf[ret-1] == 0, "LCMapStringA not null-terminated\n");
2331     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
2332                        upper_case, lstrlenA(upper_case), buf2, sizeof(buf2));
2333     ok(ret2, "LCMapStringA must succeed\n");
2334     ok(buf2[ret2-1] == 0, "LCMapStringA not null-terminated\n" );
2335     ok(ret == ret2, "lengths of sort keys must be equal\n");
2336     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
2337
2338     /* test LCMAP_SORTKEY | NORM_IGNORECASE */
2339     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORECASE,
2340                        upper_case, -1, buf, sizeof(buf));
2341     ok(ret, "LCMapStringA must succeed\n");
2342     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
2343                        lower_case, -1, buf2, sizeof(buf2));
2344     ok(ret2, "LCMapStringA must succeed\n");
2345     ok(ret == ret2, "lengths of sort keys must be equal\n");
2346     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
2347
2348     /* Don't test LCMAP_SORTKEY | NORM_IGNORENONSPACE, produces different
2349        results from plain LCMAP_SORTKEY on Vista */
2350
2351     /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
2352     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
2353                        lower_case, -1, buf, sizeof(buf));
2354     ok(ret, "LCMapStringA must succeed\n");
2355     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
2356                        symbols_stripped, -1, buf2, sizeof(buf2));
2357     ok(ret2, "LCMapStringA must succeed\n");
2358     ok(ret == ret2, "lengths of sort keys must be equal\n");
2359     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
2360
2361     /* test NORM_IGNORENONSPACE */
2362     lstrcpyA(buf, "foo");
2363     ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORENONSPACE,
2364                        lower_case, -1, buf, sizeof(buf));
2365     ok(ret == lstrlenA(lower_case) + 1, "LCMapStringA should return %d, ret = %d\n",
2366         lstrlenA(lower_case) + 1, ret);
2367     ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
2368
2369     /* test NORM_IGNORESYMBOLS */
2370     lstrcpyA(buf, "foo");
2371     ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORESYMBOLS,
2372                        lower_case, -1, buf, sizeof(buf));
2373     ok(ret == lstrlenA(symbols_stripped) + 1, "LCMapStringA should return %d, ret = %d\n",
2374         lstrlenA(symbols_stripped) + 1, ret);
2375     ok(!lstrcmpA(buf, symbols_stripped), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
2376
2377     /* test NORM_IGNORESYMBOLS | NORM_IGNORENONSPACE */
2378     lstrcpyA(buf, "foo");
2379     ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORESYMBOLS | NORM_IGNORENONSPACE,
2380                        lower_case, -1, buf, sizeof(buf));
2381     ok(ret == lstrlenA(symbols_stripped) + 1, "LCMapStringA should return %d, ret = %d\n",
2382         lstrlenA(symbols_stripped) + 1, ret);
2383     ok(!lstrcmpA(buf, symbols_stripped), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
2384
2385     /* test srclen = 0 */
2386     SetLastError(0xdeadbeef);
2387     ret = LCMapStringA(LOCALE_USER_DEFAULT, 0, upper_case, 0, buf, sizeof(buf));
2388     ok(!ret, "LCMapStringA should fail with srclen = 0\n");
2389     ok(GetLastError() == ERROR_INVALID_PARAMETER,
2390        "unexpected error code %d\n", GetLastError());
2391 }
2392
2393 typedef INT (*lcmapstring_wrapper)(DWORD, LPCWSTR, INT, LPWSTR, INT);
2394
2395 static void test_lcmapstring_unicode(lcmapstring_wrapper func_ptr, const char *func_name)
2396 {
2397     static const WCHAR japanese_text[] = {
2398         0x3044, 0x309d, 0x3084, 0x3001, 0x30a4, 0x30fc, 0x30cf,
2399         0x30c8, 0x30fc, 0x30f4, 0x30a9, 0x306e, 0x2026, 0
2400     };
2401     static const WCHAR hiragana_text[] = {
2402         0x3044, 0x309d, 0x3084, 0x3001, 0x3044, 0x30fc, 0x306f,
2403         0x3068, 0x30fc, 0x3094, 0x3049, 0x306e, 0x2026, 0
2404     };
2405     static const WCHAR katakana_text[] = {
2406         0x30a4, 0x30fd, 0x30e4, 0x3001, 0x30a4, 0x30fc, 0x30cf,
2407         0x30c8, 0x30fc, 0x30f4, 0x30a9, 0x30ce, 0x2026, 0
2408     };
2409     static const WCHAR halfwidth_text[] = {
2410         0x3044, 0x309d, 0x3084, 0xff64, 0xff72, 0xff70, 0xff8a,
2411         0xff84, 0xff70, 0xff73, 0xff9e, 0xff6b, 0x306e, 0x2026, 0
2412     };
2413     int ret, ret2, i;
2414     WCHAR buf[256], buf2[256];
2415     char *p_buf = (char *)buf, *p_buf2 = (char *)buf2;
2416
2417     /* LCMAP_LOWERCASE | LCMAP_UPPERCASE makes LCMAP_TITLECASE, so it's valid now. */
2418     ret = func_ptr(LCMAP_LOWERCASE | LCMAP_UPPERCASE,
2419                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
2420     todo_wine ok(ret == lstrlenW(title_case) + 1 || broken(!ret),
2421        "%s ret %d, error %d, expected value %d\n", func_name,
2422        ret, GetLastError(), lstrlenW(title_case) + 1);
2423     todo_wine ok(lstrcmpW(buf, title_case) == 0 || broken(!ret),
2424        "Expected title case string\n");
2425
2426     /* test invalid flag combinations */
2427     for (i = 0; i < sizeof(lcmap_invalid_flags)/sizeof(lcmap_invalid_flags[0]); i++) {
2428         lstrcpyW(buf, fooW);
2429         SetLastError(0xdeadbeef);
2430         ret = func_ptr(lcmap_invalid_flags[i],
2431                            lower_case, -1, buf, sizeof(buf));
2432         ok(GetLastError() == ERROR_INVALID_FLAGS,
2433            "%s (flag %08x) unexpected error code %d\n",
2434            func_name, lcmap_invalid_flags[i], GetLastError());
2435         ok(!ret, "%s (flag %08x) should return 0, got %d\n",
2436            func_name, lcmap_invalid_flags[i], ret);
2437     }
2438
2439     /* test LCMAP_LOWERCASE */
2440     ret = func_ptr(LCMAP_LOWERCASE,
2441                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
2442     ok(ret == lstrlenW(upper_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2443        ret, GetLastError(), lstrlenW(upper_case) + 1);
2444     ok(!lstrcmpW(buf, lower_case), "%s string compare mismatch\n", func_name);
2445
2446     /* test LCMAP_UPPERCASE */
2447     ret = func_ptr(LCMAP_UPPERCASE,
2448                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
2449     ok(ret == lstrlenW(lower_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2450        ret, GetLastError(), lstrlenW(lower_case) + 1);
2451     ok(!lstrcmpW(buf, upper_case), "%s string compare mismatch\n", func_name);
2452
2453     /* test LCMAP_HIRAGANA */
2454     ret = func_ptr(LCMAP_HIRAGANA,
2455                    japanese_text, -1, buf, sizeof(buf)/sizeof(WCHAR));
2456     ok(ret == lstrlenW(hiragana_text) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2457        ret, GetLastError(), lstrlenW(hiragana_text) + 1);
2458     ok(!lstrcmpW(buf, hiragana_text), "%s string compare mismatch\n", func_name);
2459
2460     buf[0] = 0x30f5; /* KATAKANA LETTER SMALL KA */
2461     ret = func_ptr(LCMAP_HIRAGANA, buf, 1, buf2, 1);
2462     ok(ret == 1, "%s ret %d, error %d, expected value 1\n", func_name,
2463        ret, GetLastError());
2464     /* U+3095: HIRAGANA LETTER SMALL KA was added in Unicode 3.2 */
2465     ok(buf2[0] == 0x3095 || broken(buf2[0] == 0x30f5 /* Vista and earlier versions */),
2466        "%s expected %04x, got %04x\n", func_name, 0x3095, buf2[0]);
2467
2468     /* test LCMAP_KATAKANA | LCMAP_LOWERCASE */
2469     ret = func_ptr(LCMAP_KATAKANA | LCMAP_LOWERCASE,
2470                    japanese_text, -1, buf, sizeof(buf)/sizeof(WCHAR));
2471     ok(ret == lstrlenW(katakana_text) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2472        ret, GetLastError(), lstrlenW(katakana_text) + 1);
2473     ok(!lstrcmpW(buf, katakana_text), "%s string compare mismatch\n", func_name);
2474
2475     /* test LCMAP_FULLWIDTH */
2476     ret = func_ptr(LCMAP_FULLWIDTH,
2477                    halfwidth_text, -1, buf, sizeof(buf)/sizeof(WCHAR));
2478     ok(ret == lstrlenW(japanese_text) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2479        ret, GetLastError(), lstrlenW(japanese_text) + 1);
2480     ok(!lstrcmpW(buf, japanese_text), "%s string compare mismatch\n", func_name);
2481
2482     ret2 = func_ptr(LCMAP_FULLWIDTH, halfwidth_text, -1, NULL, 0);
2483     ok(ret == ret2, "%s ret %d, expected value %d\n", func_name, ret2, ret);
2484
2485     /* test LCMAP_FULLWIDTH | LCMAP_HIRAGANA
2486        (half-width katakana is converted into full-wdith hiragana) */
2487     ret = func_ptr(LCMAP_FULLWIDTH | LCMAP_HIRAGANA,
2488                    halfwidth_text, -1, buf, sizeof(buf)/sizeof(WCHAR));
2489     ok(ret == lstrlenW(hiragana_text) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2490        ret, GetLastError(), lstrlenW(hiragana_text) + 1);
2491     ok(!lstrcmpW(buf, hiragana_text), "%s string compare mismatch\n", func_name);
2492
2493     ret2 = func_ptr(LCMAP_FULLWIDTH | LCMAP_HIRAGANA, halfwidth_text, -1, NULL, 0);
2494     ok(ret == ret2, "%s ret %d, expected value %d\n", func_name, ret, ret2);
2495
2496     /* test LCMAP_HALFWIDTH */
2497     ret = func_ptr(LCMAP_HALFWIDTH,
2498                    japanese_text, -1, buf, sizeof(buf)/sizeof(WCHAR));
2499     ok(ret == lstrlenW(halfwidth_text) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2500        ret, GetLastError(), lstrlenW(halfwidth_text) + 1);
2501     ok(!lstrcmpW(buf, halfwidth_text), "%s string compare mismatch\n", func_name);
2502
2503     ret2 = func_ptr(LCMAP_HALFWIDTH, japanese_text, -1, NULL, 0);
2504     ok(ret == ret2, "%s ret %d, expected value %d\n", func_name, ret, ret2);
2505
2506     /* test buffer overflow */
2507     SetLastError(0xdeadbeef);
2508     ret = func_ptr(LCMAP_UPPERCASE,
2509                        lower_case, -1, buf, 4);
2510     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2511        "%s should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", func_name, ret);
2512
2513     /* KATAKANA LETTER GA (U+30AC) is converted into two half-width characters.
2514        Thus, it requires two WCHARs. */
2515     buf[0] = 0x30ac;
2516     SetLastError(0xdeadbeef);
2517     ret = func_ptr(LCMAP_HALFWIDTH, buf, 1, buf2, 1);
2518     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
2519        "%s should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", func_name, ret);
2520
2521     /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
2522     lstrcpyW(buf, lower_case);
2523     ret = func_ptr(LCMAP_UPPERCASE,
2524                        buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
2525     ok(ret == lstrlenW(lower_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2526        ret, GetLastError(), lstrlenW(lower_case) + 1);
2527     ok(!lstrcmpW(buf, upper_case), "%s string compare mismatch\n", func_name);
2528
2529     lstrcpyW(buf, upper_case);
2530     ret = func_ptr(LCMAP_LOWERCASE,
2531                        buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
2532     ok(ret == lstrlenW(upper_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
2533        ret, GetLastError(), lstrlenW(lower_case) + 1);
2534     ok(!lstrcmpW(buf, lower_case), "%s string compare mismatch\n", func_name);
2535
2536     /* otherwise src == dst should fail */
2537     SetLastError(0xdeadbeef);
2538     ret = func_ptr(LCMAP_SORTKEY | LCMAP_UPPERCASE,
2539                        buf, 10, buf, sizeof(buf));
2540     ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
2541        GetLastError() == ERROR_INVALID_PARAMETER /* Win7+ */,
2542        "%s unexpected error code %d\n", func_name, GetLastError());
2543     ok(!ret, "%s src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n", func_name);
2544
2545     /* test whether '\0' is always appended */
2546     ret = func_ptr(LCMAP_SORTKEY,
2547                        upper_case, -1, buf, sizeof(buf));
2548     ok(ret, "%s func_ptr must succeed\n", func_name);
2549     ret2 = func_ptr(LCMAP_SORTKEY,
2550                        upper_case, lstrlenW(upper_case), buf2, sizeof(buf2));
2551     ok(ret, "%s func_ptr must succeed\n", func_name);
2552     ok(ret == ret2, "%s lengths of sort keys must be equal\n", func_name);
2553     ok(!lstrcmpA(p_buf, p_buf2), "%s sort keys must be equal\n", func_name);
2554
2555     /* test LCMAP_SORTKEY | NORM_IGNORECASE */
2556     ret = func_ptr(LCMAP_SORTKEY | NORM_IGNORECASE,
2557                        upper_case, -1, buf, sizeof(buf));
2558     ok(ret, "%s func_ptr must succeed\n", func_name);
2559     ret2 = func_ptr(LCMAP_SORTKEY,
2560                        lower_case, -1, buf2, sizeof(buf2));
2561     ok(ret2, "%s func_ptr must succeed\n", func_name);
2562     ok(ret == ret2, "%s lengths of sort keys must be equal\n", func_name);
2563     ok(!lstrcmpA(p_buf, p_buf2), "%s sort keys must be equal\n", func_name);
2564
2565     /* Don't test LCMAP_SORTKEY | NORM_IGNORENONSPACE, produces different
2566        results from plain LCMAP_SORTKEY on Vista */
2567
2568     /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
2569     ret = func_ptr(LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
2570                        lower_case, -1, buf, sizeof(buf));
2571     ok(ret, "%s func_ptr must succeed\n", func_name);
2572     ret2 = func_ptr(LCMAP_SORTKEY,
2573                        symbols_stripped, -1, buf2, sizeof(buf2));
2574     ok(ret2, "%s func_ptr must succeed\n", func_name);
2575     ok(ret == ret2, "%s lengths of sort keys must be equal\n", func_name);
2576     ok(!lstrcmpA(p_buf, p_buf2), "%s sort keys must be equal\n", func_name);
2577
2578     /* test NORM_IGNORENONSPACE */
2579     lstrcpyW(buf, fooW);
2580     ret = func_ptr(NORM_IGNORENONSPACE,
2581                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
2582     ok(ret == lstrlenW(lower_case) + 1, "%s func_ptr should return %d, ret = %d\n", func_name,
2583     lstrlenW(lower_case) + 1, ret);
2584     ok(!lstrcmpW(buf, lower_case), "%s string comparison mismatch\n", func_name);
2585
2586     /* test NORM_IGNORESYMBOLS */
2587     lstrcpyW(buf, fooW);
2588     ret = func_ptr(NORM_IGNORESYMBOLS,
2589                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
2590     ok(ret == lstrlenW(symbols_stripped) + 1, "%s func_ptr should return %d, ret = %d\n", func_name,
2591     lstrlenW(symbols_stripped) + 1, ret);
2592     ok(!lstrcmpW(buf, symbols_stripped), "%s string comparison mismatch\n", func_name);
2593
2594     /* test NORM_IGNORESYMBOLS | NORM_IGNORENONSPACE */
2595     lstrcpyW(buf, fooW);
2596     ret = func_ptr(NORM_IGNORESYMBOLS | NORM_IGNORENONSPACE,
2597                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
2598     ok(ret == lstrlenW(symbols_stripped) + 1, "%s func_ptr should return %d, ret = %d\n", func_name,
2599     lstrlenW(symbols_stripped) + 1, ret);
2600     ok(!lstrcmpW(buf, symbols_stripped), "%s string comparison mismatch\n", func_name);
2601
2602     /* test srclen = 0 */
2603     SetLastError(0xdeadbeef);
2604     ret = func_ptr(0, upper_case, 0, buf, sizeof(buf)/sizeof(WCHAR));
2605     ok(!ret, "%s func_ptr should fail with srclen = 0\n", func_name);
2606     ok(GetLastError() == ERROR_INVALID_PARAMETER,
2607        "%s unexpected error code %d\n", func_name, GetLastError());
2608 }
2609
2610 static INT LCMapStringW_wrapper(DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen)
2611 {
2612     return LCMapStringW(LOCALE_USER_DEFAULT, flags, src, srclen, dst, dstlen);
2613 }
2614
2615 static void test_LCMapStringW(void)
2616 {
2617     int ret;
2618     WCHAR buf[256];
2619
2620     trace("testing LCMapStringW\n");
2621
2622     SetLastError(0xdeadbeef);
2623     ret = LCMapStringW((LCID)-1, LCMAP_LOWERCASE, upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
2624     todo_wine {
2625     ok(!ret, "LCMapStringW should fail with bad lcid\n");
2626     ok(GetLastError() == ERROR_INVALID_PARAMETER, "unexpected error code %d\n", GetLastError());
2627     }
2628
2629     test_lcmapstring_unicode(LCMapStringW_wrapper, "LCMapStringW:");
2630 }
2631
2632 static INT LCMapStringEx_wrapper(DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen)
2633 {
2634     return pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, flags, src, srclen, dst, dstlen, NULL, NULL, 0);
2635 }
2636
2637 static void test_LCMapStringEx(void)
2638 {
2639     int ret;
2640     WCHAR buf[256];
2641
2642     if (!pLCMapStringEx)
2643     {
2644         win_skip( "LCMapStringEx not available\n" );
2645         return;
2646     }
2647
2648     trace("testing LCMapStringEx\n");
2649
2650     SetLastError(0xdeadbeef);
2651     ret = pLCMapStringEx(invalidW, LCMAP_LOWERCASE,
2652                          upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR), NULL, NULL, 0);
2653     todo_wine {
2654     ok(!ret, "LCMapStringEx should fail with bad locale name\n");
2655     ok(GetLastError() == ERROR_INVALID_PARAMETER, "unexpected error code %d\n", GetLastError());
2656     }
2657
2658     /* test reserved parameters */
2659     ret = pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, LCMAP_LOWERCASE,
2660                          upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR), NULL, NULL, 1);
2661     ok(ret == lstrlenW(upper_case) + 1, "ret %d, error %d, expected value %d\n",
2662        ret, GetLastError(), lstrlenW(upper_case) + 1);
2663     ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
2664
2665     ret = pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, LCMAP_LOWERCASE,
2666                          upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR), NULL, (void*)1, 0);
2667     ok(ret == lstrlenW(upper_case) + 1, "ret %d, error %d, expected value %d\n",
2668        ret, GetLastError(), lstrlenW(upper_case) + 1);
2669     ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
2670
2671     /* crashes on native */
2672     if(0)
2673         ret = pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, LCMAP_LOWERCASE,
2674                              upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR), (void*)1, NULL, 0);
2675
2676     test_lcmapstring_unicode(LCMapStringEx_wrapper, "LCMapStringEx:");
2677 }
2678
2679 struct neutralsublang_name_t {
2680     WCHAR name[3];
2681     WCHAR sname[16];
2682     LCID lcid;
2683     int todo;
2684 };
2685
2686 static const struct neutralsublang_name_t neutralsublang_names[] = {
2687     { {'a','r',0}, {'a','r','-','S','A',0}, MAKELCID(MAKELANGID(LANG_ARABIC, SUBLANG_ARABIC_SAUDI_ARABIA), SORT_DEFAULT) },
2688     { {'a','z',0}, {'a','z','-','L','a','t','n','-','A','Z',0}, MAKELCID(MAKELANGID(LANG_AZERI, SUBLANG_AZERI_LATIN), SORT_DEFAULT) },
2689     { {'d','e',0}, {'d','e','-','D','E',0}, MAKELCID(MAKELANGID(LANG_GERMAN, SUBLANG_GERMAN), SORT_DEFAULT) },
2690     { {'e','n',0}, {'e','n','-','U','S',0}, MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) },
2691     { {'e','s',0}, {'e','s','-','E','S',0}, MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH_MODERN), SORT_DEFAULT) },
2692     { {'g','a',0}, {'g','a','-','I','E',0}, MAKELCID(MAKELANGID(LANG_IRISH, SUBLANG_IRISH_IRELAND), SORT_DEFAULT) },
2693     { {'i','t',0}, {'i','t','-','I','T',0}, MAKELCID(MAKELANGID(LANG_ITALIAN, SUBLANG_ITALIAN), SORT_DEFAULT) },
2694     { {'m','s',0}, {'m','s','-','M','Y',0}, MAKELCID(MAKELANGID(LANG_MALAY, SUBLANG_MALAY_MALAYSIA), SORT_DEFAULT) },
2695     { {'n','l',0}, {'n','l','-','N','L',0}, MAKELCID(MAKELANGID(LANG_DUTCH, SUBLANG_DUTCH), SORT_DEFAULT) },
2696     { {'p','t',0}, {'p','t','-','B','R',0}, MAKELCID(MAKELANGID(LANG_PORTUGUESE, SUBLANG_PORTUGUESE_BRAZILIAN), SORT_DEFAULT) },
2697     { {'s','r',0}, {'s','r','-','L','a','t','n','-','R','S',0}, MAKELCID(MAKELANGID(LANG_SERBIAN, SUBLANG_SERBIAN_SERBIA_LATIN), SORT_DEFAULT), 1 },
2698     { {'s','v',0}, {'s','v','-','S','E',0}, MAKELCID(MAKELANGID(LANG_SWEDISH, SUBLANG_SWEDISH), SORT_DEFAULT) },
2699     { {'u','z',0}, {'u','z','-','L','a','t','n','-','U','Z',0}, MAKELCID(MAKELANGID(LANG_UZBEK, SUBLANG_UZBEK_LATIN), SORT_DEFAULT) },
2700     { {'z','h',0}, {'z','h','-','C','N',0}, MAKELCID(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_SIMPLIFIED), SORT_DEFAULT) },
2701     { {0} }
2702 };
2703
2704 static void test_LocaleNameToLCID(void)
2705 {
2706     LCID lcid;
2707     INT ret;
2708     WCHAR buffer[LOCALE_NAME_MAX_LENGTH];
2709     static const WCHAR enW[] = {'e','n',0};
2710     static const WCHAR esesW[] = {'e','s','-','e','s',0};
2711     static const WCHAR zhHansW[] = {'z','h','-','H','a','n','s',0};
2712     static const WCHAR zhhansW[] = {'z','h','-','h','a','n','s',0};
2713     static const WCHAR zhHantW[] = {'z','h','-','H','a','n','t',0};
2714     static const WCHAR zhhantW[] = {'z','h','-','h','a','n','t',0};
2715     static const WCHAR zhcnW[] = {'z','h','-','C','N',0};
2716     static const WCHAR zhhkW[] = {'z','h','-','H','K',0};
2717
2718     if (!pLocaleNameToLCID)
2719     {
2720         win_skip( "LocaleNameToLCID not available\n" );
2721         return;
2722     }
2723
2724     /* special cases */
2725     buffer[0] = 0;
2726     SetLastError(0xdeadbeef);
2727     lcid = pLocaleNameToLCID(LOCALE_NAME_USER_DEFAULT, 0);
2728     ok(lcid == GetUserDefaultLCID() || broken(GetLastError() == ERROR_INVALID_PARAMETER /* Vista */),
2729        "Expected lcid == %08x, got %08x, error %d\n", GetUserDefaultLCID(), lcid, GetLastError());
2730     ret = pLCIDToLocaleName(lcid, buffer, LOCALE_NAME_MAX_LENGTH, 0);
2731     ok(ret > 0, "Expected ret > 0, got %d, error %d\n", ret, GetLastError());
2732     trace("%08x, %s\n", lcid, wine_dbgstr_w(buffer));
2733
2734     buffer[0] = 0;
2735     SetLastError(0xdeadbeef);
2736     lcid = pLocaleNameToLCID(LOCALE_NAME_SYSTEM_DEFAULT, 0);
2737     ok(!lcid && GetLastError() == ERROR_INVALID_PARAMETER,
2738        "Expected lcid == 0, got %08x, error %d\n", lcid, GetLastError());
2739     ret = pLCIDToLocaleName(lcid, buffer, LOCALE_NAME_MAX_LENGTH, 0);
2740     ok(ret > 0, "Expected ret > 0, got %d, error %d\n", ret, GetLastError());
2741     trace("%08x, %s\n", lcid, wine_dbgstr_w(buffer));
2742
2743     buffer[0] = 0;
2744     SetLastError(0xdeadbeef);
2745     lcid = pLocaleNameToLCID(LOCALE_NAME_INVARIANT, 0);
2746     ok(lcid == 0x7F, "Expected lcid = 0x7F, got %08x, error %d\n", lcid, GetLastError());
2747     ret = pLCIDToLocaleName(lcid, buffer, LOCALE_NAME_MAX_LENGTH, 0);
2748     ok(ret > 0, "Expected ret > 0, got %d, error %d\n", ret, GetLastError());
2749     trace("%08x, %s\n", lcid, wine_dbgstr_w(buffer));
2750
2751     /* bad name */
2752     SetLastError(0xdeadbeef);
2753     lcid = pLocaleNameToLCID(invalidW, 0);
2754     ok(!lcid && GetLastError() == ERROR_INVALID_PARAMETER,
2755        "Expected lcid == 0, got %08x, error %d\n", lcid, GetLastError());
2756
2757     /* lower-case */
2758     lcid = pLocaleNameToLCID(esesW, 0);
2759     ok(lcid == MAKELCID(MAKELANGID(LANG_SPANISH, SUBLANG_SPANISH_MODERN), SORT_DEFAULT), "Got wrong lcid for es-es: 0x%x\n", lcid);
2760
2761     /* english neutral name */
2762     lcid = pLocaleNameToLCID(enW, 0);
2763     ok(lcid == MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT) ||
2764        broken(lcid == 0) /* Vista */, "got 0x%04x\n", lcid);
2765     if (lcid)
2766     {
2767         const struct neutralsublang_name_t *ptr = neutralsublang_names;
2768
2769         while (*ptr->name)
2770         {
2771             lcid = pLocaleNameToLCID(ptr->name, 0);
2772             todo_wine_if (ptr->todo)
2773                 ok(lcid == ptr->lcid, "%s: got wrong lcid 0x%04x, expected 0x%04x\n",
2774                     wine_dbgstr_w(ptr->name), lcid, ptr->lcid);
2775
2776             *buffer = 0;
2777             ret = pLCIDToLocaleName(lcid, buffer, sizeof(buffer)/sizeof(WCHAR), 0);
2778             ok(ret > 0, "%s: got %d\n", wine_dbgstr_w(ptr->name), ret);
2779             ok(!lstrcmpW(ptr->sname, buffer), "%s: got wrong locale name %s\n",
2780                 wine_dbgstr_w(ptr->name), wine_dbgstr_w(buffer));
2781
2782             ptr++;
2783         }
2784
2785         /* zh-Hant */
2786         lcid = pLocaleNameToLCID(zhHantW, 0);
2787         todo_wine ok(lcid == MAKELCID(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_HONGKONG), SORT_DEFAULT),
2788            "%s: got wrong lcid 0x%04x\n", wine_dbgstr_w(zhHantW), lcid);
2789         ret = pLCIDToLocaleName(lcid, buffer, sizeof(buffer)/sizeof(WCHAR), 0);
2790         ok(ret > 0, "%s: got %d\n", wine_dbgstr_w(zhHantW), ret);
2791         todo_wine ok(!lstrcmpW(zhhkW, buffer), "%s: got wrong locale name %s\n",
2792            wine_dbgstr_w(zhHantW), wine_dbgstr_w(buffer));
2793
2794         /* zh-hant */
2795         lcid = pLocaleNameToLCID(zhhantW, 0);
2796         todo_wine ok(lcid == MAKELCID(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_HONGKONG), SORT_DEFAULT),
2797            "%s: got wrong lcid 0x%04x\n", wine_dbgstr_w(zhhantW),
2798            MAKELCID(MAKELANGID(LANG_CHINESE, SUBLANG_CHINESE_HONGKONG), SORT_DEFAULT));
2799         ret = pLCIDToLocaleName(lcid, buffer, sizeof(buffer)/sizeof(WCHAR), 0);
2800         ok(ret > 0, "%s: got %d\n", wine_dbgstr_w(zhhantW), ret);
2801         todo_wine ok(!lstrcmpW(zhhkW, buffer), "%s: got wrong locale name %s\n",
2802            wine_dbgstr_w(zhhantW), wine_dbgstr_w(buffer));
2803
2804         /* zh-Hans */
2805         lcid = pLocaleNameToLCID(zhHansW, 0);
2806         todo_wine ok(lcid == MAKELCID(MAKELANGID(LANG_CHINESE_SIMPLIFIED, SUBLANG_CHINESE_SIMPLIFIED), SORT_DEFAULT),
2807            "%s: got wrong lcid 0x%04x\n", wine_dbgstr_w(zhHansW), lcid);
2808         ret = pLCIDToLocaleName(lcid, buffer, sizeof(buffer)/sizeof(WCHAR), 0);
2809         ok(ret > 0, "%s: got %d\n", wine_dbgstr_w(zhHansW), ret);
2810         todo_wine ok(!lstrcmpW(zhcnW, buffer), "%s: got wrong locale name %s\n",
2811            wine_dbgstr_w(zhHansW), wine_dbgstr_w(buffer));
2812
2813         /* zh-hans */
2814         lcid = pLocaleNameToLCID(zhhansW, 0);
2815         todo_wine ok(lcid == MAKELCID(MAKELANGID(LANG_CHINESE_SIMPLIFIED, SUBLANG_CHINESE_SIMPLIFIED), SORT_DEFAULT),
2816            "%s: got wrong lcid 0x%04x\n", wine_dbgstr_w(zhhansW),
2817            MAKELCID(MAKELANGID(LANG_CHINESE_SIMPLIFIED, SUBLANG_CHINESE_SIMPLIFIED), SORT_DEFAULT));
2818         ret = pLCIDToLocaleName(lcid, buffer, sizeof(buffer)/sizeof(WCHAR), 0);
2819         ok(ret > 0, "%s: got %d\n", wine_dbgstr_w(zhhansW), ret);
2820         todo_wine ok(!lstrcmpW(zhcnW, buffer), "%s: got wrong locale name %s\n",
2821            wine_dbgstr_w(zhhansW), wine_dbgstr_w(buffer));
2822     }
2823 }
2824
2825 /* this requires collation table patch to make it MS compatible */
2826 static const char * const strings_sorted[] =
2827 {
2828 "'",
2829 "-",
2830 "!",
2831 "\"",
2832 ".",
2833 ":",
2834 "\\",
2835 "_",
2836 "`",
2837 "{",
2838 "}",
2839 "+",
2840 "0",
2841 "1",
2842 "2",
2843 "3",
2844 "4",
2845 "5",
2846 "6",
2847 "7",
2848 "8",
2849 "9",
2850 "a",
2851 "A",
2852 "b",
2853 "B",
2854 "c",
2855 "C"
2856 };
2857
2858 static const char * const strings[] =
2859 {
2860 "C",
2861 "\"",
2862 "9",
2863 "'",
2864 "}",
2865 "-",
2866 "7",
2867 "+",
2868 "`",
2869 "1",
2870 "a",
2871 "5",
2872 "\\",
2873 "8",
2874 "B",
2875 "3",
2876 "_",
2877 "6",
2878 "{",
2879 "2",
2880 "c",
2881 "4",
2882 "!",
2883 "0",
2884 "A",
2885 ":",
2886 "b",
2887 "."
2888 };
2889
2890 static int compare_string1(const void *e1, const void *e2)
2891 {
2892     const char *s1 = *(const char *const *)e1;
2893     const char *s2 = *(const char *const *)e2;
2894
2895     return lstrcmpA(s1, s2);
2896 }
2897
2898 static int compare_string2(const void *e1, const void *e2)
2899 {
2900     const char *s1 = *(const char *const *)e1;
2901     const char *s2 = *(const char *const *)e2;
2902
2903     return CompareStringA(0, 0, s1, -1, s2, -1) - 2;
2904 }
2905
2906 static int compare_string3(const void *e1, const void *e2)
2907 {
2908     const char *s1 = *(const char *const *)e1;
2909     const char *s2 = *(const char *const *)e2;
2910     char key1[256], key2[256];
2911
2912     LCMapStringA(0, LCMAP_SORTKEY, s1, -1, key1, sizeof(key1));
2913     LCMapStringA(0, LCMAP_SORTKEY, s2, -1, key2, sizeof(key2));
2914     return strcmp(key1, key2);
2915 }
2916
2917 static void test_sorting(void)
2918 {
2919     char buf[256];
2920     char **str_buf = (char **)buf;
2921     int i;
2922
2923     assert(sizeof(buf) >= sizeof(strings));
2924
2925     /* 1. sort using lstrcmpA */
2926     memcpy(buf, strings, sizeof(strings));
2927     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string1);
2928     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
2929     {
2930         ok(!strcmp(strings_sorted[i], str_buf[i]),
2931            "qsort using lstrcmpA failed for element %d\n", i);
2932     }
2933     /* 2. sort using CompareStringA */
2934     memcpy(buf, strings, sizeof(strings));
2935     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string2);
2936     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
2937     {
2938         ok(!strcmp(strings_sorted[i], str_buf[i]),
2939            "qsort using CompareStringA failed for element %d\n", i);
2940     }
2941     /* 3. sort using sort keys */
2942     memcpy(buf, strings, sizeof(strings));
2943     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string3);
2944     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
2945     {
2946         ok(!strcmp(strings_sorted[i], str_buf[i]),
2947            "qsort using sort keys failed for element %d\n", i);
2948     }
2949 }
2950
2951 static void test_FoldStringA(void)
2952 {
2953   int ret, i, j;
2954   BOOL is_special;
2955   char src[256], dst[256];
2956   static const char digits_src[] = { 0xB9,0xB2,0xB3,'\0'  };
2957   static const char digits_dst[] = { '1','2','3','\0'  };
2958   static const char composite_src[] =
2959   {
2960     0x8a,0x8e,0x9a,0x9e,0x9f,0xc0,0xc1,0xc2,
2961     0xc3,0xc4,0xc5,0xc7,0xc8,0xc9,0xca,0xcb,
2962     0xcc,0xcd,0xce,0xcf,0xd1,0xd2,0xd3,0xd4,
2963     0xd5,0xd6,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,
2964     0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe7,0xe8,
2965     0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,0xf1,
2966     0xf2,0xf3,0xf4,0xf5,0xf6,0xf8,0xf9,0xfa,
2967     0xfb,0xfc,0xfd,0xff,'\0'
2968   };
2969   static const char composite_dst[] =
2970   {
2971     0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
2972     0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
2973     0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
2974     0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
2975     0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
2976     0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
2977     0x4f,0x7e,0x4f,0xa8,0x4f,0x3f,0x55,0x60,
2978     0x55,0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,
2979     0x61,0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,
2980     0x61,0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,
2981     0x65,0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,
2982     0x69,0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,
2983     0x6f,0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,
2984     0x6f,0xa8,0x6f,0x3f,0x75,0x60,0x75,0xb4,
2985     0x75,0x5e,0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
2986   };
2987   static const char composite_dst_alt[] =
2988   {
2989     0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
2990     0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
2991     0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
2992     0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
2993     0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
2994     0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
2995     0x4f,0x7e,0x4f,0xa8,0xd8,0x55,0x60,0x55,
2996     0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,0x61,
2997     0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,0x61,
2998     0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,0x65,
2999     0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,0x69,
3000     0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,0x6f,
3001     0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,0x6f,
3002     0xa8,0xf8,0x75,0x60,0x75,0xb4,0x75,0x5e,
3003     0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
3004   };
3005   static const char ligatures_src[] =
3006   {
3007     0x8C,0x9C,0xC6,0xDE,0xDF,0xE6,0xFE,'\0'
3008   };
3009   static const char ligatures_dst[] =
3010   {
3011     'O','E','o','e','A','E','T','H','s','s','a','e','t','h','\0'
3012   };
3013   static const struct special
3014   {
3015     char src;
3016     char dst[4];
3017   }  foldczone_special[] =
3018   {
3019     /* src   dst                   */
3020     { 0x85, { 0x2e, 0x2e, 0x2e, 0x00 } },
3021     { 0x98, { 0x20, 0x7e, 0x00 } },
3022     { 0x99, { 0x54, 0x4d, 0x00 } },
3023     { 0xa0, { 0x20, 0x00 } },
3024     { 0xa8, { 0x20, 0xa8, 0x00 } },
3025     { 0xaa, { 0x61, 0x00 } },
3026     { 0xaf, { 0x20, 0xaf, 0x00 } },
3027     { 0xb2, { 0x32, 0x00 } },
3028     { 0xb3, { 0x33, 0x00 } },
3029     { 0xb4, { 0x20, 0xb4, 0x00 } },
3030     { 0xb8, { 0x20, 0xb8, 0x00 } },
3031     { 0xb9, { 0x31, 0x00 } },
3032     { 0xba, { 0x6f, 0x00 } },
3033     { 0xbc, { 0x31, 0x2f, 0x34, 0x00 } },
3034     { 0xbd, { 0x31, 0x2f, 0x32, 0x00 } },
3035     { 0xbe, { 0x33, 0x2f, 0x34, 0x00 } },
3036     { 0x00 }
3037   };
3038
3039   if (!pFoldStringA)
3040     return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
3041
3042   /* these tests are locale specific */
3043   if (GetACP() != 1252)
3044   {
3045       trace("Skipping FoldStringA tests for a not Latin 1 locale\n");
3046       return;
3047   }
3048
3049   /* MAP_FOLDDIGITS */
3050   SetLastError(0);
3051   ret = pFoldStringA(MAP_FOLDDIGITS, digits_src, -1, dst, 256);
3052   if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3053   {
3054     win_skip("FoldStringA is not implemented\n");
3055     return;
3056   }
3057   ok(ret == 4, "Expected ret == 4, got %d, error %d\n", ret, GetLastError());
3058   ok(strcmp(dst, digits_dst) == 0,
3059      "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", digits_dst, dst);
3060   for (i = 1; i < 256; i++)
3061   {
3062     if (!strchr(digits_src, i))
3063     {
3064       src[0] = i;
3065       src[1] = '\0';
3066       SetLastError(0);
3067       ret = pFoldStringA(MAP_FOLDDIGITS, src, -1, dst, 256);
3068       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3069       ok(dst[0] == src[0],
3070          "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", src, dst);
3071     }
3072   }
3073
3074   /* MAP_EXPAND_LIGATURES */
3075   SetLastError(0);
3076   ret = pFoldStringA(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
3077   /* NT 4.0 doesn't support MAP_EXPAND_LIGATURES */
3078   if (!(ret == 0 && GetLastError() == ERROR_INVALID_FLAGS)) {
3079     ok(ret == sizeof(ligatures_dst), "Got %d, error %d\n", ret, GetLastError());
3080     ok(strcmp(dst, ligatures_dst) == 0,
3081        "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", ligatures_dst, dst);
3082     for (i = 1; i < 256; i++)
3083     {
3084       if (!strchr(ligatures_src, i))
3085       {
3086         src[0] = i;
3087         src[1] = '\0';
3088         SetLastError(0);
3089         ret = pFoldStringA(MAP_EXPAND_LIGATURES, src, -1, dst, 256);
3090         if (ret == 3)
3091         {
3092           /* Vista */
3093           ok((i == 0xDC && lstrcmpA(dst, "UE") == 0) ||
3094              (i == 0xFC && lstrcmpA(dst, "ue") == 0),
3095              "Got %s for %d\n", dst, i);
3096         }
3097         else
3098         {
3099           ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3100           ok(dst[0] == src[0],
3101              "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", src, dst);
3102         }
3103       }
3104     }
3105   }
3106
3107   /* MAP_COMPOSITE */
3108   SetLastError(0);
3109   ret = pFoldStringA(MAP_COMPOSITE, composite_src, -1, dst, 256);
3110   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
3111   ok(ret == 121 || ret == 119, "Expected 121 or 119, got %d\n", ret);
3112   ok(strcmp(dst, composite_dst) == 0 || strcmp(dst, composite_dst_alt) == 0,
3113      "MAP_COMPOSITE: Mismatch, got '%s'\n", dst);
3114
3115   for (i = 1; i < 256; i++)
3116   {
3117     if (!strchr(composite_src, i))
3118     {
3119       src[0] = i;
3120       src[1] = '\0';
3121       SetLastError(0);
3122       ret = pFoldStringA(MAP_COMPOSITE, src, -1, dst, 256);
3123       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3124       ok(dst[0] == src[0],
3125          "0x%02x, 0x%02x,0x%02x,0x%02x,\n", (unsigned char)src[0],
3126          (unsigned char)dst[0],(unsigned char)dst[1],(unsigned char)dst[2]);
3127     }
3128   }
3129
3130   /* MAP_FOLDCZONE */
3131   for (i = 1; i < 256; i++)
3132   {
3133     src[0] = i;
3134     src[1] = '\0';
3135     SetLastError(0);
3136     ret = pFoldStringA(MAP_FOLDCZONE, src, -1, dst, 256);
3137     is_special = FALSE;
3138     for (j = 0; foldczone_special[j].src != 0 && ! is_special; j++)
3139     {
3140       if (foldczone_special[j].src == src[0])
3141       {
3142         ok(ret == 2 || ret == lstrlenA(foldczone_special[j].dst) + 1,
3143            "Expected ret == 2 or %d, got %d, error %d\n",
3144            lstrlenA(foldczone_special[j].dst) + 1, ret, GetLastError());
3145         ok(src[0] == dst[0] || lstrcmpA(foldczone_special[j].dst, dst) == 0,
3146            "MAP_FOLDCZONE: string mismatch for 0x%02x\n",
3147            (unsigned char)src[0]);
3148         is_special = TRUE;
3149       }
3150     }
3151     if (! is_special)
3152     {
3153       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3154       ok(src[0] == dst[0],
3155          "MAP_FOLDCZONE: Expected 0x%02x, got 0x%02x\n",
3156          (unsigned char)src[0], (unsigned char)dst[0]);
3157     }
3158   }
3159
3160   /* MAP_PRECOMPOSED */
3161   for (i = 1; i < 256; i++)
3162   {
3163     src[0] = i;
3164     src[1] = '\0';
3165     SetLastError(0);
3166     ret = pFoldStringA(MAP_PRECOMPOSED, src, -1, dst, 256);
3167     ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3168     ok(src[0] == dst[0],
3169        "MAP_PRECOMPOSED: Expected 0x%02x, got 0x%02x\n",
3170        (unsigned char)src[0], (unsigned char)dst[0]);
3171   }
3172 }
3173
3174 static void test_FoldStringW(void)
3175 {
3176   int ret;
3177   unsigned int i, j;
3178   WCHAR src[256], dst[256], ch, prev_ch = 1;
3179   static const DWORD badFlags[] =
3180   {
3181     0,
3182     MAP_PRECOMPOSED|MAP_COMPOSITE,
3183     MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES,
3184     MAP_COMPOSITE|MAP_EXPAND_LIGATURES
3185   };
3186   /* Ranges of digits 0-9 : Must be sorted! */
3187   static const WCHAR digitRanges[] =
3188   {
3189     0x0030, /* '0'-'9' */
3190     0x0660, /* Eastern Arabic */
3191     0x06F0, /* Arabic - Hindu */
3192     0x07C0, /* Nko */
3193     0x0966, /* Devengari */
3194     0x09E6, /* Bengalii */
3195     0x0A66, /* Gurmukhi */
3196     0x0AE6, /* Gujarati */
3197     0x0B66, /* Oriya */
3198     0x0BE6, /* Tamil - No 0 */
3199     0x0C66, /* Telugu */
3200     0x0CE6, /* Kannada */
3201     0x0D66, /* Maylayalam */
3202     0x0DE6, /* Sinhala Lith */
3203     0x0E50, /* Thai */
3204     0x0ED0, /* Laos */
3205     0x0F20, /* Tibet */
3206     0x0F29, /* Tibet half - 0 is out of sequence */
3207     0x1040, /* Myanmar */
3208     0x1090, /* Myanmar Shan */
3209     0x1368, /* Ethiopic - no 0 */
3210     0x17E0, /* Khmer */
3211     0x1810, /* Mongolian */
3212     0x1946, /* Limbu */
3213     0x19D0, /* New Tai Lue */
3214     0x1A80, /* Tai Tham Hora */
3215     0x1A90, /* Tai Tham Tham */
3216     0x1B50, /* Balinese */
3217     0x1BB0, /* Sundanese */
3218     0x1C40, /* Lepcha */
3219     0x1C50, /* Ol Chiki */
3220     0x2070, /* Superscript - 1, 2, 3 are out of sequence */
3221     0x2080, /* Subscript */
3222     0x245F, /* Circled - 0 is out of sequence */
3223     0x2473, /* Bracketed */
3224     0x2487, /* Full stop */
3225     0x24F4, /* Double Circled */
3226     0x2775, /* Inverted circled - No 0 */
3227     0x277F, /* Patterned circled - No 0 */
3228     0x2789, /* Inverted Patterned circled - No 0 */
3229     0x3020, /* Hangzhou */
3230     0xA620, /* Vai */
3231     0xA8D0, /* Saurashtra */
3232     0xA900, /* Kayah Li */
3233     0xA9D0, /* Javanese */
3234     0xA9F0, /* Myanmar Tai Laing */
3235     0xAA50, /* Cham */
3236     0xABF0, /* Meetei Mayek */
3237     0xff10, /* Pliene chasse (?) */
3238     0xffff  /* Terminator */
3239   };
3240   /* Digits which are represented, but out of sequence */
3241   static const WCHAR outOfSequenceDigits[] =
3242   {
3243       0xB9,   /* Superscript 1 */
3244       0xB2,   /* Superscript 2 */
3245       0xB3,   /* Superscript 3 */
3246       0x0C78, /* Telugu Fraction 0 */
3247       0x0C79, /* Telugu Fraction 1 */
3248       0x0C7A, /* Telugu Fraction 2 */
3249       0x0C7B, /* Telugu Fraction 3 */
3250       0x0C7C, /* Telugu Fraction 1 */
3251       0x0C7D, /* Telugu Fraction 2 */
3252       0x0C7E, /* Telugu Fraction 3 */
3253       0x0F33, /* Tibetan half zero */
3254       0x19DA, /* New Tai Lue Tham 1 */
3255       0x24EA, /* Circled 0 */
3256       0x24FF, /* Negative Circled 0 */
3257       0x3007, /* Ideographic number zero */
3258       '\0'    /* Terminator */
3259   };
3260   /* Digits in digitRanges for which no representation is available */
3261   static const WCHAR noDigitAvailable[] =
3262   {
3263       0x0BE6, /* No Tamil 0 */
3264       0x0F29, /* No Tibetan half zero (out of sequence) */
3265       0x1368, /* No Ethiopic 0 */
3266       0x2473, /* No Bracketed 0 */
3267       0x2487, /* No 0 Full stop */
3268       0x24F4, /* No double circled 0 */
3269       0x2775, /* No inverted circled 0 */
3270       0x277F, /* No patterned circled */
3271       0x2789, /* No inverted Patterned circled */
3272       0x3020, /* No Hangzhou 0 */
3273       '\0'    /* Terminator */
3274   };
3275   static const WCHAR foldczone_src[] =
3276   {
3277     'W',    'i',    'n',    'e',    0x0348, 0x0551, 0x1323, 0x280d,
3278     0xff37, 0xff49, 0xff4e, 0xff45, '\0'
3279   };
3280   static const WCHAR foldczone_dst[] =
3281   {
3282     'W','i','n','e',0x0348,0x0551,0x1323,0x280d,'W','i','n','e','\0'
3283   };
3284   static const WCHAR foldczone_todo_src[] =
3285   {
3286       0x3c5,0x308,0x6a,0x30c,0xa0,0xaa,0
3287   };
3288   static const WCHAR foldczone_todo_dst[] =
3289   {
3290       0x3cb,0x1f0,' ','a',0
3291   };
3292   static const WCHAR foldczone_todo_broken_dst[] =
3293   {
3294       0x3cb,0x1f0,0xa0,0xaa,0
3295   };
3296   static const WCHAR ligatures_src[] =
3297   {
3298     'W',    'i',    'n',    'e',    0x03a6, 0x03b9, 0x03bd, 0x03b5,
3299     0x00c6, 0x00de, 0x00df, 0x00e6, 0x00fe, 0x0132, 0x0133, 0x0152,
3300     0x0153, 0x01c4, 0x01c5, 0x01c6, 0x01c7, 0x01c8, 0x01c9, 0x01ca,
3301     0x01cb, 0x01cc, 0x01e2, 0x01e3, 0x01f1, 0x01f2, 0x01f3, 0x01fc,
3302     0x01fd, 0x05f0, 0x05f1, 0x05f2, 0xfb00, 0xfb01, 0xfb02, 0xfb03,
3303     0xfb04, 0xfb05, 0xfb06, '\0'
3304   };
3305   static const WCHAR ligatures_dst[] =
3306   {
3307     'W','i','n','e',0x03a6,0x03b9,0x03bd,0x03b5,
3308     'A','E','T','H','s','s','a','e','t','h','I','J','i','j','O','E','o','e',
3309     'D',0x017d,'D',0x017e,'d',0x017e,'L','J','L','j','l','j','N','J','N','j',
3310     'n','j',0x0100,0x0112,0x0101,0x0113,'D','Z','D','z','d','z',0x00c1,0x00c9,
3311     0x00e1,0x00e9,0x05d5,0x05d5,0x05d5,0x05d9,0x05d9,0x05d9,'f','f','f','i',
3312     'f','l','f','f','i','f','f','l',0x017f,'t','s','t','\0'
3313   };
3314
3315   if (!pFoldStringW)
3316   {
3317     win_skip("FoldStringW is not available\n");
3318     return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
3319   }
3320
3321   /* Invalid flag combinations */
3322   for (i = 0; i < sizeof(badFlags)/sizeof(badFlags[0]); i++)
3323   {
3324     src[0] = dst[0] = '\0';
3325     SetLastError(0);
3326     ret = pFoldStringW(badFlags[i], src, 256, dst, 256);
3327     if (GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
3328     {
3329       win_skip("FoldStringW is not implemented\n");
3330       return;
3331     }
3332     ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
3333        "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
3334   }
3335
3336   /* src & dst cannot be the same */
3337   SetLastError(0);
3338   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, src, 256);
3339   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3340       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3341
3342   /* src can't be NULL */
3343   SetLastError(0);
3344   ret = pFoldStringW(MAP_FOLDCZONE, NULL, -1, dst, 256);
3345   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3346       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3347
3348   /* srclen can't be 0 */
3349   SetLastError(0);
3350   ret = pFoldStringW(MAP_FOLDCZONE, src, 0, dst, 256);
3351   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3352       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3353
3354   /* dstlen can't be < 0 */
3355   SetLastError(0);
3356   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, -1);
3357   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3358       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3359
3360   /* Ret includes terminating NUL which is appended if srclen = -1 */
3361   SetLastError(0);
3362   src[0] = 'A';
3363   src[1] = '\0';
3364   dst[0] = '\0';
3365   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, 256);
3366   ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3367   ok(dst[0] == 'A' && dst[1] == '\0',
3368      "srclen=-1: Expected ret=2 [%d,%d], got ret=%d [%d,%d], err=%d\n",
3369      'A', '\0', ret, dst[0], dst[1], GetLastError());
3370
3371   /* If size is given, result is not NUL terminated */
3372   SetLastError(0);
3373   src[0] = 'A';
3374   src[1] = 'A';
3375   dst[0] = 'X';
3376   dst[1] = 'X';
3377   ret = pFoldStringW(MAP_FOLDCZONE, src, 1, dst, 256);
3378   ok(ret == 1, "Expected ret == 1, got %d, error %d\n", ret, GetLastError());
3379   ok(dst[0] == 'A' && dst[1] == 'X',
3380      "srclen=1: Expected ret=1, [%d,%d], got ret=%d,[%d,%d], err=%d\n",
3381      'A','X', ret, dst[0], dst[1], GetLastError());
3382
3383   /* MAP_FOLDDIGITS */
3384   for (j = 0; j < sizeof(digitRanges)/sizeof(digitRanges[0]); j++)
3385   {
3386     /* Check everything before this range */
3387     for (ch = prev_ch; ch < digitRanges[j]; ch++)
3388     {
3389       SetLastError(0);
3390       src[0] = ch;
3391       src[1] = dst[0] = '\0';
3392       ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
3393       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3394
3395       ok(dst[0] == ch || strchrW(outOfSequenceDigits, ch) ||
3396          (ch >= 0xa8e0 && ch <= 0xa8e9),  /* combining Devanagari on Win8 */
3397          "MAP_FOLDDIGITS: ch 0x%04x Expected unchanged got %04x\n", ch, dst[0]);
3398       ok(!isdigitW(ch) || strchrW(outOfSequenceDigits, ch) ||
3399          broken( ch >= 0xbf0 && ch <= 0xbf2 ), /* win2k */
3400          "char %04x should not be a digit\n", ch );
3401     }
3402
3403     if (digitRanges[j] == 0xffff)
3404       break; /* Finished the whole code point space */
3405
3406     for (ch = digitRanges[j]; ch < digitRanges[j] + 10; ch++)
3407     {
3408       WCHAR c;
3409
3410       /* Map out of sequence characters */
3411       if      (ch == 0x2071) c = 0x00B9; /* Superscript 1 */
3412       else if (ch == 0x2072) c = 0x00B2; /* Superscript 2 */
3413       else if (ch == 0x2073) c = 0x00B3; /* Superscript 3 */
3414       else if (ch == 0x245F) c = 0x24EA; /* Circled 0     */
3415       else                   c = ch;
3416       SetLastError(0);
3417       src[0] = c;
3418       src[1] = dst[0] = '\0';
3419       ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
3420       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
3421
3422       ok((dst[0] == '0' + ch - digitRanges[j] && dst[1] == '\0') ||
3423          broken( dst[0] == ch ) ||  /* old Windows versions don't have all mappings */
3424          (digitRanges[j] == 0x3020 && dst[0] == ch) || /* Hangzhou not present in all Windows versions */
3425          (digitRanges[j] == 0x0F29 && dst[0] == ch) || /* Tibetan not present in all Windows versions */
3426          strchrW(noDigitAvailable, c),
3427          "MAP_FOLDDIGITS: ch %04x Expected %04x got %04x\n",
3428          ch, '0' + digitRanges[j] - ch, dst[0]);
3429     }
3430     prev_ch = ch;
3431   }
3432
3433   /* MAP_FOLDCZONE */
3434   SetLastError(0);
3435   ret = pFoldStringW(MAP_FOLDCZONE, foldczone_src, -1, dst, 256);
3436   ok(ret == sizeof(foldczone_dst)/sizeof(foldczone_dst[0]),
3437      "Got %d, error %d\n", ret, GetLastError());
3438   ok(!memcmp(dst, foldczone_dst, sizeof(foldczone_dst)),
3439      "MAP_FOLDCZONE: Expanded incorrectly\n");
3440
3441   ret = pFoldStringW(MAP_FOLDCZONE|MAP_PRECOMPOSED, foldczone_todo_src, -1, dst, 256);
3442   todo_wine ok(ret == sizeof(foldczone_todo_dst)/sizeof(foldczone_todo_dst[0]),
3443           "Got %d, error %d\n", ret, GetLastError());
3444   todo_wine ok(!memcmp(dst, foldczone_todo_dst, sizeof(foldczone_todo_dst))
3445           || broken(!memcmp(dst, foldczone_todo_broken_dst, sizeof(foldczone_todo_broken_dst))),
3446           "MAP_FOLDCZONE: Expanded incorrectly (%s)\n", wine_dbgstr_w(dst));
3447
3448   /* MAP_EXPAND_LIGATURES */
3449   SetLastError(0);
3450   ret = pFoldStringW(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
3451   /* NT 4.0 doesn't support MAP_EXPAND_LIGATURES */
3452   if (!(ret == 0 && GetLastError() == ERROR_INVALID_FLAGS)) {
3453     ok(ret == sizeof(ligatures_dst)/sizeof(ligatures_dst[0]),
3454        "Got %d, error %d\n", ret, GetLastError());
3455     ok(!memcmp(dst, ligatures_dst, sizeof(ligatures_dst)),
3456        "MAP_EXPAND_LIGATURES: Expanded incorrectly\n");
3457   }
3458
3459   /* FIXME: MAP_PRECOMPOSED : MAP_COMPOSITE */
3460 }
3461
3462
3463
3464 #define LCID_OK(l) \
3465   ok(lcid == l, "Expected lcid = %08x, got %08x\n", l, lcid)
3466 #define MKLCID(x,y,z) MAKELCID(MAKELANGID(x, y), z)
3467 #define LCID_RES(src, res) lcid = ConvertDefaultLocale(src); LCID_OK(res)
3468 #define TEST_LCIDLANG(a,b) LCID_RES(MAKELCID(a,b), MAKELCID(a,b))
3469 #define TEST_LCID(a,b,c) LCID_RES(MKLCID(a,b,c), MKLCID(a,b,c))
3470
3471 static void test_ConvertDefaultLocale(void)
3472 {
3473   LCID lcid;
3474
3475   /* Doesn't change lcid, even if non default sublang/sort used */
3476   TEST_LCID(LANG_ENGLISH,  SUBLANG_ENGLISH_US, SORT_DEFAULT);
3477   TEST_LCID(LANG_ENGLISH,  SUBLANG_ENGLISH_UK, SORT_DEFAULT);
3478   TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT,    SORT_DEFAULT);
3479   TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT,    SORT_JAPANESE_UNICODE);
3480
3481   /* SUBLANG_NEUTRAL -> SUBLANG_DEFAULT */
3482   LCID_RES(MKLCID(LANG_ENGLISH,  SUBLANG_NEUTRAL, SORT_DEFAULT),
3483            MKLCID(LANG_ENGLISH,  SUBLANG_DEFAULT, SORT_DEFAULT));
3484   LCID_RES(MKLCID(LANG_JAPANESE, SUBLANG_NEUTRAL, SORT_DEFAULT),
3485            MKLCID(LANG_JAPANESE, SUBLANG_DEFAULT, SORT_DEFAULT));
3486
3487   /* Invariant language is not treated specially */
3488   TEST_LCID(LANG_INVARIANT, SUBLANG_DEFAULT, SORT_DEFAULT);
3489
3490   /* User/system default languages alone are not mapped */
3491   TEST_LCIDLANG(LANG_SYSTEM_DEFAULT, SORT_JAPANESE_UNICODE);
3492   TEST_LCIDLANG(LANG_USER_DEFAULT,   SORT_JAPANESE_UNICODE);
3493
3494   /* Default lcids */
3495   LCID_RES(LOCALE_SYSTEM_DEFAULT, GetSystemDefaultLCID());
3496   LCID_RES(LOCALE_USER_DEFAULT,   GetUserDefaultLCID());
3497   LCID_RES(LOCALE_NEUTRAL,        GetUserDefaultLCID());
3498   lcid = ConvertDefaultLocale(LOCALE_INVARIANT);
3499   ok(lcid == LOCALE_INVARIANT || broken(lcid == 0x47f) /* win2k[3]/winxp */,
3500      "Expected lcid = %08x, got %08x\n", LOCALE_INVARIANT, lcid);
3501 }
3502
3503 static BOOL CALLBACK langgrp_procA(LGRPID lgrpid, LPSTR lpszNum, LPSTR lpszName,
3504                                     DWORD dwFlags, LONG_PTR lParam)
3505 {
3506   if (winetest_debug > 1)
3507     trace("%08x, %s, %s, %08x, %08lx\n",
3508           lgrpid, lpszNum, lpszName, dwFlags, lParam);
3509
3510   ok(pIsValidLanguageGroup(lgrpid, dwFlags) == TRUE,
3511      "Enumerated grp %d not valid (flags %d)\n", lgrpid, dwFlags);
3512
3513   /* If lParam is one, we are calling with flags defaulted from 0 */
3514   ok(!lParam || (dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED),
3515          "Expected dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED, got %d\n", dwFlags);
3516
3517   return TRUE;
3518 }
3519
3520 static void test_EnumSystemLanguageGroupsA(void)
3521 {
3522   BOOL ret;
3523
3524   if (!pEnumSystemLanguageGroupsA || !pIsValidLanguageGroup)
3525   {
3526     win_skip("EnumSystemLanguageGroupsA and/or IsValidLanguageGroup are not available\n");
3527     return;
3528   }
3529
3530   /* No enumeration proc */
3531   SetLastError(0);
3532   ret = pEnumSystemLanguageGroupsA(0, LGRPID_INSTALLED, 0);
3533   if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3534   {
3535     win_skip("EnumSystemLanguageGroupsA is not implemented\n");
3536     return;
3537   }
3538   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3539       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3540
3541   /* Invalid flags */
3542   SetLastError(0);
3543   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED|LGRPID_SUPPORTED, 0);
3544   ok(GetLastError() == ERROR_INVALID_FLAGS, "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
3545
3546   /* No flags - defaults to LGRPID_INSTALLED */
3547   SetLastError(0xdeadbeef);
3548   pEnumSystemLanguageGroupsA(langgrp_procA, 0, 1);
3549   ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
3550
3551   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED, 0);
3552   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_SUPPORTED, 0);
3553 }
3554
3555 static BOOL CALLBACK enum_func( LPWSTR name, DWORD flags, LPARAM lparam )
3556 {
3557     if (winetest_debug > 1)
3558         trace( "%s %x\n", wine_dbgstr_w(name), flags );
3559     return TRUE;
3560 }
3561
3562 static void test_EnumSystemLocalesEx(void)
3563 {
3564     BOOL ret;
3565
3566     if (!pEnumSystemLocalesEx)
3567     {
3568         win_skip( "EnumSystemLocalesEx not available\n" );
3569         return;
3570     }
3571     SetLastError( 0xdeadbeef );
3572     ret = pEnumSystemLocalesEx( enum_func, LOCALE_ALL, 0, (void *)1 );
3573     ok( !ret, "should have failed\n" );
3574     ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
3575     SetLastError( 0xdeadbeef );
3576     ret = pEnumSystemLocalesEx( enum_func, 0, 0, NULL );
3577     ok( ret, "failed err %u\n", GetLastError() );
3578 }
3579
3580 static BOOL CALLBACK lgrplocale_procA(LGRPID lgrpid, LCID lcid, LPSTR lpszNum,
3581                                       LONG_PTR lParam)
3582 {
3583   if (winetest_debug > 1)
3584     trace("%08x, %08x, %s, %08lx\n", lgrpid, lcid, lpszNum, lParam);
3585
3586   /* invalid locale enumerated on some platforms */
3587   if (lcid == 0)
3588       return TRUE;
3589
3590   ok(pIsValidLanguageGroup(lgrpid, LGRPID_SUPPORTED) == TRUE,
3591      "Enumerated grp %d not valid\n", lgrpid);
3592   ok(IsValidLocale(lcid, LCID_SUPPORTED) == TRUE,
3593      "Enumerated grp locale %04x not valid\n", lcid);
3594   return TRUE;
3595 }
3596
3597 static void test_EnumLanguageGroupLocalesA(void)
3598 {
3599   BOOL ret;
3600
3601   if (!pEnumLanguageGroupLocalesA || !pIsValidLanguageGroup)
3602   {
3603     win_skip("EnumLanguageGroupLocalesA and/or IsValidLanguageGroup are not available\n");
3604     return;
3605   }
3606
3607   /* No enumeration proc */
3608   SetLastError(0);
3609   ret = pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0, 0);
3610   if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3611   {
3612     win_skip("EnumLanguageGroupLocalesA is not implemented\n");
3613     return;
3614   }
3615   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3616       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3617
3618   /* lgrpid too small */
3619   SetLastError(0);
3620   ret = pEnumLanguageGroupLocalesA(lgrplocale_procA, 0, 0, 0);
3621   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3622       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3623
3624   /* lgrpid too big */
3625   SetLastError(0);
3626   ret = pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_ARMENIAN + 1, 0, 0);
3627   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3628       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3629
3630   /* dwFlags is reserved */
3631   SetLastError(0);
3632   ret = pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0x1, 0);
3633   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
3634       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3635
3636   pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_WESTERN_EUROPE, 0, 0);
3637 }
3638
3639 static void test_SetLocaleInfoA(void)
3640 {
3641   BOOL bRet;
3642   LCID lcid = GetUserDefaultLCID();
3643
3644   /* Null data */
3645   SetLastError(0);
3646   bRet = SetLocaleInfoA(lcid, LOCALE_SDATE, 0);
3647   ok( !bRet && GetLastError() == ERROR_INVALID_PARAMETER,
3648       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3649
3650   /* IDATE */
3651   SetLastError(0);
3652   bRet = SetLocaleInfoA(lcid, LOCALE_IDATE, "test_SetLocaleInfoA");
3653   ok(!bRet && GetLastError() == ERROR_INVALID_FLAGS,
3654      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
3655
3656   /* ILDATE */
3657   SetLastError(0);
3658   bRet = SetLocaleInfoA(lcid, LOCALE_ILDATE, "test_SetLocaleInfoA");
3659   ok(!bRet && GetLastError() == ERROR_INVALID_FLAGS,
3660      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
3661 }
3662
3663 static BOOL CALLBACK luilocale_proc1A(LPSTR value, LONG_PTR lParam)
3664 {
3665   if (winetest_debug > 1)
3666     trace("%s %08lx\n", value, lParam);
3667   return(TRUE);
3668 }
3669
3670 static BOOL CALLBACK luilocale_proc2A(LPSTR value, LONG_PTR lParam)
3671 {
3672   ok(!enumCount, "callback called again unexpected\n");
3673   enumCount++;
3674   return(FALSE);
3675 }
3676
3677 static BOOL CALLBACK luilocale_proc3A(LPSTR value, LONG_PTR lParam)
3678 {
3679   ok(0,"callback called unexpected\n");
3680   return(FALSE);
3681 }
3682
3683 static void test_EnumUILanguageA(void)
3684 {
3685   BOOL ret;
3686   if (!pEnumUILanguagesA) {
3687     win_skip("EnumUILanguagesA is not available on Win9x or NT4\n");
3688     return;
3689   }
3690
3691   SetLastError(ERROR_SUCCESS);
3692   ret = pEnumUILanguagesA(luilocale_proc1A, 0, 0);
3693   if (ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
3694   {
3695     win_skip("EnumUILanguagesA is not implemented\n");
3696     return;
3697   }
3698   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
3699
3700   enumCount = 0;
3701   SetLastError(ERROR_SUCCESS);
3702   ret = pEnumUILanguagesA(luilocale_proc2A, 0, 0);
3703   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
3704
3705   SetLastError(ERROR_SUCCESS);
3706   ret = pEnumUILanguagesA(NULL, 0, 0);
3707   ok(!ret, "Expected return value FALSE, got %u\n", ret);
3708   ok(GetLastError() == ERROR_INVALID_PARAMETER,
3709       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3710
3711   SetLastError(ERROR_SUCCESS);
3712   ret = pEnumUILanguagesA(luilocale_proc3A, 0x5a5a5a5a, 0);
3713   ok(!ret, "Expected return value FALSE, got %u\n", ret);
3714   ok(GetLastError() == ERROR_INVALID_FLAGS, "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
3715
3716   SetLastError(ERROR_SUCCESS);
3717   ret = pEnumUILanguagesA(NULL, 0x5a5a5a5a, 0);
3718   ok(!ret, "Expected return value FALSE, got %u\n", ret);
3719   ok(GetLastError() == ERROR_INVALID_PARAMETER,
3720       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
3721 }
3722
3723 static char date_fmt_buf[1024];
3724 static WCHAR date_fmt_bufW[1024];
3725
3726 static BOOL CALLBACK enum_datetime_procA(LPSTR fmt)
3727 {
3728     lstrcatA(date_fmt_buf, fmt);
3729     lstrcatA(date_fmt_buf, "\n");
3730     return TRUE;
3731 }
3732
3733 static BOOL CALLBACK enum_datetime_procW(WCHAR *fmt)
3734 {
3735     lstrcatW(date_fmt_bufW, fmt);
3736     return FALSE;
3737 }
3738
3739 static void test_EnumDateFormatsA(void)
3740 {
3741     char *p, buf[256];
3742     BOOL ret;
3743     LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
3744
3745     date_fmt_buf[0] = 0;
3746     SetLastError(0xdeadbeef);
3747     ret = EnumDateFormatsA(enum_datetime_procA, lcid, 0);
3748     if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
3749     {
3750         win_skip("0 for dwFlags is not supported\n");
3751     }
3752     else
3753     {
3754         ok(ret, "EnumDateFormatsA(0) error %d\n", GetLastError());
3755         trace("EnumDateFormatsA(0): %s\n", date_fmt_buf);
3756         /* test the 1st enumerated format */
3757         if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
3758         ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
3759         ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
3760         ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
3761     }
3762
3763     date_fmt_buf[0] = 0;
3764     SetLastError(0xdeadbeef);
3765     ret = EnumDateFormatsA(enum_datetime_procA, lcid, LOCALE_USE_CP_ACP);
3766     if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
3767     {
3768         win_skip("LOCALE_USE_CP_ACP is not supported\n");
3769     }
3770     else
3771     {
3772         ok(ret, "EnumDateFormatsA(LOCALE_USE_CP_ACP) error %d\n", GetLastError());
3773         trace("EnumDateFormatsA(LOCALE_USE_CP_ACP): %s\n", date_fmt_buf);
3774         /* test the 1st enumerated format */
3775         if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
3776         ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
3777         ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
3778         ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
3779     }
3780
3781     date_fmt_buf[0] = 0;
3782     ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_SHORTDATE);
3783     ok(ret, "EnumDateFormatsA(DATE_SHORTDATE) error %d\n", GetLastError());
3784     trace("EnumDateFormatsA(DATE_SHORTDATE): %s\n", date_fmt_buf);
3785     /* test the 1st enumerated format */
3786     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
3787     ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
3788     ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
3789     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
3790
3791     date_fmt_buf[0] = 0;
3792     ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_LONGDATE);
3793     ok(ret, "EnumDateFormatsA(DATE_LONGDATE) error %d\n", GetLastError());
3794     trace("EnumDateFormatsA(DATE_LONGDATE): %s\n", date_fmt_buf);
3795     /* test the 1st enumerated format */
3796     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
3797     ret = GetLocaleInfoA(lcid, LOCALE_SLONGDATE, buf, sizeof(buf));
3798     ok(ret, "GetLocaleInfoA(LOCALE_SLONGDATE) error %d\n", GetLastError());
3799     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
3800
3801     date_fmt_buf[0] = 0;
3802     SetLastError(0xdeadbeef);
3803     ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_YEARMONTH);
3804     if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
3805     {
3806         win_skip("DATE_YEARMONTH is only present on W2K and later\n");
3807         return;
3808     }
3809     ok(ret, "EnumDateFormatsA(DATE_YEARMONTH) error %d\n", GetLastError());
3810     trace("EnumDateFormatsA(DATE_YEARMONTH): %s\n", date_fmt_buf);
3811     /* test the 1st enumerated format */
3812     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
3813     ret = GetLocaleInfoA(lcid, LOCALE_SYEARMONTH, buf, sizeof(buf));
3814     ok(ret, "GetLocaleInfoA(LOCALE_SYEARMONTH) error %d\n", GetLastError());
3815     ok(!lstrcmpA(date_fmt_buf, buf) || broken(!buf[0]) /* win9x */,
3816        "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
3817 }
3818
3819 static void test_EnumTimeFormatsA(void)
3820 {
3821     char *p, buf[256];
3822     BOOL ret;
3823     LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
3824
3825     date_fmt_buf[0] = 0;
3826     ret = EnumTimeFormatsA(enum_datetime_procA, lcid, 0);
3827     ok(ret, "EnumTimeFormatsA(0) error %d\n", GetLastError());
3828     trace("EnumTimeFormatsA(0): %s\n", date_fmt_buf);
3829     /* test the 1st enumerated format */
3830     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
3831     ret = GetLocaleInfoA(lcid, LOCALE_STIMEFORMAT, buf, sizeof(buf));
3832     ok(ret, "GetLocaleInfoA(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
3833     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
3834
3835     date_fmt_buf[0] = 0;
3836     ret = EnumTimeFormatsA(enum_datetime_procA, lcid, LOCALE_USE_CP_ACP);
3837     ok(ret, "EnumTimeFormatsA(LOCALE_USE_CP_ACP) error %d\n", GetLastError());
3838     trace("EnumTimeFormatsA(LOCALE_USE_CP_ACP): %s\n", date_fmt_buf);
3839     /* test the 1st enumerated format */
3840     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
3841     ret = GetLocaleInfoA(lcid, LOCALE_STIMEFORMAT, buf, sizeof(buf));
3842     ok(ret, "GetLocaleInfoA(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
3843     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
3844 }
3845
3846 static void test_EnumTimeFormatsW(void)
3847 {
3848     LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
3849     WCHAR bufW[256];
3850     BOOL ret;
3851
3852     date_fmt_bufW[0] = 0;
3853     ret = EnumTimeFormatsW(enum_datetime_procW, lcid, 0);
3854     ok(ret, "EnumTimeFormatsW(0) error %d\n", GetLastError());
3855     ret = GetLocaleInfoW(lcid, LOCALE_STIMEFORMAT, bufW, sizeof(bufW)/sizeof(bufW[0]));
3856     ok(ret, "GetLocaleInfoW(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
3857     ok(!lstrcmpW(date_fmt_bufW, bufW), "expected \"%s\" got \"%s\"\n", wine_dbgstr_w(date_fmt_bufW),
3858         wine_dbgstr_w(bufW));
3859
3860     date_fmt_bufW[0] = 0;
3861     ret = EnumTimeFormatsW(enum_datetime_procW, lcid, LOCALE_USE_CP_ACP);
3862     ok(ret, "EnumTimeFormatsW(LOCALE_USE_CP_ACP) error %d\n", GetLastError());
3863     ret = GetLocaleInfoW(lcid, LOCALE_STIMEFORMAT, bufW, sizeof(bufW)/sizeof(bufW[0]));
3864     ok(ret, "GetLocaleInfoW(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
3865     ok(!lstrcmpW(date_fmt_bufW, bufW), "expected \"%s\" got \"%s\"\n", wine_dbgstr_w(date_fmt_bufW),
3866         wine_dbgstr_w(bufW));
3867
3868     /* TIME_NOSECONDS is Win7+ feature */
3869     date_fmt_bufW[0] = 0;
3870     ret = EnumTimeFormatsW(enum_datetime_procW, lcid, TIME_NOSECONDS);
3871     if (!ret && GetLastError() == ERROR_INVALID_FLAGS)
3872         win_skip("EnumTimeFormatsW doesn't support TIME_NOSECONDS\n");
3873     else {
3874         char buf[256];
3875
3876         ok(ret, "EnumTimeFormatsW(TIME_NOSECONDS) error %d\n", GetLastError());
3877         ret = GetLocaleInfoW(lcid, LOCALE_SSHORTTIME, bufW, sizeof(bufW)/sizeof(bufW[0]));
3878         ok(ret, "GetLocaleInfoW(LOCALE_SSHORTTIME) error %d\n", GetLastError());
3879         ok(!lstrcmpW(date_fmt_bufW, bufW), "expected \"%s\" got \"%s\"\n", wine_dbgstr_w(date_fmt_bufW),
3880             wine_dbgstr_w(bufW));
3881
3882         /* EnumTimeFormatsA doesn't support this flag */
3883         ret = EnumTimeFormatsA(enum_datetime_procA, lcid, TIME_NOSECONDS);
3884         ok(!ret && GetLastError() == ERROR_INVALID_FLAGS, "EnumTimeFormatsA(TIME_NOSECONDS) ret %d, error %d\n", ret,
3885             GetLastError());
3886
3887         ret = EnumTimeFormatsA(NULL, lcid, TIME_NOSECONDS);
3888         ok(!ret && GetLastError() == ERROR_INVALID_FLAGS, "EnumTimeFormatsA(TIME_NOSECONDS) ret %d, error %d\n", ret,
3889             GetLastError());
3890
3891         /* And it's not supported by GetLocaleInfoA either */
3892         ret = GetLocaleInfoA(lcid, LOCALE_SSHORTTIME, buf, sizeof(buf)/sizeof(buf[0]));
3893         ok(!ret && GetLastError() == ERROR_INVALID_FLAGS, "GetLocaleInfoA(LOCALE_SSHORTTIME) ret %d, error %d\n", ret,
3894             GetLastError());
3895     }
3896 }
3897 static void test_GetCPInfo(void)
3898 {
3899     BOOL ret;
3900     CPINFO cpinfo;
3901
3902     SetLastError(0xdeadbeef);
3903     ret = GetCPInfo(CP_SYMBOL, &cpinfo);
3904     ok(!ret, "GetCPInfo(CP_SYMBOL) should fail\n");
3905     ok(GetLastError() == ERROR_INVALID_PARAMETER,
3906        "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
3907
3908     SetLastError(0xdeadbeef);
3909     ret = GetCPInfo(CP_UTF7, &cpinfo);
3910     if (!ret && GetLastError() == ERROR_INVALID_PARAMETER)
3911     {
3912         win_skip("Codepage CP_UTF7 is not installed/available\n");
3913     }
3914     else
3915     {
3916         ok(ret, "GetCPInfo(CP_UTF7) error %u\n", GetLastError());
3917         ok(cpinfo.DefaultChar[0] == 0x3f, "expected 0x3f, got 0x%x\n", cpinfo.DefaultChar[0]);
3918         ok(cpinfo.DefaultChar[1] == 0, "expected 0, got 0x%x\n", cpinfo.DefaultChar[1]);
3919         ok(cpinfo.LeadByte[0] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[0]);
3920         ok(cpinfo.LeadByte[1] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[1]);
3921         ok(cpinfo.MaxCharSize == 5, "expected 5, got 0x%x\n", cpinfo.MaxCharSize);
3922     }
3923
3924     SetLastError(0xdeadbeef);
3925     ret = GetCPInfo(CP_UTF8, &cpinfo);
3926     if (!ret && GetLastError() == ERROR_INVALID_PARAMETER)
3927     {
3928         win_skip("Codepage CP_UTF8 is not installed/available\n");
3929     }
3930     else
3931     {
3932         ok(ret, "GetCPInfo(CP_UTF8) error %u\n", GetLastError());
3933         ok(cpinfo.DefaultChar[0] == 0x3f, "expected 0x3f, got 0x%x\n", cpinfo.DefaultChar[0]);
3934         ok(cpinfo.DefaultChar[1] == 0, "expected 0, got 0x%x\n", cpinfo.DefaultChar[1]);
3935         ok(cpinfo.LeadByte[0] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[0]);
3936         ok(cpinfo.LeadByte[1] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[1]);
3937         ok(cpinfo.MaxCharSize == 4 || broken(cpinfo.MaxCharSize == 3) /* win9x */,
3938            "expected 4, got %u\n", cpinfo.MaxCharSize);
3939     }
3940 }
3941
3942 /*
3943  * The CT_TYPE1 has varied over windows version.
3944  * The current target for correct behavior is windows 7.
3945  * There was a big shift between windows 2000 (first introduced) and windows Xp
3946  * Most of the old values below are from windows 2000.
3947  * A smaller subset of changes happened between windows Xp and Window vista/7
3948  */
3949 static void test_GetStringTypeW(void)
3950 {
3951     static const WCHAR blanks[] = {0x9, 0x20, 0xa0, 0x3000, 0xfeff};
3952     static const WORD blanks_new[] = {C1_SPACE | C1_CNTRL | C1_BLANK | C1_DEFINED,
3953                                  C1_SPACE | C1_BLANK | C1_DEFINED,
3954                                  C1_SPACE | C1_BLANK | C1_DEFINED,
3955                                  C1_SPACE | C1_BLANK | C1_DEFINED,
3956                                  C1_CNTRL | C1_BLANK | C1_DEFINED};
3957     static const WORD blanks_old[] ={C1_SPACE | C1_CNTRL | C1_BLANK,
3958                                     C1_SPACE | C1_BLANK,
3959                                     C1_SPACE | C1_BLANK,
3960                                     C1_SPACE | C1_BLANK,
3961                                     C1_SPACE | C1_BLANK};
3962
3963     static const WCHAR undefined[] = {0x378, 0x379, 0x5ff, 0xfff8, 0xfffe};
3964
3965                                   /* Lu, Ll, Lt */
3966     static const WCHAR alpha[] = {0x47, 0x67, 0x1c5};
3967     static const WORD alpha_old[] = {C1_UPPER | C1_ALPHA,
3968                                      C1_LOWER | C1_ALPHA,
3969                                      C1_UPPER | C1_LOWER | C1_ALPHA,
3970                                      C1_ALPHA};
3971
3972                                   /* Sk, Sk, Mn, So, Me */
3973     static const WCHAR oldpunc[] = { 0x2c2, 0x2e5, 0x322, 0x482, 0x6de,
3974                                  /* Sc, Sm, No,*/
3975                                      0xffe0, 0xffe9, 0x2153};
3976
3977                                 /* Lm, Nl, Cf, 0xad(Cf), 0x1f88 (Lt), Lo, Mc */
3978     static const WCHAR changed[] = {0x2b0, 0x2160, 0x600, 0xad, 0x1f88, 0x294, 0x903};
3979     static const WORD changed_old[] = { C1_PUNCT, C1_PUNCT, 0, C1_PUNCT, C1_UPPER | C1_ALPHA, C1_ALPHA, C1_PUNCT };
3980     static const WORD changed_xp[] = {C1_ALPHA | C1_DEFINED,
3981                                       C1_ALPHA | C1_DEFINED,
3982                                       C1_CNTRL | C1_DEFINED,
3983                                       C1_PUNCT | C1_DEFINED,
3984                                       C1_UPPER | C1_LOWER | C1_ALPHA | C1_DEFINED,
3985                                       C1_ALPHA | C1_LOWER | C1_DEFINED,
3986                                       C1_ALPHA | C1_DEFINED };
3987     static const WORD changed_new[] = { C1_ALPHA | C1_DEFINED,
3988                                       C1_ALPHA | C1_DEFINED,
3989                                       C1_CNTRL | C1_DEFINED,
3990                                       C1_PUNCT | C1_CNTRL | C1_DEFINED,
3991                                       C1_UPPER | C1_LOWER | C1_ALPHA | C1_DEFINED,
3992                                       C1_ALPHA | C1_DEFINED,
3993                                       C1_DEFINED
3994  };
3995                                 /* Pc,  Pd, Ps, Pe, Pi, Pf, Po*/
3996     static const WCHAR punct[] = { 0x5f, 0x2d, 0x28, 0x29, 0xab, 0xbb, 0x21 };
3997
3998     static const WCHAR punct_special[] = {0x24, 0x2b, 0x3c, 0x3e, 0x5e, 0x60,
3999                                           0x7c, 0x7e, 0xa2, 0xbe, 0xd7, 0xf7};
4000     static const WCHAR digit_special[] = {0xb2, 0xb3, 0xb9};
4001     static const WCHAR lower_special[] = {0x2071, 0x207f};
4002     static const WCHAR cntrl_special[] = {0x070f, 0x200c, 0x200d,
4003                   0x200e, 0x200f, 0x202a, 0x202b, 0x202c, 0x202d, 0x202e,
4004                   0x206a, 0x206b, 0x206c, 0x206d, 0x206e, 0x206f, 0xfeff,
4005                   0xfff9, 0xfffa, 0xfffb};
4006     static const WCHAR space_special[] = {0x09, 0x0d, 0x85};
4007
4008     WORD types[20];
4009     WCHAR ch[2];
4010     BOOL ret;
4011     int i;
4012
4013     /* NULL src */
4014     SetLastError(0xdeadbeef);
4015     ret = GetStringTypeW(CT_CTYPE1, NULL, 0, NULL);
4016     ok(!ret, "got %d\n", ret);
4017     ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %d\n", GetLastError());
4018
4019     SetLastError(0xdeadbeef);
4020     ret = GetStringTypeW(CT_CTYPE1, NULL, 0, types);
4021     ok(!ret, "got %d\n", ret);
4022     ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %d\n", GetLastError());
4023
4024     SetLastError(0xdeadbeef);
4025     ret = GetStringTypeW(CT_CTYPE1, NULL, 5, types);
4026     ok(!ret, "got %d\n", ret);
4027     ok(GetLastError() == ERROR_INVALID_PARAMETER, "got error %d\n", GetLastError());
4028
4029     memset(types,0,sizeof(types));
4030     GetStringTypeW(CT_CTYPE1, blanks, 5, types);
4031     for (i = 0; i < 5; i++)
4032         ok(types[i] == blanks_new[i] || broken(types[i] == blanks_old[i] || broken(types[i] == 0)), "incorrect type1 returned for %x -> (%x != %x)\n",blanks[i],types[i],blanks_new[i]);
4033
4034     memset(types,0,sizeof(types));
4035     GetStringTypeW(CT_CTYPE1, alpha, 3, types);
4036     for (i = 0; i < 3; i++)
4037         ok(types[i] == (C1_DEFINED | alpha_old[i]) || broken(types[i] == alpha_old[i]) || broken(types[i] == 0), "incorrect types returned for %x -> (%x != %x)\n",alpha[i], types[i],(C1_DEFINED | alpha_old[i]));
4038     memset(types,0,sizeof(types));
4039     GetStringTypeW(CT_CTYPE1, undefined, 5, types);
4040     for (i = 0; i < 5; i++)
4041         ok(types[i] == 0, "incorrect types returned for %x -> (%x != 0)\n",undefined[i], types[i]);
4042
4043     memset(types,0,sizeof(types));
4044     GetStringTypeW(CT_CTYPE1, oldpunc, 8, types);
4045     for (i = 0; i < 8; i++)
4046         ok(types[i] == C1_DEFINED || broken(types[i] == C1_PUNCT) || broken(types[i] == 0), "incorrect types returned for %x -> (%x != %x)\n",oldpunc[i], types[i], C1_DEFINED);
4047
4048     memset(types,0,sizeof(types));
4049     GetStringTypeW(CT_CTYPE1, changed, 7, types);
4050     for (i = 0; i < 7; i++)
4051         ok(types[i] == changed_new[i] || broken(types[i] == changed_old[i]) || broken(types[i] == changed_xp[i]) || broken(types[i] == 0), "incorrect types returned for %x -> (%x != %x)\n",changed[i], types[i], changed_new[i]);
4052
4053     memset(types,0,sizeof(types));
4054     GetStringTypeW(CT_CTYPE1, punct, 7, types);
4055     for (i = 0; i < 7; i++)
4056         ok(types[i] == (C1_PUNCT | C1_DEFINED) || broken(types[i] == C1_PUNCT) || broken(types[i] == 0), "incorrect types returned for %x -> (%x != %x)\n",punct[i], types[i], (C1_PUNCT | C1_DEFINED));
4057
4058
4059     memset(types,0,sizeof(types));
4060     GetStringTypeW(CT_CTYPE1, punct_special, 12, types);
4061     for (i = 0; i < 12; i++)
4062         ok(types[i]  & C1_PUNCT || broken(types[i] == 0), "incorrect types returned for %x -> (%x doest not have %x)\n",punct_special[i], types[i], C1_PUNCT);
4063
4064     memset(types,0,sizeof(types));
4065     GetStringTypeW(CT_CTYPE1, digit_special, 3, types);
4066     for (i = 0; i < 3; i++)
4067         ok(types[i] & C1_DIGIT || broken(types[i] == 0), "incorrect types returned for %x -> (%x doest not have = %x)\n",digit_special[i], types[i], C1_DIGIT);
4068
4069     memset(types,0,sizeof(types));
4070     GetStringTypeW(CT_CTYPE1, lower_special, 2, types);
4071     for (i = 0; i < 2; i++)
4072         ok(types[i] & C1_LOWER || broken(types[i] == C1_PUNCT) || broken(types[i] == 0), "incorrect types returned for %x -> (%x does not have %x)\n",lower_special[i], types[i], C1_LOWER);
4073
4074     memset(types,0,sizeof(types));
4075     GetStringTypeW(CT_CTYPE1, cntrl_special, 20, types);
4076     for (i = 0; i < 20; i++)
4077         ok(types[i] & C1_CNTRL || broken(types[i] == (C1_BLANK|C1_SPACE)) || broken(types[i] == C1_PUNCT) || broken(types[i] == 0), "incorrect types returned for %x -> (%x does not have %x)\n",cntrl_special[i], types[i], C1_CNTRL);
4078
4079     memset(types,0,sizeof(types));
4080     GetStringTypeW(CT_CTYPE1, space_special, 3, types);
4081     for (i = 0; i < 3; i++)
4082         ok(types[i] & C1_SPACE || broken(types[i] == C1_CNTRL) || broken(types[i] == 0), "incorrect types returned for %x -> (%x does not have %x)\n",space_special[i], types[i], C1_SPACE );
4083
4084     /* surrogate pairs */
4085     ch[0] = 0xd800;
4086     memset(types, 0, sizeof(types));
4087     GetStringTypeW(CT_CTYPE3, ch, 1, types);
4088     if (types[0] == C3_NOTAPPLICABLE)
4089         win_skip("C3_HIGHSURROGATE/C3_LOWSURROGATE are not supported.\n");
4090     else {
4091         ok(types[0] == C3_HIGHSURROGATE, "got %x\n", types[0]);
4092
4093         ch[0] = 0xdc00;
4094         memset(types, 0, sizeof(types));
4095         GetStringTypeW(CT_CTYPE3, ch, 1, types);
4096         ok(types[0] == C3_LOWSURROGATE, "got %x\n", types[0]);
4097     }
4098
4099     /* Zl, Zp categories */
4100     ch[0] = 0x2028;
4101     ch[1] = 0x2029;
4102     memset(types, 0, sizeof(types));
4103     GetStringTypeW(CT_CTYPE1, ch, 2, types);
4104     ok(types[0] == (C1_DEFINED|C1_SPACE), "got %x\n", types[0]);
4105     ok(types[1] == (C1_DEFINED|C1_SPACE), "got %x\n", types[1]);
4106
4107     /* check Arabic range for kashida flag */
4108     for (ch[0] = 0x600; ch[0] <= 0x6ff; ch[0] += 1)
4109     {
4110         types[0] = 0;
4111         ret = GetStringTypeW(CT_CTYPE3, ch, 1, types);
4112         ok(ret, "%#x: failed %d\n", ch[0], ret);
4113         if (ch[0] == 0x640) /* ARABIC TATWEEL (Kashida) */
4114             ok(types[0] & C3_KASHIDA, "%#x: type %#x\n", ch[0], types[0]);
4115         else
4116             ok(!(types[0] & C3_KASHIDA), "%#x: type %#x\n", ch[0], types[0]);
4117     }
4118 }
4119
4120 static void test_IdnToNameprepUnicode(void)
4121 {
4122     struct {
4123         DWORD in_len;
4124         const WCHAR in[64];
4125         DWORD ret;
4126         DWORD broken_ret;
4127         const WCHAR out[64];
4128         DWORD flags;
4129         DWORD err;
4130         DWORD todo;
4131     } test_data[] = {
4132         {
4133             5, {'t','e','s','t',0},
4134             5, 5, {'t','e','s','t',0},
4135             0, 0xdeadbeef
4136         },
4137         {
4138             3, {'a',0xe111,'b'},
4139             0, 0, {0},
4140             0, ERROR_INVALID_NAME
4141         },
4142         {
4143             4, {'t',0,'e',0},
4144             0, 0, {0},
4145             0, ERROR_INVALID_NAME
4146         },
4147         {
4148             1, {'T',0},
4149             1, 1, {'T',0},
4150             0, 0xdeadbeef
4151         },
4152         {
4153             1, {0},
4154             0, 0, {0},
4155             0, ERROR_INVALID_NAME
4156         },
4157         {
4158             6, {' ','-','/','[',']',0},
4159             6, 6, {' ','-','/','[',']',0},
4160             0, 0xdeadbeef
4161         },
4162         {
4163             3, {'a','-','a'},
4164             3, 3, {'a','-','a'},
4165             IDN_USE_STD3_ASCII_RULES, 0xdeadbeef
4166         },
4167         {
4168             3, {'a','a','-'},
4169             0, 0, {0},
4170             IDN_USE_STD3_ASCII_RULES, ERROR_INVALID_NAME
4171         },
4172         { /* FoldString is not working as expected when MAP_FOLDCZONE is specified (composition+compatibility) */
4173             10, {'T',0xdf,0x130,0x143,0x37a,0x6a,0x30c,' ',0xaa,0},
4174             12, 12, {'t','s','s','i',0x307,0x144,' ',0x3b9,0x1f0,' ','a',0},
4175             0, 0xdeadbeef, TRUE
4176         },
4177         {
4178             11, {'t',0xad,0x34f,0x1806,0x180b,0x180c,0x180d,0x200b,0x200c,0x200d,0},
4179             2, 0, {'t',0},
4180             0, 0xdeadbeef
4181         },
4182         { /* Another example of incorrectly working FoldString (composition) */
4183             2, {0x3b0, 0},
4184             2, 2, {0x3b0, 0},
4185             0, 0xdeadbeef, TRUE
4186         },
4187         {
4188             2, {0x221, 0},
4189             0, 2, {0},
4190             0, ERROR_NO_UNICODE_TRANSLATION
4191         },
4192         {
4193             2, {0x221, 0},
4194             2, 2, {0x221, 0},
4195             IDN_ALLOW_UNASSIGNED, 0xdeadbeef
4196         },
4197         {
4198             5, {'a','.','.','a',0},
4199             0, 0, {0},
4200             0, ERROR_INVALID_NAME
4201         },
4202         {
4203             3, {'a','.',0},
4204             3, 3, {'a','.',0},
4205             0, 0xdeadbeef
4206         },
4207     };
4208
4209     WCHAR buf[1024];
4210     DWORD i, ret, err;
4211
4212     if (!pIdnToNameprepUnicode)
4213     {
4214         win_skip("IdnToNameprepUnicode is not available\n");
4215         return;
4216     }
4217
4218     ret = pIdnToNameprepUnicode(0, test_data[0].in,
4219             test_data[0].in_len, NULL, 0);
4220     ok(ret == test_data[0].ret, "ret = %d\n", ret);
4221
4222     SetLastError(0xdeadbeef);
4223     ret = pIdnToNameprepUnicode(0, test_data[1].in,
4224             test_data[1].in_len, NULL, 0);
4225     err = GetLastError();
4226     ok(ret == test_data[1].ret, "ret = %d\n", ret);
4227     ok(err == test_data[1].err, "err = %d\n", err);
4228
4229     SetLastError(0xdeadbeef);
4230     ret = pIdnToNameprepUnicode(0, test_data[0].in, -1,
4231             buf, sizeof(buf)/sizeof(WCHAR));
4232     err = GetLastError();
4233     ok(ret == test_data[0].ret, "ret = %d\n", ret);
4234     ok(err == 0xdeadbeef, "err = %d\n", err);
4235
4236     SetLastError(0xdeadbeef);
4237     ret = pIdnToNameprepUnicode(0, test_data[0].in, -2,
4238             buf, sizeof(buf)/sizeof(WCHAR));
4239     err = GetLastError();
4240     ok(ret == 0, "ret = %d\n", ret);
4241     ok(err == ERROR_INVALID_PARAMETER, "err = %d\n", err);
4242
4243     SetLastError(0xdeadbeef);
4244     ret = pIdnToNameprepUnicode(0, test_data[0].in, 0,
4245             buf, sizeof(buf)/sizeof(WCHAR));
4246     err = GetLastError();
4247     ok(ret == 0, "ret = %d\n", ret);
4248     ok(err == ERROR_INVALID_NAME, "err = %d\n", err);
4249
4250     ret = pIdnToNameprepUnicode(IDN_ALLOW_UNASSIGNED|IDN_USE_STD3_ASCII_RULES,
4251             test_data[0].in, -1, buf, sizeof(buf)/sizeof(WCHAR));
4252     ok(ret == test_data[0].ret, "ret = %d\n", ret);
4253
4254     SetLastError(0xdeadbeef);
4255     ret = pIdnToNameprepUnicode(0, NULL, 0, NULL, 0);
4256     err = GetLastError();
4257     ok(ret == 0, "ret = %d\n", ret);
4258     ok(err == ERROR_INVALID_PARAMETER, "err = %d\n", err);
4259
4260     SetLastError(0xdeadbeef);
4261     ret = pIdnToNameprepUnicode(4, NULL, 0, NULL, 0);
4262     err = GetLastError();
4263     ok(ret == 0, "ret = %d\n", ret);
4264     ok(err == ERROR_INVALID_FLAGS || err == ERROR_INVALID_PARAMETER /* Win8 */,
4265        "err = %d\n", err);
4266
4267     for (i=0; i<sizeof(test_data)/sizeof(*test_data); i++)
4268     {
4269         SetLastError(0xdeadbeef);
4270         ret = pIdnToNameprepUnicode(test_data[i].flags, test_data[i].in,
4271                 test_data[i].in_len, buf, sizeof(buf)/sizeof(WCHAR));
4272         err = GetLastError();
4273
4274         todo_wine_if (test_data[i].todo)
4275             ok(ret == test_data[i].ret ||
4276                     broken(ret == test_data[i].broken_ret), "%d) ret = %d\n", i, ret);
4277
4278         if(ret != test_data[i].ret)
4279             continue;
4280
4281         ok(err == test_data[i].err, "%d) err = %d\n", i, err);
4282         ok(!memcmp(test_data[i].out, buf, ret*sizeof(WCHAR)),
4283                 "%d) buf = %s\n", i, wine_dbgstr_wn(buf, ret));
4284     }
4285 }
4286
4287 static void test_IdnToAscii(void)
4288 {
4289     struct {
4290         DWORD in_len;
4291         const WCHAR in[64];
4292         DWORD ret;
4293         const WCHAR out[64];
4294         DWORD flags;
4295         DWORD err;
4296     } test_data[] = {
4297         {
4298             5, {'T','e','s','t',0},
4299             5, {'T','e','s','t',0},
4300             0, 0xdeadbeef
4301         },
4302         {
4303             5, {'T','e',0x017c,'s','t',0},
4304             12, {'x','n','-','-','t','e','s','t','-','c','b','b',0},
4305             0, 0xdeadbeef
4306         },
4307         {
4308             12, {'t','e',0x0105,'s','t','.','t','e',0x017c,'s','t',0},
4309             26, {'x','n','-','-','t','e','s','t','-','c','t','a','.','x','n','-','-','t','e','s','t','-','c','b','b',0},
4310             0, 0xdeadbeef
4311         },
4312         {
4313             3, {0x0105,'.',0},
4314             9, {'x','n','-','-','2','d','a','.',0},
4315             0, 0xdeadbeef
4316         },
4317         {
4318             10, {'h','t','t','p',':','/','/','t',0x0106,0},
4319             17, {'x','n','-','-','h','t','t','p',':','/','/','t','-','7','8','a',0},
4320             0, 0xdeadbeef
4321         },
4322         {
4323             10, {0x4e3a,0x8bf4,0x4e0d,0x4ed6,0x5011,0x10d,0x11b,0x305c,0x306a,0},
4324             35, {'x','n','-','-','b','e','a','2','a','1','6','3','1','a','v','b','a',
4325                 'v','4','4','t','y','h','a','3','2','b','9','1','e','g','s','2','t',0},
4326             0, 0xdeadbeef
4327         },
4328         {
4329             2, {0x221,0},
4330             8, {'x','n','-','-','6','l','a',0},
4331             IDN_ALLOW_UNASSIGNED, 0xdeadbeef
4332         },
4333     };
4334
4335     WCHAR buf[1024];
4336     DWORD i, ret, err;
4337
4338     if (!pIdnToAscii)
4339     {
4340         win_skip("IdnToAscii is not available\n");
4341         return;
4342     }
4343
4344     for (i=0; i<sizeof(test_data)/sizeof(*test_data); i++)
4345     {
4346         SetLastError(0xdeadbeef);
4347         ret = pIdnToAscii(test_data[i].flags, test_data[i].in,
4348                 test_data[i].in_len, buf, sizeof(buf));
4349         err = GetLastError();
4350         ok(ret == test_data[i].ret, "%d) ret = %d\n", i, ret);
4351         ok(err == test_data[i].err, "%d) err = %d\n", i, err);
4352         ok(!memcmp(test_data[i].out, buf, ret*sizeof(WCHAR)),
4353                 "%d) buf = %s\n", i, wine_dbgstr_wn(buf, ret));
4354     }
4355 }
4356
4357 static void test_IdnToUnicode(void)
4358 {
4359     struct {
4360         DWORD in_len;
4361         const WCHAR in[64];
4362         DWORD ret;
4363         const WCHAR out[64];
4364         DWORD flags;
4365         DWORD err;
4366     } test_data[] = {
4367         {
4368             5, {'T','e','s','.',0},
4369             5, {'T','e','s','.',0},
4370             0, 0xdeadbeef
4371         },
4372         {
4373             2, {0x105,0},
4374             0, {0},
4375             0, ERROR_INVALID_NAME
4376         },
4377         {
4378             33, {'x','n','-','-','4','d','b','c','a','g','d','a','h','y','m','b',
4379                 'x','e','k','h','e','h','6','e','0','a','7','f','e','i','0','b',0},
4380             23, {0x05dc,0x05de,0x05d4,0x05d4,0x05dd,0x05e4,0x05e9,0x05d5,0x05d8,
4381                 0x05dc,0x05d0,0x05de,0x05d3,0x05d1,0x05e8,0x05d9,0x05dd,0x05e2,
4382                 0x05d1,0x05e8,0x05d9,0x05ea,0},
4383             0, 0xdeadbeef
4384         },
4385         {
4386             34, {'t','e','s','t','.','x','n','-','-','k','d','a','9','a','g','5','e',
4387                 '9','j','n','f','s','j','.','x','n','-','-','p','d','-','f','n','a'},
4388             16, {'t','e','s','t','.',0x0105,0x0119,0x015b,0x0107,
4389                 0x0142,0x00f3,0x017c,'.','p',0x0119,'d'},
4390             0, 0xdeadbeef
4391         },
4392         {
4393             64, {'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
4394                 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
4395                 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
4396                 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a'},
4397             0, {0},
4398             0, ERROR_INVALID_NAME
4399         },
4400         {
4401             8, {'x','n','-','-','6','l','a',0},
4402             2, {0x221,0},
4403             IDN_ALLOW_UNASSIGNED, 0xdeadbeef
4404         },
4405     };
4406
4407     WCHAR buf[1024];
4408     DWORD i, ret, err;
4409
4410     if (!pIdnToUnicode)
4411     {
4412         win_skip("IdnToUnicode is not available\n");
4413         return;
4414     }
4415
4416     for (i=0; i<sizeof(test_data)/sizeof(*test_data); i++)
4417     {
4418         ret = pIdnToUnicode(test_data[i].flags, test_data[i].in,
4419                 test_data[i].in_len, NULL, 0);
4420         ok(ret == test_data[i].ret, "%d) ret = %d\n", i, ret);
4421
4422         SetLastError(0xdeadbeef);
4423         ret = pIdnToUnicode(test_data[i].flags, test_data[i].in,
4424                 test_data[i].in_len, buf, sizeof(buf));
4425         err = GetLastError();
4426         ok(ret == test_data[i].ret, "%d) ret = %d\n", i, ret);
4427         ok(err == test_data[i].err, "%d) err = %d\n", i, err);
4428         ok(!memcmp(test_data[i].out, buf, ret*sizeof(WCHAR)),
4429                 "%d) buf = %s\n", i, wine_dbgstr_wn(buf, ret));
4430     }
4431 }
4432
4433 static void test_GetLocaleInfoEx(void)
4434 {
4435     static const WCHAR enW[] = {'e','n',0};
4436     WCHAR bufferW[80], buffer2[80];
4437     INT ret;
4438
4439     if (!pGetLocaleInfoEx)
4440     {
4441         win_skip("GetLocaleInfoEx not supported\n");
4442         return;
4443     }
4444
4445     ret = pGetLocaleInfoEx(enW, LOCALE_SNAME, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4446     ok(ret || broken(ret == 0) /* Vista */, "got %d\n", ret);
4447     if (ret)
4448     {
4449         static const WCHAR statesW[] = {'U','n','i','t','e','d',' ','S','t','a','t','e','s',0};
4450         static const WCHAR dummyW[] = {'d','u','m','m','y',0};
4451         static const WCHAR enusW[] = {'e','n','-','U','S',0};
4452         static const WCHAR usaW[] = {'U','S','A',0};
4453         static const WCHAR enuW[] = {'E','N','U',0};
4454         const struct neutralsublang_name_t *ptr = neutralsublang_names;
4455         DWORD val;
4456
4457         ok(ret == lstrlenW(bufferW)+1, "got %d\n", ret);
4458         ok(!lstrcmpW(bufferW, enW), "got %s\n", wine_dbgstr_w(bufferW));
4459
4460         SetLastError(0xdeadbeef);
4461         ret = pGetLocaleInfoEx(enW, LOCALE_SNAME, bufferW, 2);
4462         ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %d, %d\n", ret, GetLastError());
4463
4464         SetLastError(0xdeadbeef);
4465         ret = pGetLocaleInfoEx(enW, LOCALE_SNAME, NULL, 0);
4466         ok(ret == 3 && GetLastError() == 0xdeadbeef, "got %d, %d\n", ret, GetLastError());
4467
4468         ret = pGetLocaleInfoEx(enusW, LOCALE_SNAME, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4469         ok(ret == lstrlenW(bufferW)+1, "got %d\n", ret);
4470         ok(!lstrcmpW(bufferW, enusW), "got %s\n", wine_dbgstr_w(bufferW));
4471
4472         ret = pGetLocaleInfoEx(enW, LOCALE_SABBREVCTRYNAME, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4473         ok(ret == lstrlenW(bufferW)+1, "got %d\n", ret);
4474         ok(!lstrcmpW(bufferW, usaW), "got %s\n", wine_dbgstr_w(bufferW));
4475
4476         ret = pGetLocaleInfoEx(enW, LOCALE_SABBREVLANGNAME, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4477         ok(ret == lstrlenW(bufferW)+1, "got %d\n", ret);
4478         ok(!lstrcmpW(bufferW, enuW), "got %s\n", wine_dbgstr_w(bufferW));
4479
4480         ret = pGetLocaleInfoEx(enW, LOCALE_SCOUNTRY, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4481         ok(ret == lstrlenW(bufferW)+1, "got %d\n", ret);
4482         if ((PRIMARYLANGID(LANGIDFROMLCID(GetSystemDefaultLCID())) != LANG_ENGLISH) ||
4483             (PRIMARYLANGID(LANGIDFROMLCID(GetThreadLocale())) != LANG_ENGLISH))
4484         {
4485             skip("Non-English locale\n");
4486         }
4487         else
4488             ok(!lstrcmpW(bufferW, statesW), "got %s\n", wine_dbgstr_w(bufferW));
4489
4490         bufferW[0] = 0;
4491         SetLastError(0xdeadbeef);
4492         ret = pGetLocaleInfoEx(dummyW, LOCALE_SNAME, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4493         ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4494
4495         while (*ptr->name)
4496         {
4497             val = 0;
4498             pGetLocaleInfoEx(ptr->name, LOCALE_ILANGUAGE|LOCALE_RETURN_NUMBER, (WCHAR*)&val, sizeof(val)/sizeof(WCHAR));
4499             todo_wine_if (ptr->todo)
4500                 ok(val == ptr->lcid, "%s: got wrong lcid 0x%04x, expected 0x%04x\n", wine_dbgstr_w(ptr->name), val, ptr->lcid);
4501             bufferW[0] = 0;
4502             ret = pGetLocaleInfoEx(ptr->name, LOCALE_SNAME, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4503             ok(ret == lstrlenW(bufferW)+1, "%s: got ret value %d\n", wine_dbgstr_w(ptr->name), ret);
4504             ok(!lstrcmpW(bufferW, ptr->name), "%s: got wrong LOCALE_SNAME %s\n", wine_dbgstr_w(ptr->name), wine_dbgstr_w(bufferW));
4505             ptr++;
4506         }
4507
4508         ret = pGetLocaleInfoEx(LOCALE_NAME_USER_DEFAULT, LOCALE_SNAME, bufferW, sizeof(bufferW)/sizeof(WCHAR));
4509         ok(ret && ret == lstrlenW(bufferW)+1, "got ret value %d\n", ret);
4510         ret = GetLocaleInfoW(GetUserDefaultLCID(), LOCALE_SNAME, buffer2, sizeof(buffer2)/sizeof(WCHAR));
4511         ok(ret && ret == lstrlenW(buffer2)+1, "got ret value %d\n", ret);
4512         ok(!lstrcmpW(bufferW, buffer2), "LOCALE_SNAMEs don't match %s %s\n", wine_dbgstr_w(bufferW), wine_dbgstr_w(buffer2));
4513     }
4514 }
4515
4516 static void test_IsValidLocaleName(void)
4517 {
4518     static const WCHAR enusW[] = {'e','n','-','U','S',0};
4519     static const WCHAR zzW[] = {'z','z',0};
4520     static const WCHAR zz_zzW[] = {'z','z','-','Z','Z',0};
4521     static const WCHAR zzzzW[] = {'z','z','z','z',0};
4522     BOOL ret;
4523
4524     if (!pIsValidLocaleName)
4525     {
4526         win_skip("IsValidLocaleName not supported\n");
4527         return;
4528     }
4529
4530     ret = pIsValidLocaleName(enusW);
4531     ok(ret, "IsValidLocaleName failed\n");
4532     ret = pIsValidLocaleName(zzW);
4533     ok(!ret || broken(ret), "IsValidLocaleName should have failed\n");
4534     ret = pIsValidLocaleName(zz_zzW);
4535     ok(!ret || broken(ret), "IsValidLocaleName should have failed\n");
4536     ret = pIsValidLocaleName(zzzzW);
4537     ok(!ret, "IsValidLocaleName should have failed\n");
4538     ret = pIsValidLocaleName(LOCALE_NAME_INVARIANT);
4539     ok(ret, "IsValidLocaleName failed\n");
4540     ret = pIsValidLocaleName(NULL);
4541     ok(!ret, "IsValidLocaleName should have failed\n");
4542 }
4543
4544 static void test_CompareStringOrdinal(void)
4545 {
4546     INT ret;
4547     WCHAR test1[] = { 't','e','s','t',0 };
4548     WCHAR test2[] = { 'T','e','S','t',0 };
4549     WCHAR test3[] = { 't','e','s','t','3',0 };
4550     WCHAR null1[] = { 'a',0,'a',0 };
4551     WCHAR null2[] = { 'a',0,'b',0 };
4552     WCHAR bills1[] = { 'b','i','l','l','\'','s',0 };
4553     WCHAR bills2[] = { 'b','i','l','l','s',0 };
4554     WCHAR coop1[] = { 'c','o','-','o','p',0 };
4555     WCHAR coop2[] = { 'c','o','o','p',0 };
4556     WCHAR nonascii1[] = { 0x0102,0 };
4557     WCHAR nonascii2[] = { 0x0201,0 };
4558     WCHAR ch1, ch2;
4559
4560     if (!pCompareStringOrdinal)
4561     {
4562         win_skip("CompareStringOrdinal not supported\n");
4563         return;
4564     }
4565
4566     /* Check errors */
4567     SetLastError(0xdeadbeef);
4568     ret = pCompareStringOrdinal(NULL, 0, NULL, 0, FALSE);
4569     ok(!ret, "Got %u, expected 0\n", ret);
4570     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Got %x, expected %x\n", GetLastError(), ERROR_INVALID_PARAMETER);
4571     SetLastError(0xdeadbeef);
4572     ret = pCompareStringOrdinal(test1, -1, NULL, 0, FALSE);
4573     ok(!ret, "Got %u, expected 0\n", ret);
4574     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Got %x, expected %x\n", GetLastError(), ERROR_INVALID_PARAMETER);
4575     SetLastError(0xdeadbeef);
4576     ret = pCompareStringOrdinal(NULL, 0, test1, -1, FALSE);
4577     ok(!ret, "Got %u, expected 0\n", ret);
4578     ok(GetLastError() == ERROR_INVALID_PARAMETER, "Got %x, expected %x\n", GetLastError(), ERROR_INVALID_PARAMETER);
4579
4580     /* Check case */
4581     ret = pCompareStringOrdinal(test1, -1, test1, -1, FALSE);
4582     ok(ret == CSTR_EQUAL, "Got %u, expected %u\n", ret, CSTR_EQUAL);
4583     ret = pCompareStringOrdinal(test1, -1, test2, -1, FALSE);
4584     ok(ret == CSTR_GREATER_THAN, "Got %u, expected %u\n", ret, CSTR_GREATER_THAN);
4585     ret = pCompareStringOrdinal(test2, -1, test1, -1, FALSE);
4586     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4587     ret = pCompareStringOrdinal(test1, -1, test2, -1, TRUE);
4588     ok(ret == CSTR_EQUAL, "Got %u, expected %u\n", ret, CSTR_EQUAL);
4589
4590     /* Check different sizes */
4591     ret = pCompareStringOrdinal(test1, 3, test2, -1, TRUE);
4592     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4593     ret = pCompareStringOrdinal(test1, -1, test2, 3, TRUE);
4594     ok(ret == CSTR_GREATER_THAN, "Got %u, expected %u\n", ret, CSTR_GREATER_THAN);
4595
4596     /* Check null character */
4597     ret = pCompareStringOrdinal(null1, 3, null2, 3, FALSE);
4598     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4599     ret = pCompareStringOrdinal(null1, 3, null2, 3, TRUE);
4600     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4601     ret = pCompareStringOrdinal(test1, 5, test3, 5, FALSE);
4602     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4603     ret = pCompareStringOrdinal(test1, 4, test1, 5, FALSE);
4604     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4605
4606     /* Check ordinal behaviour */
4607     ret = pCompareStringOrdinal(bills1, -1, bills2, -1, FALSE);
4608     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4609     ret = pCompareStringOrdinal(coop2, -1, coop1, -1, FALSE);
4610     ok(ret == CSTR_GREATER_THAN, "Got %u, expected %u\n", ret, CSTR_GREATER_THAN);
4611     ret = pCompareStringOrdinal(nonascii1, -1, nonascii2, -1, FALSE);
4612     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4613     ret = pCompareStringOrdinal(nonascii1, -1, nonascii2, -1, TRUE);
4614     ok(ret == CSTR_LESS_THAN, "Got %u, expected %u\n", ret, CSTR_LESS_THAN);
4615
4616     for (ch1 = 0; ch1 < 512; ch1++)
4617     {
4618         for (ch2 = 0; ch2 < 1024; ch2++)
4619         {
4620             int diff = ch1 - ch2;
4621             ret = pCompareStringOrdinal( &ch1, 1, &ch2, 1, FALSE );
4622             ok( ret == (diff > 0 ? CSTR_GREATER_THAN : diff < 0 ? CSTR_LESS_THAN : CSTR_EQUAL),
4623                         "wrong result %d %04x %04x\n", ret, ch1, ch2 );
4624             diff = pRtlUpcaseUnicodeChar( ch1 ) - pRtlUpcaseUnicodeChar( ch2 );
4625             ret = pCompareStringOrdinal( &ch1, 1, &ch2, 1, TRUE );
4626             ok( ret == (diff > 0 ? CSTR_GREATER_THAN : diff < 0 ? CSTR_LESS_THAN : CSTR_EQUAL),
4627                         "wrong result %d %04x %04x\n", ret, ch1, ch2 );
4628         }
4629     }
4630 }
4631
4632 static void test_GetGeoInfo(void)
4633 {
4634     char buffA[20];
4635     INT ret;
4636
4637     if (!pGetGeoInfoA)
4638     {
4639         win_skip("GetGeoInfo is not available.\n");
4640         return;
4641     }
4642
4643     /* unassigned id */
4644     SetLastError(0xdeadbeef);
4645     ret = pGetGeoInfoA(344, GEO_ISO2, NULL, 0, 0);
4646     ok(ret == 0, "got %d\n", ret);
4647     ok(GetLastError() == ERROR_INVALID_PARAMETER, "got %d\n", GetLastError());
4648
4649     ret = pGetGeoInfoA(203, GEO_ISO2, NULL, 0, 0);
4650     ok(ret == 3, "got %d\n", ret);
4651
4652     ret = pGetGeoInfoA(203, GEO_ISO3, NULL, 0, 0);
4653     ok(ret == 4, "got %d\n", ret);
4654
4655     ret = pGetGeoInfoA(203, GEO_ISO2, buffA, 3, 0);
4656     ok(ret == 3, "got %d\n", ret);
4657     ok(!strcmp(buffA, "RU"), "got %s\n", buffA);
4658
4659     /* buffer pointer not NULL, length is 0 - return required length */
4660     buffA[0] = 'a';
4661     SetLastError(0xdeadbeef);
4662     ret = pGetGeoInfoA(203, GEO_ISO2, buffA, 0, 0);
4663     ok(ret == 3, "got %d\n", ret);
4664     ok(buffA[0] == 'a', "got %c\n", buffA[0]);
4665
4666     ret = pGetGeoInfoA(203, GEO_ISO3, buffA, 4, 0);
4667     ok(ret == 4, "got %d\n", ret);
4668     ok(!strcmp(buffA, "RUS"), "got %s\n", buffA);
4669
4670     /* shorter buffer */
4671     SetLastError(0xdeadbeef);
4672     buffA[1] = buffA[2] = 0;
4673     ret = pGetGeoInfoA(203, GEO_ISO2, buffA, 2, 0);
4674     ok(ret == 0, "got %d\n", ret);
4675     ok(!strcmp(buffA, "RU"), "got %s\n", buffA);
4676     ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, "got %d\n", GetLastError());
4677
4678     /* GEO_NATION returns GEOID in a string form */
4679     buffA[0] = 0;
4680     ret = pGetGeoInfoA(203, GEO_NATION, buffA, 20, 0);
4681     ok(ret == 4, "got %d\n", ret);
4682     ok(!strcmp(buffA, "203"), "got %s\n", buffA);
4683
4684     /* GEO_PARENT */
4685     buffA[0] = 0;
4686     ret = pGetGeoInfoA(203, GEO_PARENT, buffA, 20, 0);
4687     if (ret == 0)
4688         win_skip("GEO_PARENT not supported.\n");
4689     else
4690     {
4691         ok(ret == 6, "got %d\n", ret);
4692         ok(!strcmp(buffA, "47609"), "got %s\n", buffA);
4693     }
4694
4695     buffA[0] = 0;
4696     ret = pGetGeoInfoA(203, GEO_ISO_UN_NUMBER, buffA, 20, 0);
4697     if (ret == 0)
4698         win_skip("GEO_ISO_UN_NUMBER not supported.\n");
4699     else
4700     {
4701         ok(ret == 4, "got %d\n", ret);
4702         ok(!strcmp(buffA, "643"), "got %s\n", buffA);
4703     }
4704
4705     /* try invalid type value */
4706     SetLastError(0xdeadbeef);
4707     ret = pGetGeoInfoA(203, GEO_CURRENCYSYMBOL + 1, NULL, 0, 0);
4708     ok(ret == 0, "got %d\n", ret);
4709     ok(GetLastError() == ERROR_INVALID_FLAGS, "got %d\n", GetLastError());
4710 }
4711
4712 static int geoidenum_count;
4713 static BOOL CALLBACK test_geoid_enumproc(GEOID geoid)
4714 {
4715     INT ret = pGetGeoInfoA(geoid, GEO_ISO2, NULL, 0, 0);
4716     ok(ret == 3, "got %d for %d\n", ret, geoid);
4717     /* valid geoid starts at 2 */
4718     ok(geoid >= 2, "got geoid %d\n", geoid);
4719
4720     return geoidenum_count++ < 5;
4721 }
4722
4723 static BOOL CALLBACK test_geoid_enumproc2(GEOID geoid)
4724 {
4725     geoidenum_count++;
4726     return TRUE;
4727 }
4728
4729 static void test_EnumSystemGeoID(void)
4730 {
4731     BOOL ret;
4732
4733     if (!pEnumSystemGeoID)
4734     {
4735         win_skip("EnumSystemGeoID is not available.\n");
4736         return;
4737     }
4738
4739     SetLastError(0xdeadbeef);
4740     ret = pEnumSystemGeoID(GEOCLASS_NATION, 0, NULL);
4741     ok(!ret, "got %d\n", ret);
4742     ok(GetLastError() == ERROR_INVALID_PARAMETER, "got %d\n", GetLastError());
4743
4744     SetLastError(0xdeadbeef);
4745     ret = pEnumSystemGeoID(GEOCLASS_NATION+1, 0, test_geoid_enumproc);
4746     ok(!ret, "got %d\n", ret);
4747     ok(GetLastError() == ERROR_INVALID_FLAGS, "got %d\n", GetLastError());
4748
4749     SetLastError(0xdeadbeef);
4750     ret = pEnumSystemGeoID(GEOCLASS_NATION+1, 0, NULL);
4751     ok(!ret, "got %d\n", ret);
4752     ok(GetLastError() == ERROR_INVALID_PARAMETER, "got %d\n", GetLastError());
4753
4754     ret = pEnumSystemGeoID(GEOCLASS_NATION, 0, test_geoid_enumproc);
4755     ok(ret, "got %d\n", ret);
4756
4757     /* only the first level is enumerated, not the whole hierarchy */
4758     geoidenum_count = 0;
4759     ret = pEnumSystemGeoID(GEOCLASS_NATION, 39070, test_geoid_enumproc2);
4760     if (ret == 0)
4761         win_skip("Parent GEOID is not supported in EnumSystemGeoID.\n");
4762     else
4763         ok(ret && geoidenum_count > 0, "got %d, count %d\n", ret, geoidenum_count);
4764
4765     geoidenum_count = 0;
4766     ret = pEnumSystemGeoID(GEOCLASS_REGION, 39070, test_geoid_enumproc2);
4767     if (ret == 0)
4768         win_skip("GEOCLASS_REGION is not supported in EnumSystemGeoID.\n");
4769     else
4770     {
4771         ok(ret && geoidenum_count > 0, "got %d, count %d\n", ret, geoidenum_count);
4772
4773         geoidenum_count = 0;
4774         ret = pEnumSystemGeoID(GEOCLASS_REGION, 0, test_geoid_enumproc2);
4775         ok(ret && geoidenum_count > 0, "got %d, count %d\n", ret, geoidenum_count);
4776     }
4777 }
4778
4779 struct invariant_entry {
4780   const char *name;
4781   int id;
4782   const char *expect, *expect2;
4783 };
4784
4785 #define X(x)  #x, x
4786 static const struct invariant_entry invariant_list[] = {
4787     { X(LOCALE_ILANGUAGE),                "007f" },
4788     { X(LOCALE_SENGLANGUAGE),             "Invariant Language" },
4789     { X(LOCALE_SABBREVLANGNAME),          "IVL" },
4790     { X(LOCALE_SNATIVELANGNAME),          "Invariant Language" },
4791     { X(LOCALE_ICOUNTRY),                 "1" },
4792     { X(LOCALE_SENGCOUNTRY),              "Invariant Country" },
4793     { X(LOCALE_SABBREVCTRYNAME),          "IVC", "" },
4794     { X(LOCALE_SNATIVECTRYNAME),          "Invariant Country" },
4795     { X(LOCALE_IDEFAULTLANGUAGE),         "0409" },
4796     { X(LOCALE_IDEFAULTCOUNTRY),          "1" },
4797     { X(LOCALE_IDEFAULTCODEPAGE),         "437" },
4798     { X(LOCALE_IDEFAULTANSICODEPAGE),     "1252" },
4799     { X(LOCALE_IDEFAULTMACCODEPAGE),      "10000" },
4800     { X(LOCALE_SLIST),                    "," },
4801     { X(LOCALE_IMEASURE),                 "0" },
4802     { X(LOCALE_SDECIMAL),                 "." },
4803     { X(LOCALE_STHOUSAND),                "," },
4804     { X(LOCALE_SGROUPING),                "3;0" },
4805     { X(LOCALE_IDIGITS),                  "2" },
4806     { X(LOCALE_ILZERO),                   "1" },
4807     { X(LOCALE_INEGNUMBER),               "1" },
4808     { X(LOCALE_SNATIVEDIGITS),            "0123456789" },
4809     { X(LOCALE_SCURRENCY),                "\x00a4" },
4810     { X(LOCALE_SINTLSYMBOL),              "XDR" },
4811     { X(LOCALE_SMONDECIMALSEP),           "." },
4812     { X(LOCALE_SMONTHOUSANDSEP),          "," },
4813     { X(LOCALE_SMONGROUPING),             "3;0" },
4814     { X(LOCALE_ICURRDIGITS),              "2" },
4815     { X(LOCALE_IINTLCURRDIGITS),          "2" },
4816     { X(LOCALE_ICURRENCY),                "0" },
4817     { X(LOCALE_INEGCURR),                 "0" },
4818     { X(LOCALE_SDATE),                    "/" },
4819     { X(LOCALE_STIME),                    ":" },
4820     { X(LOCALE_SSHORTDATE),               "MM/dd/yyyy" },
4821     { X(LOCALE_SLONGDATE),                "dddd, dd MMMM yyyy" },
4822     { X(LOCALE_STIMEFORMAT),              "HH:mm:ss" },
4823     { X(LOCALE_IDATE),                    "0" },
4824     { X(LOCALE_ILDATE),                   "1" },
4825     { X(LOCALE_ITIME),                    "1" },
4826     { X(LOCALE_ITIMEMARKPOSN),            "0" },
4827     { X(LOCALE_ICENTURY),                 "1" },
4828     { X(LOCALE_ITLZERO),                  "1" },
4829     { X(LOCALE_IDAYLZERO),                "1" },
4830     { X(LOCALE_IMONLZERO),                "1" },
4831     { X(LOCALE_S1159),                    "AM" },
4832     { X(LOCALE_S2359),                    "PM" },
4833     { X(LOCALE_ICALENDARTYPE),            "1" },
4834     { X(LOCALE_IOPTIONALCALENDAR),        "0" },
4835     { X(LOCALE_IFIRSTDAYOFWEEK),          "6" },
4836     { X(LOCALE_IFIRSTWEEKOFYEAR),         "0" },
4837     { X(LOCALE_SDAYNAME1),                "Monday" },
4838     { X(LOCALE_SDAYNAME2),                "Tuesday" },
4839     { X(LOCALE_SDAYNAME3),                "Wednesday" },
4840     { X(LOCALE_SDAYNAME4),                "Thursday" },
4841     { X(LOCALE_SDAYNAME5),                "Friday" },
4842     { X(LOCALE_SDAYNAME6),                "Saturday" },
4843     { X(LOCALE_SDAYNAME7),                "Sunday" },
4844     { X(LOCALE_SABBREVDAYNAME1),          "Mon" },
4845     { X(LOCALE_SABBREVDAYNAME2),          "Tue" },
4846     { X(LOCALE_SABBREVDAYNAME3),          "Wed" },
4847     { X(LOCALE_SABBREVDAYNAME4),          "Thu" },
4848     { X(LOCALE_SABBREVDAYNAME5),          "Fri" },
4849     { X(LOCALE_SABBREVDAYNAME6),          "Sat" },
4850     { X(LOCALE_SABBREVDAYNAME7),          "Sun" },
4851     { X(LOCALE_SMONTHNAME1),              "January" },
4852     { X(LOCALE_SMONTHNAME2),              "February" },
4853     { X(LOCALE_SMONTHNAME3),              "March" },
4854     { X(LOCALE_SMONTHNAME4),              "April" },
4855     { X(LOCALE_SMONTHNAME5),              "May" },
4856     { X(LOCALE_SMONTHNAME6),              "June" },
4857     { X(LOCALE_SMONTHNAME7),              "July" },
4858     { X(LOCALE_SMONTHNAME8),              "August" },
4859     { X(LOCALE_SMONTHNAME9),              "September" },
4860     { X(LOCALE_SMONTHNAME10),             "October" },
4861     { X(LOCALE_SMONTHNAME11),             "November" },
4862     { X(LOCALE_SMONTHNAME12),             "December" },
4863     { X(LOCALE_SMONTHNAME13),             "" },
4864     { X(LOCALE_SABBREVMONTHNAME1),        "Jan" },
4865     { X(LOCALE_SABBREVMONTHNAME2),        "Feb" },
4866     { X(LOCALE_SABBREVMONTHNAME3),        "Mar" },
4867     { X(LOCALE_SABBREVMONTHNAME4),        "Apr" },
4868     { X(LOCALE_SABBREVMONTHNAME5),        "May" },
4869     { X(LOCALE_SABBREVMONTHNAME6),        "Jun" },
4870     { X(LOCALE_SABBREVMONTHNAME7),        "Jul" },
4871     { X(LOCALE_SABBREVMONTHNAME8),        "Aug" },
4872     { X(LOCALE_SABBREVMONTHNAME9),        "Sep" },
4873     { X(LOCALE_SABBREVMONTHNAME10),       "Oct" },
4874     { X(LOCALE_SABBREVMONTHNAME11),       "Nov" },
4875     { X(LOCALE_SABBREVMONTHNAME12),       "Dec" },
4876     { X(LOCALE_SABBREVMONTHNAME13),       "" },
4877     { X(LOCALE_SPOSITIVESIGN),            "+" },
4878     { X(LOCALE_SNEGATIVESIGN),            "-" },
4879     { X(LOCALE_IPOSSIGNPOSN),             "3" },
4880     { X(LOCALE_INEGSIGNPOSN),             "0" },
4881     { X(LOCALE_IPOSSYMPRECEDES),          "1" },
4882     { X(LOCALE_IPOSSEPBYSPACE),           "0" },
4883     { X(LOCALE_INEGSYMPRECEDES),          "1" },
4884     { X(LOCALE_INEGSEPBYSPACE),           "0" },
4885     { X(LOCALE_SISO639LANGNAME),          "iv" },
4886     { X(LOCALE_SISO3166CTRYNAME),         "IV" },
4887     { X(LOCALE_IDEFAULTEBCDICCODEPAGE),   "037" },
4888     { X(LOCALE_IPAPERSIZE),               "9" },
4889     { X(LOCALE_SENGCURRNAME),             "International Monetary Fund" },
4890     { X(LOCALE_SNATIVECURRNAME),          "International Monetary Fund" },
4891     { X(LOCALE_SYEARMONTH),               "yyyy MMMM" },
4892     { X(LOCALE_IDIGITSUBSTITUTION),       "1" },
4893     { X(LOCALE_SNAME),                    "" },
4894     { X(LOCALE_SSCRIPTS),                 "Latn;" },
4895     { 0 }
4896 };
4897 #undef X
4898
4899 static void test_invariant(void)
4900 {
4901   int ret;
4902   int len;
4903   char buffer[BUFFER_SIZE];
4904   const struct invariant_entry *ptr = invariant_list;
4905
4906   if (!GetLocaleInfoA(LOCALE_INVARIANT, NUO|LOCALE_SLANGUAGE, buffer, sizeof(buffer)))
4907   {
4908       win_skip("GetLocaleInfoA(LOCALE_INVARIANT) not supported\n"); /* win2k */
4909       return;
4910   }
4911
4912   while (ptr->name)
4913   {
4914     ret = GetLocaleInfoA(LOCALE_INVARIANT, NUO|ptr->id, buffer, sizeof(buffer));
4915     if (!ret && (ptr->id == LOCALE_SNAME || ptr->id == LOCALE_SSCRIPTS))
4916         win_skip("not supported\n"); /* winxp/win2k3 */
4917     else
4918     {
4919         len = strlen(ptr->expect)+1; /* include \0 */
4920         ok(ret == len || (ptr->expect2 && ret == strlen(ptr->expect2)+1),
4921            "For id %d, expected ret == %d, got %d, error %d\n",
4922             ptr->id, len, ret, GetLastError());
4923         ok(!strcmp(buffer, ptr->expect) || (ptr->expect2 && !strcmp(buffer, ptr->expect2)),
4924            "For id %d, Expected %s, got '%s'\n",
4925             ptr->id, ptr->expect, buffer);
4926     }
4927
4928     ptr++;
4929   }
4930
4931  if ((LANGIDFROMLCID(GetSystemDefaultLCID()) != MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)) ||
4932      (LANGIDFROMLCID(GetThreadLocale()) != MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US)))
4933   {
4934       skip("Non US-English locale\n");
4935   }
4936   else
4937   {
4938     /* some locales translate these */
4939     static const char lang[]  = "Invariant Language (Invariant Country)";
4940     static const char cntry[] = "Invariant Country";
4941     static const char sortm[] = "Math Alphanumerics";
4942     static const char sortd[] = "Default"; /* win2k3 */
4943
4944     ret = GetLocaleInfoA(LOCALE_INVARIANT, NUO|LOCALE_SLANGUAGE, buffer, sizeof(buffer));
4945     len = lstrlenA(lang) + 1;
4946     ok(ret == len, "Expected ret == %d, got %d, error %d\n", len, ret, GetLastError());
4947     ok(!strcmp(buffer, lang), "Expected %s, got '%s'\n", lang, buffer);
4948
4949     ret = GetLocaleInfoA(LOCALE_INVARIANT, NUO|LOCALE_SCOUNTRY, buffer, sizeof(buffer));
4950     len = lstrlenA(cntry) + 1;
4951     ok(ret == len, "Expected ret == %d, got %d, error %d\n", len, ret, GetLastError());
4952     ok(!strcmp(buffer, cntry), "Expected %s, got '%s'\n", cntry, buffer);
4953
4954     ret = GetLocaleInfoA(LOCALE_INVARIANT, NUO|LOCALE_SSORTNAME, buffer, sizeof(buffer));
4955     if (ret == lstrlenA(sortm)+1)
4956         ok(!strcmp(buffer, sortm), "Expected %s, got '%s'\n", sortm, buffer);
4957     else if (ret == lstrlenA(sortd)+1) /* win2k3 */
4958         ok(!strcmp(buffer, sortd), "Expected %s, got '%s'\n", sortd, buffer);
4959     else
4960         ok(0, "Expected ret == %d or %d, got %d, error %d\n",
4961             lstrlenA(sortm)+1, lstrlenA(sortd)+1, ret, GetLastError());
4962   }
4963 }
4964
4965 static void test_GetSystemPreferredUILanguages(void)
4966 {
4967     BOOL ret;
4968     ULONG count, size, size_id, size_name, size_buffer;
4969     WCHAR *buffer;
4970
4971
4972     if (!pGetSystemPreferredUILanguages)
4973     {
4974         win_skip("GetSystemPreferredUILanguages is not available.\n");
4975         return;
4976     }
4977
4978     /* (in)valid first parameter */
4979     count = 0xdeadbeef;
4980     size = 0;
4981     SetLastError(0xdeadbeef);
4982     ret = pGetSystemPreferredUILanguages(0, &count, NULL, &size);
4983     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
4984     ok(count, "Expected count > 0\n");
4985     ok(size % 6 == 1, "Expected size (%d) %% 6 == 1\n", size);
4986
4987     count = 0xdeadbeef;
4988     size = 0;
4989     SetLastError(0xdeadbeef);
4990     ret = pGetSystemPreferredUILanguages(MUI_FULL_LANGUAGE, &count, NULL, &size);
4991     ok(!ret, "Expected GetSystemPreferredUILanguages to fail\n");
4992     ok(ERROR_INVALID_PARAMETER == GetLastError(),
4993        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
4994
4995     count = 0xdeadbeef;
4996     size = 0;
4997     SetLastError(0xdeadbeef);
4998     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID | MUI_FULL_LANGUAGE, &count, NULL, &size);
4999     ok(!ret, "Expected GetSystemPreferredUILanguages to fail\n");
5000     ok(ERROR_INVALID_PARAMETER == GetLastError(),
5001        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
5002
5003     count = 0xdeadbeef;
5004     size = 0;
5005     SetLastError(0xdeadbeef);
5006     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID | MUI_LANGUAGE_NAME, &count, NULL, &size);
5007     ok(!ret, "Expected GetSystemPreferredUILanguages to fail\n");
5008     ok(ERROR_INVALID_PARAMETER == GetLastError(),
5009        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
5010
5011     count = 0xdeadbeef;
5012     size = 0;
5013     SetLastError(0xdeadbeef);
5014     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID | MUI_MACHINE_LANGUAGE_SETTINGS, &count, NULL, &size);
5015     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5016     ok(count, "Expected count > 0\n");
5017     ok(size % 5 == 1, "Expected size (%d) %% 5 == 1\n", size);
5018
5019     count = 0xdeadbeef;
5020     size = 0;
5021     SetLastError(0xdeadbeef);
5022     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_NAME | MUI_MACHINE_LANGUAGE_SETTINGS, &count, NULL, &size);
5023     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5024     ok(count, "Expected count > 0\n");
5025     ok(size % 6 == 1, "Expected size (%d) %% 6 == 1\n", size);
5026
5027     /* second parameter
5028      * ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID, NULL, NULL, &size);
5029      * -> unhandled exception c0000005
5030      */
5031
5032     /* invalid third parameter */
5033     count = 0xdeadbeef;
5034     size = 1;
5035     SetLastError(0xdeadbeef);
5036     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID, &count, NULL, &size);
5037     ok(!ret, "Expected GetSystemPreferredUILanguages to fail\n");
5038     ok(ERROR_INVALID_PARAMETER == GetLastError(),
5039        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
5040
5041     /* fourth parameter
5042      * ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID, &count, NULL, NULL);
5043      * -> unhandled exception c0000005
5044      */
5045
5046     count = 0xdeadbeef;
5047     size_id = 0;
5048     SetLastError(0xdeadbeef);
5049     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID, &count, NULL, &size_id);
5050     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5051     ok(count, "Expected count > 0\n");
5052     ok(size_id  % 5 == 1, "Expected size (%d) %% 5 == 1\n", size_id);
5053
5054     count = 0xdeadbeef;
5055     size_name = 0;
5056     SetLastError(0xdeadbeef);
5057     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_NAME, &count, NULL, &size_name);
5058     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5059     ok(count, "Expected count > 0\n");
5060     ok(size_name % 6 == 1, "Expected size (%d) %% 6 == 1\n", size_name);
5061
5062     size_buffer = max(size_id, size_name);
5063     if(!size_buffer)
5064     {
5065         skip("No valid buffer size\n");
5066         return;
5067     }
5068
5069     buffer = HeapAlloc(GetProcessHeap(), 0, size_buffer * sizeof(WCHAR));
5070     if (!buffer)
5071     {
5072         skip("Failed to allocate memory for %d chars\n", size_buffer);
5073         return;
5074     }
5075
5076     count = 0xdeadbeef;
5077     size = size_buffer;
5078     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5079     SetLastError(0xdeadbeef);
5080     ret = pGetSystemPreferredUILanguages(0, &count, buffer, &size);
5081     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5082     ok(count, "Expected count > 0\n");
5083     ok(size % 6 == 1, "Expected size (%d) %% 6 == 1\n", size);
5084     if (ret && size % 6 == 1)
5085         ok(!buffer[size -2] && !buffer[size -1],
5086            "Expected last two WCHARs being empty, got 0x%x 0x%x\n",
5087            buffer[size -2], buffer[size -1]);
5088
5089     count = 0xdeadbeef;
5090     size = size_buffer;
5091     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5092     SetLastError(0xdeadbeef);
5093     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID, &count, buffer, &size);
5094     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5095     ok(count, "Expected count > 0\n");
5096     ok(size % 5 == 1, "Expected size (%d) %% 5 == 1\n", size);
5097     if (ret && size % 5 == 1)
5098         ok(!buffer[size -2] && !buffer[size -1],
5099            "Expected last two WCHARs being empty, got 0x%x 0x%x\n",
5100            buffer[size -2], buffer[size -1]);
5101
5102     count = 0xdeadbeef;
5103     size = size_buffer;
5104     SetLastError(0xdeadbeef);
5105     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_NAME, &count, buffer, &size);
5106     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5107     ok(count, "Expected count > 0\n");
5108     ok(size % 6 == 1, "Expected size (%d) %% 6 == 1\n", size);
5109     if (ret && size % 5 == 1)
5110         ok(!buffer[size -2] && !buffer[size -1],
5111            "Expected last two WCHARs being empty, got 0x%x 0x%x\n",
5112            buffer[size -2], buffer[size -1]);
5113
5114     count = 0xdeadbeef;
5115     size = 0;
5116     SetLastError(0xdeadbeef);
5117     ret = pGetSystemPreferredUILanguages(MUI_MACHINE_LANGUAGE_SETTINGS, &count, NULL, &size);
5118     ok(ret, "Expected GetSystemPreferredUILanguages to succeed\n");
5119     ok(count, "Expected count > 0\n");
5120     ok(size % 6 == 1, "Expected size (%d) %% 6 == 1\n", size);
5121     if (ret && size % 6 == 1)
5122         ok(!buffer[size -2] && !buffer[size -1],
5123            "Expected last two WCHARs being empty, got 0x%x 0x%x\n",
5124            buffer[size -2], buffer[size -1]);
5125
5126     count = 0xdeadbeef;
5127     size = 1;
5128     SetLastError(0xdeadbeef);
5129     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID, &count, buffer, &size);
5130     ok(!ret, "Expected GetSystemPreferredUILanguages to fail\n");
5131     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(),
5132        "Expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
5133
5134     count = 0xdeadbeef;
5135     size = size_id -1;
5136     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5137     SetLastError(0xdeadbeef);
5138     ret = pGetSystemPreferredUILanguages(MUI_LANGUAGE_ID, &count, buffer, &size);
5139     ok(!ret, "Expected GetSystemPreferredUILanguages to fail\n");
5140     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(),
5141        "Expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
5142
5143     count = 0xdeadbeef;
5144     size = size_id -2;
5145     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5146     SetLastError(0xdeadbeef);
5147     ret = pGetSystemPreferredUILanguages(0, &count, buffer, &size);
5148     ok(!ret, "Expected GetSystemPreferredUILanguages to fail\n");
5149     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(),
5150        "Expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
5151
5152     HeapFree(GetProcessHeap(), 0, buffer);
5153 }
5154
5155 static void test_GetThreadPreferredUILanguages(void)
5156 {
5157     BOOL ret;
5158     ULONG count, size;
5159     WCHAR *buf;
5160
5161     if (!pGetThreadPreferredUILanguages)
5162     {
5163         win_skip("GetThreadPreferredUILanguages is not available.\n");
5164         return;
5165     }
5166
5167     size = count = 0;
5168     ret = pGetThreadPreferredUILanguages(MUI_LANGUAGE_ID|MUI_UI_FALLBACK, &count, NULL, &size);
5169     ok(ret, "got %u\n", GetLastError());
5170     ok(count, "expected count > 0\n");
5171     ok(size, "expected size > 0\n");
5172
5173     count = 0;
5174     buf = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, size * sizeof(WCHAR));
5175     ret = pGetThreadPreferredUILanguages(MUI_LANGUAGE_ID|MUI_UI_FALLBACK, &count, buf, &size);
5176     ok(ret, "got %u\n", GetLastError());
5177     ok(count, "expected count > 0\n");
5178     HeapFree(GetProcessHeap(), 0, buf);
5179 }
5180
5181 static void test_GetUserPreferredUILanguages(void)
5182 {
5183     BOOL ret;
5184     ULONG count, size, size_id, size_name, size_buffer;
5185     WCHAR *buffer;
5186
5187
5188     if (!pGetUserPreferredUILanguages)
5189     {
5190         win_skip("GetUserPreferredUILanguages is not available.\n");
5191         return;
5192     }
5193
5194     count = 0xdeadbeef;
5195     size = 0;
5196     SetLastError(0xdeadbeef);
5197     ret = pGetUserPreferredUILanguages(MUI_FULL_LANGUAGE, &count, NULL, &size);
5198     ok(!ret, "Expected GetUserPreferredUILanguages to fail\n");
5199     ok(ERROR_INVALID_PARAMETER == GetLastError(),
5200        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
5201
5202     count = 0xdeadbeef;
5203     size = 0;
5204     SetLastError(0xdeadbeef);
5205     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_ID | MUI_FULL_LANGUAGE, &count, NULL, &size);
5206     ok(!ret, "Expected GetUserPreferredUILanguages to fail\n");
5207     ok(ERROR_INVALID_PARAMETER == GetLastError(),
5208        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
5209
5210     count = 0xdeadbeef;
5211     size = 0;
5212     SetLastError(0xdeadbeef);
5213     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_ID | MUI_MACHINE_LANGUAGE_SETTINGS, &count, NULL, &size);
5214     ok(!ret, "Expected GetUserPreferredUILanguages to fail\n");
5215     ok(ERROR_INVALID_PARAMETER == GetLastError(),
5216        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
5217
5218     count = 0xdeadbeef;
5219     size = 1;
5220     SetLastError(0xdeadbeef);
5221     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_ID, &count, NULL, &size);
5222     ok(!ret, "Expected GetUserPreferredUILanguages to fail\n");
5223     ok(ERROR_INVALID_PARAMETER == GetLastError(),
5224        "Expected error ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
5225
5226     count = 0xdeadbeef;
5227     size_id = 0;
5228     SetLastError(0xdeadbeef);
5229     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_ID, &count, NULL, &size_id);
5230     ok(ret, "Expected GetUserPreferredUILanguages to succeed\n");
5231     ok(count, "Expected count > 0\n");
5232     ok(size_id  % 5 == 1, "Expected size (%d) %% 5 == 1\n", size_id);
5233
5234     count = 0xdeadbeef;
5235     size_name = 0;
5236     SetLastError(0xdeadbeef);
5237     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_NAME, &count, NULL, &size_name);
5238     ok(ret, "Expected GetUserPreferredUILanguages to succeed\n");
5239     ok(count, "Expected count > 0\n");
5240     ok(size_name % 6 == 1, "Expected size (%d) %% 6 == 1\n", size_name);
5241
5242     size_buffer = max(size_id, size_name);
5243     if(!size_buffer)
5244     {
5245         skip("No valid buffer size\n");
5246         return;
5247     }
5248
5249     buffer = HeapAlloc(GetProcessHeap(), 0, size_buffer * sizeof(WCHAR));
5250
5251     count = 0xdeadbeef;
5252     size = size_buffer;
5253     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5254     SetLastError(0xdeadbeef);
5255     ret = pGetUserPreferredUILanguages(0, &count, buffer, &size);
5256     ok(ret, "Expected GetUserPreferredUILanguages to succeed\n");
5257     ok(count, "Expected count > 0\n");
5258     ok(size % 6 == 1, "Expected size (%d) %% 6 == 1\n", size);
5259     if (ret && size % 6 == 1)
5260         ok(!buffer[size -2] && !buffer[size -1],
5261            "Expected last two WCHARs being empty, got 0x%x 0x%x\n",
5262            buffer[size -2], buffer[size -1]);
5263
5264     count = 0xdeadbeef;
5265     size = size_buffer;
5266     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5267     SetLastError(0xdeadbeef);
5268     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_ID, &count, buffer, &size);
5269     ok(ret, "Expected GetUserPreferredUILanguages to succeed\n");
5270     ok(count, "Expected count > 0\n");
5271     ok(size % 5 == 1, "Expected size (%d) %% 5 == 1\n", size);
5272     if (ret && size % 5 == 1)
5273         ok(!buffer[size -2] && !buffer[size -1],
5274            "Expected last two WCHARs being empty, got 0x%x 0x%x\n",
5275            buffer[size -2], buffer[size -1]);
5276
5277     count = 0xdeadbeef;
5278     size = size_buffer;
5279     SetLastError(0xdeadbeef);
5280     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_NAME, &count, buffer, &size);
5281     ok(ret, "Expected GetUserPreferredUILanguages to succeed\n");
5282     ok(count, "Expected count > 0\n");
5283     ok(size % 6 == 1, "Expected size (%d) %% 6 == 1\n", size);
5284     if (ret && size % 5 == 1)
5285         ok(!buffer[size -2] && !buffer[size -1],
5286            "Expected last two WCHARs being empty, got 0x%x 0x%x\n",
5287            buffer[size -2], buffer[size -1]);
5288
5289     count = 0xdeadbeef;
5290     size = 1;
5291     SetLastError(0xdeadbeef);
5292     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_ID, &count, buffer, &size);
5293     ok(!ret, "Expected GetUserPreferredUILanguages to fail\n");
5294     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(),
5295        "Expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
5296
5297     count = 0xdeadbeef;
5298     size = size_id -1;
5299     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5300     SetLastError(0xdeadbeef);
5301     ret = pGetUserPreferredUILanguages(MUI_LANGUAGE_ID, &count, buffer, &size);
5302     ok(!ret, "Expected GetUserPreferredUILanguages to fail\n");
5303     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(),
5304        "Expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
5305
5306     count = 0xdeadbeef;
5307     size = size_id -2;
5308     memset(buffer, 0x5a, size_buffer * sizeof(WCHAR));
5309     SetLastError(0xdeadbeef);
5310     ret = pGetUserPreferredUILanguages(0, &count, buffer, &size);
5311     ok(!ret, "Expected GetUserPreferredUILanguages to fail\n");
5312     ok(ERROR_INSUFFICIENT_BUFFER == GetLastError(),
5313        "Expected error ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
5314
5315     HeapFree(GetProcessHeap(), 0, buffer);
5316 }
5317
5318 START_TEST(locale)
5319 {
5320   InitFunctionPointers();
5321
5322   test_EnumTimeFormatsA();
5323   test_EnumTimeFormatsW();
5324   test_EnumDateFormatsA();
5325   test_GetLocaleInfoA();
5326   test_GetLocaleInfoW();
5327   test_GetLocaleInfoEx();
5328   test_GetTimeFormatA();
5329   test_GetTimeFormatEx();
5330   test_GetDateFormatA();
5331   test_GetDateFormatEx();
5332   test_GetDateFormatW();
5333   test_GetCurrencyFormatA(); /* Also tests the W version */
5334   test_GetNumberFormatA();   /* Also tests the W version */
5335   test_GetNumberFormatEx();
5336   test_CompareStringA();
5337   test_CompareStringW();
5338   test_CompareStringEx();
5339   test_LCMapStringA();
5340   test_LCMapStringW();
5341   test_LCMapStringEx();
5342   test_LocaleNameToLCID();
5343   test_FoldStringA();
5344   test_FoldStringW();
5345   test_ConvertDefaultLocale();
5346   test_EnumSystemLanguageGroupsA();
5347   test_EnumSystemLocalesEx();
5348   test_EnumLanguageGroupLocalesA();
5349   test_SetLocaleInfoA();
5350   test_EnumUILanguageA();
5351   test_GetCPInfo();
5352   test_GetStringTypeW();
5353   test_IdnToNameprepUnicode();
5354   test_IdnToAscii();
5355   test_IdnToUnicode();
5356   test_IsValidLocaleName();
5357   test_CompareStringOrdinal();
5358   test_GetGeoInfo();
5359   test_EnumSystemGeoID();
5360   test_invariant();
5361   test_GetSystemPreferredUILanguages();
5362   test_GetThreadPreferredUILanguages();
5363   test_GetUserPreferredUILanguages();
5364   test_sorting();
5365 }