git.oblomov.eu Git - wine/blob - dlls/kernel32/tests/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 #include "wine/test.h"
  34 #include "windef.h"
  35 #include "winbase.h"
  36 #include "winerror.h"
  37 #include "winnls.h"
  38
  39 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};
  40 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};
  41 static const WCHAR symbols_stripped[] = {'j','u','s','t','a','t','e','s','t','s','t','r','i','n','g','1',0};
  42 static const WCHAR fooW[] = {'f','o','o',0};
  43
  44 static inline unsigned int strlenW( const WCHAR *str )
  45 {
  46     const WCHAR *s = str;
  47     while (*s) s++;
  48     return s - str;
  49 }
  50
  51 static inline int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
  52 {
  53     if (n <= 0) return 0;
  54     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
  55     return *str1 - *str2;
  56 }
  57
  58 static inline WCHAR *strchrW( const WCHAR *str, WCHAR ch )
  59 {
  60     do { if (*str == ch) return (WCHAR *)str; } while (*str++);
  61     return NULL;
  62 }
  63
  64 static inline int isdigitW( WCHAR wc )
  65 {
  66     WORD type;
  67     GetStringTypeW( CT_CTYPE1, &wc, 1, &type );
  68     return type & C1_DIGIT;
  69 }
  70
  71 /* Some functions are only in later versions of kernel32.dll */
  72 static HMODULE hKernel32;
  73 static WORD enumCount;
  74
  75 static BOOL (WINAPI *pEnumSystemLanguageGroupsA)(LANGUAGEGROUP_ENUMPROC, DWORD, LONG_PTR);
  76 static BOOL (WINAPI *pEnumLanguageGroupLocalesA)(LANGGROUPLOCALE_ENUMPROC, LGRPID, DWORD, LONG_PTR);
  77 static BOOL (WINAPI *pEnumUILanguagesA)(UILANGUAGE_ENUMPROC, DWORD, LONG_PTR);
  78 static BOOL (WINAPI *pEnumSystemLocalesEx)(LOCALE_ENUMPROCEX, DWORD, LPARAM, LPVOID);
  79 static INT (WINAPI *pLCMapStringEx)(LPCWSTR, DWORD, LPCWSTR, INT, LPWSTR, INT, LPNLSVERSIONINFO, LPVOID, LPARAM);
  80 static LCID (WINAPI *pLocaleNameToLCID)(LPCWSTR, DWORD);
  81 static INT  (WINAPI *pLCIDToLocaleName)(LCID, LPWSTR, INT, DWORD);
  82 static INT (WINAPI *pFoldStringA)(DWORD, LPCSTR, INT, LPSTR, INT);
  83 static INT (WINAPI *pFoldStringW)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  84 static BOOL (WINAPI *pIsValidLanguageGroup)(LGRPID, DWORD);
  85 static INT (WINAPI *pIdnToNameprepUnicode)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  86 static INT (WINAPI *pIdnToAscii)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  87 static INT (WINAPI *pIdnToUnicode)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  88
  89 static void InitFunctionPointers(void)
  90 {
  91   hKernel32 = GetModuleHandleA("kernel32");
  92   pEnumSystemLanguageGroupsA = (void*)GetProcAddress(hKernel32, "EnumSystemLanguageGroupsA");
  93   pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
  94   pLocaleNameToLCID = (void*)GetProcAddress(hKernel32, "LocaleNameToLCID");
  95   pLCIDToLocaleName = (void*)GetProcAddress(hKernel32, "LCIDToLocaleName");
  96   pLCMapStringEx = (void*)GetProcAddress(hKernel32, "LCMapStringEx");
  97   pFoldStringA = (void*)GetProcAddress(hKernel32, "FoldStringA");
  98   pFoldStringW = (void*)GetProcAddress(hKernel32, "FoldStringW");
  99   pIsValidLanguageGroup = (void*)GetProcAddress(hKernel32, "IsValidLanguageGroup");
 100   pEnumUILanguagesA = (void*)GetProcAddress(hKernel32, "EnumUILanguagesA");
 101   pEnumSystemLocalesEx = (void*)GetProcAddress(hKernel32, "EnumSystemLocalesEx");
 102   pIdnToNameprepUnicode = (void*)GetProcAddress(hKernel32, "IdnToNameprepUnicode");
 103   pIdnToAscii = (void*)GetProcAddress(hKernel32, "IdnToAscii");
 104   pIdnToUnicode = (void*)GetProcAddress(hKernel32, "IdnToUnicode");
 105 }
 106
 107 #define eq(received, expected, label, type) \
 108         ok((received) == (expected), "%s: got " type " instead of " type "\n", \
 109            (label), (received), (expected))
 110
 111 #define BUFFER_SIZE    128
 112 #define COUNTOF(x) (sizeof(x)/sizeof(x)[0])
 113
 114 #define STRINGSA(x,y) strcpy(input, x); strcpy(Expected, y); SetLastError(0xdeadbeef); buffer[0] = '\0'
 115 #define EXPECT_LENA ok(ret == lstrlen(Expected)+1, "Expected Len %d, got %d\n", lstrlen(Expected)+1, ret)
 116 #define EXPECT_EQA ok(strncmp(buffer, Expected, strlen(Expected)) == 0, \
 117   "Expected '%s', got '%s'\n", Expected, buffer)
 118
 119 #define STRINGSW(x,y) MultiByteToWideChar(CP_ACP,0,x,-1,input,COUNTOF(input)); \
 120    MultiByteToWideChar(CP_ACP,0,y,-1,Expected,COUNTOF(Expected)); \
 121    SetLastError(0xdeadbeef); buffer[0] = '\0'
 122 #define EXPECT_LENW ok(ret == lstrlenW(Expected)+1, "Expected Len %d, got %d\n", lstrlenW(Expected)+1, ret)
 123 #define EXPECT_EQW  ok(strncmpW(buffer, Expected, strlenW(Expected)) == 0, "Bad conversion\n")
 124
 125 #define NUO LOCALE_NOUSEROVERRIDE
 126
 127 static void test_GetLocaleInfoA(void)
 128 {
 129   int ret;
 130   int len;
 131   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 132   char buffer[BUFFER_SIZE];
 133   char expected[BUFFER_SIZE];
 134
 135   ok(lcid == 0x409, "wrong LCID calculated - %d\n", lcid);
 136
 137   /* en and ar use SUBLANG_NEUTRAL, but GetLocaleInfo assume SUBLANG_DEFAULT
 138      Same is true for zh on pre-Vista, but on Vista and higher GetLocaleInfo
 139      assumes SUBLANG_NEUTRAL for zh */
 140   memset(expected, 0, COUNTOF(expected));
 141   len = GetLocaleInfoA(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
 142   SetLastError(0xdeadbeef);
 143   memset(buffer, 0, COUNTOF(buffer));
 144   ret = GetLocaleInfoA(LANG_ENGLISH, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
 145   ok((ret == len) && !lstrcmpA(buffer, expected),
 146       "got %d with '%s' (expected %d with '%s')\n",
 147       ret, buffer, len, expected);
 148
 149   memset(expected, 0, COUNTOF(expected));
 150   len = GetLocaleInfoA(MAKELANGID(LANG_ARABIC, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
 151   if (len) {
 152       SetLastError(0xdeadbeef);
 153       memset(buffer, 0, COUNTOF(buffer));
 154       ret = GetLocaleInfoA(LANG_ARABIC, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
 155       ok((ret == len) && !lstrcmpA(buffer, expected),
 156           "got %d with '%s' (expected %d with '%s')\n",
 157           ret, buffer, len, expected);
 158   }
 159   else
 160       win_skip("LANG_ARABIC not installed\n");
 161
 162   /* SUBLANG_DEFAULT is required for mlang.dll, but optional for GetLocaleInfo */
 163   memset(expected, 0, COUNTOF(expected));
 164   len = GetLocaleInfoA(MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
 165   SetLastError(0xdeadbeef);
 166   memset(buffer, 0, COUNTOF(buffer));
 167   ret = GetLocaleInfoA(LANG_GERMAN, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
 168   ok((ret == len) && !lstrcmpA(buffer, expected),
 169       "got %d with '%s' (expected %d with '%s')\n",
 170       ret, buffer, len, expected);
 171
 172
 173   /* HTMLKit and "Font xplorer lite" expect GetLocaleInfoA to
 174    * partially fill the buffer even if it is too short. See bug 637.
 175    */
 176   SetLastError(0xdeadbeef);
 177   memset(buffer, 0, COUNTOF(buffer));
 178   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 0);
 179   ok(ret == 7 && !buffer[0], "Expected len=7, got %d\n", ret);
 180
 181   SetLastError(0xdeadbeef);
 182   memset(buffer, 0, COUNTOF(buffer));
 183   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 3);
 184   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 185       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 186   ok(!strcmp(buffer, "Mon"), "Expected 'Mon', got '%s'\n", buffer);
 187
 188   SetLastError(0xdeadbeef);
 189   memset(buffer, 0, COUNTOF(buffer));
 190   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 10);
 191   ok(ret == 7, "Expected ret == 7, got %d, error %d\n", ret, GetLastError());
 192   ok(!strcmp(buffer, "Monday"), "Expected 'Monday', got '%s'\n", buffer);
 193 }
 194
 195 static void test_GetLocaleInfoW(void)
 196 {
 197   LCID lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 198   LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
 199   WCHAR bufferW[80], buffer2W[80];
 200   CHAR bufferA[80];
 201   DWORD ret;
 202   INT i;
 203
 204   ret = GetLocaleInfoW(lcid_en, LOCALE_SMONTHNAME1, bufferW, COUNTOF(bufferW));
 205   if (!ret) {
 206       win_skip("GetLocaleInfoW() isn't implemented\n");
 207       return;
 208   }
 209   ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1, bufferW, COUNTOF(bufferW));
 210   if (!ret) {
 211       win_skip("LANG_RUSSIAN locale data unavailable\n");
 212       return;
 213   }
 214   ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1|LOCALE_RETURN_GENITIVE_NAMES,
 215                        bufferW, COUNTOF(bufferW));
 216   if (!ret) {
 217       win_skip("LOCALE_RETURN_GENITIVE_NAMES isn't supported\n");
 218       return;
 219   }
 220
 221   /* LOCALE_RETURN_GENITIVE_NAMES isn't supported for GetLocaleInfoA */
 222   bufferA[0] = 'a';
 223   SetLastError(0xdeadbeef);
 224   ret = GetLocaleInfoA(lcid_ru, LOCALE_SMONTHNAME1|LOCALE_RETURN_GENITIVE_NAMES,
 225                        bufferA, COUNTOF(bufferA));
 226   ok(ret == 0, "LOCALE_RETURN_GENITIVE_NAMES should fail with GetLocaleInfoA\n");
 227   ok(bufferA[0] == 'a', "Expected buffer to be untouched\n");
 228   ok(GetLastError() == ERROR_INVALID_FLAGS,
 229      "Expected ERROR_INVALID_FLAGS, got %x\n", GetLastError());
 230
 231   bufferW[0] = 'a';
 232   SetLastError(0xdeadbeef);
 233   ret = GetLocaleInfoW(lcid_ru, LOCALE_RETURN_GENITIVE_NAMES,
 234                        bufferW, COUNTOF(bufferW));
 235   ok(ret == 0,
 236      "LOCALE_RETURN_GENITIVE_NAMES itself doesn't return anything, got %d\n", ret);
 237   ok(bufferW[0] == 'a', "Expected buffer to be untouched\n");
 238   ok(GetLastError() == ERROR_INVALID_FLAGS,
 239      "Expected ERROR_INVALID_FLAGS, got %x\n", GetLastError());
 240
 241   /* yes, test empty 13 month entry too */
 242   for (i = 0; i < 12; i++) {
 243       bufferW[0] = 0;
 244       ret = GetLocaleInfoW(lcid_ru, (LOCALE_SMONTHNAME1+i)|LOCALE_RETURN_GENITIVE_NAMES,
 245                            bufferW, COUNTOF(bufferW));
 246       ok(ret, "Expected non zero result\n");
 247       ok(ret == lstrlenW(bufferW)+1, "Expected actual length, got %d, length %d\n",
 248                                     ret, lstrlenW(bufferW));
 249       buffer2W[0] = 0;
 250       ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1+i,
 251                            buffer2W, COUNTOF(buffer2W));
 252       ok(ret, "Expected non zero result\n");
 253       ok(ret == lstrlenW(buffer2W)+1, "Expected actual length, got %d, length %d\n",
 254                                     ret, lstrlenW(buffer2W));
 255
 256       ok(lstrcmpW(bufferW, buffer2W) != 0,
 257            "Expected genitive name to differ, got the same for month %d\n", i+1);
 258
 259       /* for locale without genitive names nominative returned in both cases */
 260       bufferW[0] = 0;
 261       ret = GetLocaleInfoW(lcid_en, (LOCALE_SMONTHNAME1+i)|LOCALE_RETURN_GENITIVE_NAMES,
 262                            bufferW, COUNTOF(bufferW));
 263       ok(ret, "Expected non zero result\n");
 264       ok(ret == lstrlenW(bufferW)+1, "Expected actual length, got %d, length %d\n",
 265                                     ret, lstrlenW(bufferW));
 266       buffer2W[0] = 0;
 267       ret = GetLocaleInfoW(lcid_en, LOCALE_SMONTHNAME1+i,
 268                            buffer2W, COUNTOF(buffer2W));
 269       ok(ret, "Expected non zero result\n");
 270       ok(ret == lstrlenW(buffer2W)+1, "Expected actual length, got %d, length %d\n",
 271                                     ret, lstrlenW(buffer2W));
 272
 273       ok(lstrcmpW(bufferW, buffer2W) == 0,
 274          "Expected same names, got different for month %d\n", i+1);
 275   }
 276 }
 277
 278 static void test_GetTimeFormatA(void)
 279 {
 280   int ret;
 281   SYSTEMTIME  curtime;
 282   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 283   char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 284
 285   memset(&curtime, 2, sizeof(SYSTEMTIME));
 286   STRINGSA("tt HH':'mm'@'ss", ""); /* Invalid time */
 287   SetLastError(0xdeadbeef);
 288   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 289   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 290       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 291
 292   curtime.wHour = 8;
 293   curtime.wMinute = 56;
 294   curtime.wSecond = 13;
 295   curtime.wMilliseconds = 22;
 296   STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Valid time */
 297   SetLastError(0xdeadbeef);
 298   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 299   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 300   EXPECT_LENA; EXPECT_EQA;
 301
 302   /* MSDN: LOCALE_NOUSEROVERRIDE can't be specified with a format string */
 303   SetLastError(0xdeadbeef);
 304   ret = GetTimeFormatA(lcid, NUO|TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 305   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 306      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 307
 308   STRINGSA("tt HH':'mm'@'ss", "A"); /* Insufficient buffer */
 309   SetLastError(0xdeadbeef);
 310   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, 2);
 311   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 312       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 313
 314   STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Calculate length only */
 315   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, NULL, 0);
 316   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 317   EXPECT_LENA;
 318
 319   STRINGSA("", "8 AM"); /* TIME_NOMINUTESORSECONDS, default format */
 320   ret = GetTimeFormatA(lcid, NUO|TIME_NOMINUTESORSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 321   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 322   EXPECT_LENA; EXPECT_EQA;
 323
 324   STRINGSA("m1s2m3s4", ""); /* TIME_NOMINUTESORSECONDS/complex format */
 325   ret = GetTimeFormatA(lcid, TIME_NOMINUTESORSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 326   ok(ret == strlen(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 327   ok( !strcmp( buffer, "" ) || broken( !strcmp( buffer, "4" )), /* win9x */
 328       "Expected '', got '%s'\n", buffer );
 329
 330   STRINGSA("", "8:56 AM"); /* TIME_NOSECONDS/Default format */
 331   ret = GetTimeFormatA(lcid, NUO|TIME_NOSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 332   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 333   EXPECT_LENA; EXPECT_EQA;
 334
 335   STRINGSA("h:m:s tt", "8:56 AM"); /* TIME_NOSECONDS */
 336   strcpy(Expected, "8:56 AM");
 337   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 338   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 339   EXPECT_LENA; EXPECT_EQA;
 340
 341   STRINGSA("h.@:m.@:s.@:tt", "8.@:56AM"); /* Multiple delimiters */
 342   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 343   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 344   ok( !strcmp( buffer, "8.@:56AM" ) || broken( !strcmp( buffer, "8.@:56.@:AM" )) /* win9x */,
 345       "Expected '8.@:56AM', got '%s'\n", buffer );
 346
 347   STRINGSA("s1s2s3", ""); /* Duplicate tokens */
 348   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 349   ok(ret == strlen(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 350   ok( !strcmp( buffer, "" ) || broken( !strcmp( buffer, "3" )), /* win9x */
 351       "Expected '', got '%s'\n", buffer );
 352
 353   STRINGSA("t/tt", "A/AM"); /* AM time marker */
 354   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 355   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 356   EXPECT_LENA; EXPECT_EQA;
 357
 358   curtime.wHour = 13;
 359   STRINGSA("t/tt", "P/PM"); /* PM time marker */
 360   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 361   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 362   EXPECT_LENA; EXPECT_EQA;
 363
 364   STRINGSA("h1t2tt3m", "156"); /* TIME_NOTIMEMARKER: removes text around time marker token */
 365   ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 366   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 367   EXPECT_LENA; EXPECT_EQA;
 368
 369   STRINGSA("h:m:s tt", "13:56:13 PM"); /* TIME_FORCE24HOURFORMAT */
 370   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 371   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 372   EXPECT_LENA; EXPECT_EQA;
 373
 374   STRINGSA("h:m:s", "13:56:13"); /* TIME_FORCE24HOURFORMAT doesn't add time marker */
 375   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 376   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 377   EXPECT_LENA; EXPECT_EQA;
 378
 379   curtime.wHour = 14; /* change this to 14 or 2pm */
 380   curtime.wMinute = 5;
 381   curtime.wSecond = 3;
 382   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 */
 383   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 384   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 385   EXPECT_LENA; EXPECT_EQA;
 386
 387   curtime.wHour = 0;
 388   STRINGSA("h/H/hh/HH", "12/0/12/00"); /* "hh" and "HH" */
 389   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 390   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 391   EXPECT_LENA; EXPECT_EQA;
 392
 393   STRINGSA("h:m:s tt", "12:5:3 AM"); /* non-zero flags should fail with format, doesn't */
 394   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 395   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 396   EXPECT_LENA; EXPECT_EQA;
 397
 398   /* try to convert formatting strings with more than two letters
 399    * "h:hh:hhh:H:HH:HHH:m:mm:mmm:M:MM:MMM:s:ss:sss:S:SS:SSS"
 400    * NOTE: We expect any letter for which there is an upper case value
 401    *       we should see a replacement.  For letters that DO NOT have
 402    *       upper case values we should see NO REPLACEMENT.
 403    */
 404   curtime.wHour = 8;
 405   curtime.wMinute = 56;
 406   curtime.wSecond = 13;
 407   curtime.wMilliseconds = 22;
 408   STRINGSA("h:hh:hhh H:HH:HHH m:mm:mmm M:MM:MMM s:ss:sss S:SS:SSS",
 409            "8:08:08 8:08:08 56:56:56 M:MM:MMM 13:13:13 S:SS:SSS");
 410   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 411   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 412   EXPECT_LENA; EXPECT_EQA;
 413
 414   STRINGSA("h", "text"); /* Don't write to buffer if len is 0 */
 415   strcpy(buffer, "text");
 416   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, 0);
 417   ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
 418   EXPECT_EQA;
 419
 420   STRINGSA("h 'h' H 'H' HH 'HH' m 'm' s 's' t 't' tt 'tt'",
 421            "8 h 8 H 08 HH 56 m 13 s A t AM tt"); /* "'" preserves tokens */
 422   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 423   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 424   EXPECT_LENA; EXPECT_EQA;
 425
 426   STRINGSA("'''", "'"); /* invalid quoted string */
 427   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 428   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 429   EXPECT_LENA; EXPECT_EQA;
 430
 431   /* test that msdn suggested single quotation usage works as expected */
 432   STRINGSA("''''", "'"); /* single quote mark */
 433   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 434   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 435   EXPECT_LENA; EXPECT_EQA;
 436
 437   STRINGSA("''HHHHHH", "08"); /* Normal use */
 438   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 439   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 440   EXPECT_LENA; EXPECT_EQA;
 441
 442   /* and test for normal use of the single quotation mark */
 443   STRINGSA("'''HHHHHH'", "'HHHHHH"); /* Normal use */
 444   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 445   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 446   EXPECT_LENA; EXPECT_EQA;
 447
 448   STRINGSA("'''HHHHHH", "'HHHHHH"); /* Odd use */
 449   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 450   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 451   EXPECT_LENA; EXPECT_EQA;
 452
 453   STRINGSA("'123'tt", ""); /* TIME_NOTIMEMARKER drops literals too */
 454   ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 455   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 456   EXPECT_LENA; EXPECT_EQA;
 457
 458   curtime.wHour = 25;
 459   STRINGSA("'123'tt", ""); /* Invalid time */
 460   SetLastError(0xdeadbeef);
 461   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 462   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 463       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 464
 465   curtime.wHour = 12;
 466   curtime.wMonth = 60; /* Invalid */
 467   STRINGSA("h:m:s", "12:56:13"); /* Invalid date */
 468   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 469   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 470   EXPECT_LENA; EXPECT_EQA;
 471 }
 472
 473 static void test_GetDateFormatA(void)
 474 {
 475   int ret;
 476   SYSTEMTIME  curtime;
 477   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 478   LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
 479   char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 480   char Broken[BUFFER_SIZE];
 481   char short_day[10], month[10], genitive_month[10];
 482
 483   memset(&curtime, 2, sizeof(SYSTEMTIME)); /* Invalid time */
 484   STRINGSA("ddd',' MMM dd yy","");
 485   SetLastError(0xdeadbeef);
 486   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 487   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 488       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 489
 490   curtime.wYear = 2002;
 491   curtime.wMonth = 5;
 492   curtime.wDay = 4;
 493   curtime.wDayOfWeek = 3;
 494   STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Simple case */
 495   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 496   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 497   EXPECT_LENA; EXPECT_EQA;
 498
 499   /* Same as above but with LOCALE_NOUSEROVERRIDE */
 500   STRINGSA("ddd',' MMM dd yy",""); /* Simple case */
 501   SetLastError(0xdeadbeef);
 502   ret = GetDateFormatA(lcid, NUO, &curtime, input, buffer, COUNTOF(buffer));
 503   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 504      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 505   EXPECT_EQA;
 506
 507   STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Format containing "'" */
 508   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 509   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 510   EXPECT_LENA; EXPECT_EQA;
 511
 512   curtime.wHour = 36; /* Invalid */
 513   STRINGSA("ddd',' MMM dd ''''yy","Sat, May 04 '02"); /* Invalid time */
 514   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 515   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 516   EXPECT_LENA; EXPECT_EQA;
 517
 518   STRINGSA("ddd',' MMM dd ''''yy",""); /* Get size only */
 519   ret = GetDateFormatA(lcid, 0, &curtime, input, NULL, 0);
 520   ok(ret == 16, "Expected ret == 16, got %d, error %d\n", ret, GetLastError());
 521   EXPECT_EQA;
 522
 523   STRINGSA("ddd',' MMM dd ''''yy",""); /* Buffer too small */
 524   SetLastError(0xdeadbeef);
 525   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, 2);
 526   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 527       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 528
 529   STRINGSA("ddd',' MMM dd ''''yy","5/4/2002"); /* Default to DATE_SHORTDATE */
 530   ret = GetDateFormat(lcid, NUO, &curtime, NULL, buffer, COUNTOF(buffer));
 531   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 532   if (strncmp(buffer, Expected, strlen(Expected)) && strncmp(buffer, "5/4/02", strlen(Expected)) != 0)
 533           ok (0, "Expected '%s' or '5/4/02', got '%s'\n", Expected, buffer);
 534
 535   STRINGSA("ddd',' MMM dd ''''yy", "Saturday, May 04, 2002"); /* DATE_LONGDATE */
 536   ret = GetDateFormat(lcid, NUO|DATE_LONGDATE, &curtime, NULL, buffer, COUNTOF(buffer));
 537   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 538   EXPECT_LENA; EXPECT_EQA;
 539
 540   /* test for expected DATE_YEARMONTH behavior with null format */
 541   /* NT4 returns ERROR_INVALID_FLAGS for DATE_YEARMONTH */
 542   STRINGSA("ddd',' MMM dd ''''yy", ""); /* DATE_YEARMONTH */
 543   SetLastError(0xdeadbeef);
 544   ret = GetDateFormat(lcid, NUO|DATE_YEARMONTH, &curtime, input, buffer, COUNTOF(buffer));
 545   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 546      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 547   EXPECT_EQA;
 548
 549   /* Test that using invalid DATE_* flags results in the correct error */
 550   /* and return values */
 551   STRINGSA("m/d/y", ""); /* Invalid flags */
 552   SetLastError(0xdeadbeef);
 553   ret = GetDateFormat(lcid, DATE_YEARMONTH|DATE_SHORTDATE|DATE_LONGDATE,
 554                       &curtime, input, buffer, COUNTOF(buffer));
 555   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 556      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 557
 558   ret = GetDateFormat(lcid_ru, 0, &curtime, "ddMMMM", buffer, COUNTOF(buffer));
 559   if (!ret)
 560   {
 561     win_skip("LANG_RUSSIAN locale data unavailable\n");
 562     return;
 563   }
 564
 565   /* month part should be in genitive form */
 566   strcpy(genitive_month, buffer + 2);
 567   ret = GetDateFormat(lcid_ru, 0, &curtime, "MMMM", buffer, COUNTOF(buffer));
 568   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 569   strcpy(month, buffer);
 570   ok(strcmp(genitive_month, month) != 0, "Expected different month forms\n");
 571
 572   ret = GetDateFormat(lcid_ru, 0, &curtime, "ddd", buffer, COUNTOF(buffer));
 573   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 574   strcpy(short_day, buffer);
 575
 576   STRINGSA("dd MMMMddd dd", "");
 577   sprintf(Expected, "04 %s%s 04", genitive_month, short_day);
 578   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 579   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 580   EXPECT_EQA;
 581
 582   STRINGSA("MMMMddd dd", "");
 583   sprintf(Expected, "%s%s 04", month, short_day);
 584   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 585   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 586   EXPECT_EQA;
 587
 588   STRINGSA("MMMMddd", "");
 589   sprintf(Expected, "%s%s", month, short_day);
 590   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 591   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 592   EXPECT_EQA;
 593
 594   STRINGSA("MMMMdd", "");
 595   sprintf(Expected, "%s04", genitive_month);
 596   sprintf(Broken, "%s04", month);
 597   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 598   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 599   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 600      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 601      "Expected '%s', got '%s'\n", Expected, buffer);
 602
 603   STRINGSA("MMMMdd ddd", "");
 604   sprintf(Expected, "%s04 %s", genitive_month, short_day);
 605   sprintf(Broken, "%s04 %s", month, short_day);
 606   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 607   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 608   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 609      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 610      "Expected '%s', got '%s'\n", Expected, buffer);
 611
 612   STRINGSA("dd dddMMMM", "");
 613   sprintf(Expected, "04 %s%s", short_day, month);
 614   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 615   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 616   EXPECT_EQA;
 617
 618   STRINGSA("dd dddMMMM ddd MMMMdd", "");
 619   sprintf(Expected, "04 %s%s %s %s04", short_day, month, short_day, genitive_month);
 620   sprintf(Broken, "04 %s%s %s %s04", short_day, month, short_day, month);
 621   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 622   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 623   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 624      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 625      "Expected '%s', got '%s'\n", Expected, buffer);
 626
 627   /* with literal part */
 628   STRINGSA("ddd',' MMMM dd", "");
 629   sprintf(Expected, "%s, %s 04", short_day, genitive_month);
 630   sprintf(Broken, "%s, %s 04", short_day, month);
 631   ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
 632   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 633   ok(strncmp(buffer, Expected, strlen(Expected)) == 0 ||
 634      broken(strncmp(buffer, Broken, strlen(Broken)) == 0) /* nt4 */,
 635      "Expected '%s', got '%s'\n", Expected, buffer);
 636 }
 637
 638 static void test_GetDateFormatW(void)
 639 {
 640   int ret;
 641   SYSTEMTIME  curtime;
 642   WCHAR buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 643   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 644
 645   STRINGSW("",""); /* If flags is not zero then format must be NULL */
 646   ret = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, DATE_LONGDATE, NULL,
 647                        input, buffer, COUNTOF(buffer));
 648   if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 649   {
 650     win_skip("GetDateFormatW is not implemented\n");
 651     return;
 652   }
 653   ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
 654      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 655   EXPECT_EQW;
 656
 657   STRINGSW("",""); /* NULL buffer, len > 0 */
 658   SetLastError(0xdeadbeef);
 659   ret = GetDateFormatW (lcid, 0, NULL, input, NULL, COUNTOF(buffer));
 660   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 661       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 662
 663   STRINGSW("",""); /* NULL buffer, len == 0 */
 664   ret = GetDateFormatW (lcid, 0, NULL, input, NULL, 0);
 665   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 666   EXPECT_LENW; EXPECT_EQW;
 667
 668   curtime.wYear = 2002;
 669   curtime.wMonth = 10;
 670   curtime.wDay = 23;
 671   curtime.wDayOfWeek = 45612; /* Should be 3 - Wednesday */
 672   curtime.wHour = 65432; /* Invalid */
 673   curtime.wMinute = 34512; /* Invalid */
 674   curtime.wSecond = 65535; /* Invalid */
 675   curtime.wMilliseconds = 12345;
 676   STRINGSW("dddd d MMMM yyyy","Wednesday 23 October 2002"); /* Incorrect DOW and time */
 677   ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 678   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 679   EXPECT_LENW; EXPECT_EQW;
 680
 681   /* Limit tests */
 682
 683   curtime.wYear = 1601;
 684   curtime.wMonth = 1;
 685   curtime.wDay = 1;
 686   curtime.wDayOfWeek = 0; /* Irrelevant */
 687   curtime.wHour = 0;
 688   curtime.wMinute = 0;
 689   curtime.wSecond = 0;
 690   curtime.wMilliseconds = 0;
 691   STRINGSW("dddd d MMMM yyyy","Monday 1 January 1601");
 692   SetLastError(0xdeadbeef);
 693   ret = GetDateFormatW (lcid, 0, &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   curtime.wYear = 1600;
 698   curtime.wMonth = 12;
 699   curtime.wDay = 31;
 700   curtime.wDayOfWeek = 0; /* Irrelevant */
 701   curtime.wHour = 23;
 702   curtime.wMinute = 59;
 703   curtime.wSecond = 59;
 704   curtime.wMilliseconds = 999;
 705   STRINGSW("dddd d MMMM yyyy","Friday 31 December 1600");
 706   SetLastError(0xdeadbeef);
 707   ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 708   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 709       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 710 }
 711
 712
 713 #define CY_POS_LEFT  0
 714 #define CY_POS_RIGHT 1
 715 #define CY_POS_LEFT_SPACE  2
 716 #define CY_POS_RIGHT_SPACE 3
 717
 718 static void test_GetCurrencyFormatA(void)
 719 {
 720   static char szDot[] = { '.', '\0' };
 721   static char szComma[] = { ',', '\0' };
 722   static char szDollar[] = { '$', '\0' };
 723   int ret;
 724   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 725   char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
 726   CURRENCYFMTA format;
 727
 728   memset(&format, 0, sizeof(format));
 729
 730   STRINGSA("23",""); /* NULL output, length > 0 --> Error */
 731   SetLastError(0xdeadbeef);
 732   ret = GetCurrencyFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
 733   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 734       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 735
 736   STRINGSA("23,53",""); /* Invalid character --> Error */
 737   SetLastError(0xdeadbeef);
 738   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 739   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 740       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 741
 742   STRINGSA("--",""); /* Double '-' --> Error */
 743   SetLastError(0xdeadbeef);
 744   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 745   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 746       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 747
 748   STRINGSA("0-",""); /* Trailing '-' --> Error */
 749   SetLastError(0xdeadbeef);
 750   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 751   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 752       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 753
 754   STRINGSA("0..",""); /* Double '.' --> Error */
 755   SetLastError(0xdeadbeef);
 756   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 757   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 758       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 759
 760   STRINGSA(" 0.1",""); /* Leading space --> Error */
 761   SetLastError(0xdeadbeef);
 762   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 763   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 764       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 765
 766   STRINGSA("1234","$"); /* Length too small --> Write up to length chars */
 767   SetLastError(0xdeadbeef);
 768   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, 2);
 769   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
 770       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
 771
 772   STRINGSA("2353",""); /* Format and flags given --> Error */
 773   SetLastError(0xdeadbeef);
 774   ret = GetCurrencyFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
 775   ok( !ret, "Expected ret == 0, got %d\n", ret);
 776   ok( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER,
 777       "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
 778
 779   STRINGSA("2353",""); /* Invalid format --> Error */
 780   SetLastError(0xdeadbeef);
 781   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 782   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 783       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 784
 785   STRINGSA("2353","$2,353.00"); /* Valid number */
 786   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 787   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 788   EXPECT_LENA; EXPECT_EQA;
 789
 790   STRINGSA("-2353","($2,353.00)"); /* Valid negative number */
 791   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 792   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 793   EXPECT_LENA; EXPECT_EQA;
 794
 795   STRINGSA("2353.1","$2,353.10"); /* Valid real number */
 796   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 797   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 798   EXPECT_LENA; EXPECT_EQA;
 799
 800   STRINGSA("2353.111","$2,353.11"); /* Too many DP --> Truncated */
 801   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 802   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 803   EXPECT_LENA; EXPECT_EQA;
 804
 805   STRINGSA("2353.119","$2,353.12");  /* Too many DP --> Rounded */
 806   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 807   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 808   EXPECT_LENA; EXPECT_EQA;
 809
 810   format.NumDigits = 0; /* No decimal separator */
 811   format.LeadingZero = 0;
 812   format.Grouping = 0;  /* No grouping char */
 813   format.NegativeOrder = 0;
 814   format.PositiveOrder = CY_POS_LEFT;
 815   format.lpDecimalSep = szDot;
 816   format.lpThousandSep = szComma;
 817   format.lpCurrencySymbol = szDollar;
 818
 819   STRINGSA("2353","$2353"); /* No decimal or grouping chars expected */
 820   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 821   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 822   EXPECT_LENA; EXPECT_EQA;
 823
 824   format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
 825   STRINGSA("2353","$2353.0");
 826   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 827   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 828   EXPECT_LENA; EXPECT_EQA;
 829
 830   format.Grouping = 2; /* Group by 100's */
 831   STRINGSA("2353","$23,53.0");
 832   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 833   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 834   EXPECT_LENA; EXPECT_EQA;
 835
 836   STRINGSA("235","$235.0"); /* Grouping of a positive number */
 837   format.Grouping = 3;
 838   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 839   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 840   EXPECT_LENA; EXPECT_EQA;
 841
 842   STRINGSA("-235","$-235.0"); /* Grouping of a negative number */
 843   format.NegativeOrder = 2;
 844   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 845   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 846   EXPECT_LENA; EXPECT_EQA;
 847
 848   format.LeadingZero = 1; /* Always provide leading zero */
 849   STRINGSA(".5","$0.5");
 850   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 851   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 852   EXPECT_LENA; EXPECT_EQA;
 853
 854   format.PositiveOrder = CY_POS_RIGHT;
 855   STRINGSA("1","1.0$");
 856   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 857   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 858   EXPECT_LENA; EXPECT_EQA;
 859
 860   format.PositiveOrder = CY_POS_LEFT_SPACE;
 861   STRINGSA("1","$ 1.0");
 862   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 863   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 864   EXPECT_LENA; EXPECT_EQA;
 865
 866   format.PositiveOrder = CY_POS_RIGHT_SPACE;
 867   STRINGSA("1","1.0 $");
 868   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 869   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 870   EXPECT_LENA; EXPECT_EQA;
 871
 872   format.NegativeOrder = 0;
 873   STRINGSA("-1","($1.0)");
 874   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 875   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 876   EXPECT_LENA; EXPECT_EQA;
 877
 878   format.NegativeOrder = 1;
 879   STRINGSA("-1","-$1.0");
 880   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 881   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 882   EXPECT_LENA; EXPECT_EQA;
 883
 884   format.NegativeOrder = 2;
 885   STRINGSA("-1","$-1.0");
 886   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 887   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 888   EXPECT_LENA; EXPECT_EQA;
 889
 890   format.NegativeOrder = 3;
 891   STRINGSA("-1","$1.0-");
 892   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 893   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 894   EXPECT_LENA; EXPECT_EQA;
 895
 896   format.NegativeOrder = 4;
 897   STRINGSA("-1","(1.0$)");
 898   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 899   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 900   EXPECT_LENA; EXPECT_EQA;
 901
 902   format.NegativeOrder = 5;
 903   STRINGSA("-1","-1.0$");
 904   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 905   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 906   EXPECT_LENA; EXPECT_EQA;
 907
 908   format.NegativeOrder = 6;
 909   STRINGSA("-1","1.0-$");
 910   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 911   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 912   EXPECT_LENA; EXPECT_EQA;
 913
 914   format.NegativeOrder = 7;
 915   STRINGSA("-1","1.0$-");
 916   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 917   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 918   EXPECT_LENA; EXPECT_EQA;
 919
 920   format.NegativeOrder = 8;
 921   STRINGSA("-1","-1.0 $");
 922   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 923   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 924   EXPECT_LENA; EXPECT_EQA;
 925
 926   format.NegativeOrder = 9;
 927   STRINGSA("-1","-$ 1.0");
 928   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 929   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 930   EXPECT_LENA; EXPECT_EQA;
 931
 932   format.NegativeOrder = 10;
 933   STRINGSA("-1","1.0 $-");
 934   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 935   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 936   EXPECT_LENA; EXPECT_EQA;
 937
 938   format.NegativeOrder = 11;
 939   STRINGSA("-1","$ 1.0-");
 940   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 941   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 942   EXPECT_LENA; EXPECT_EQA;
 943
 944   format.NegativeOrder = 12;
 945   STRINGSA("-1","$ -1.0");
 946   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 947   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 948   EXPECT_LENA; EXPECT_EQA;
 949
 950   format.NegativeOrder = 13;
 951   STRINGSA("-1","1.0- $");
 952   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 953   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 954   EXPECT_LENA; EXPECT_EQA;
 955
 956   format.NegativeOrder = 14;
 957   STRINGSA("-1","($ 1.0)");
 958   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 959   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 960   EXPECT_LENA; EXPECT_EQA;
 961
 962   format.NegativeOrder = 15;
 963   STRINGSA("-1","(1.0 $)");
 964   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 965   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
 966   EXPECT_LENA; EXPECT_EQA;
 967 }
 968
 969 #define NEG_PARENS      0 /* "(1.1)" */
 970 #define NEG_LEFT        1 /* "-1.1"  */
 971 #define NEG_LEFT_SPACE  2 /* "- 1.1" */
 972 #define NEG_RIGHT       3 /* "1.1-"  */
 973 #define NEG_RIGHT_SPACE 4 /* "1.1 -" */
 974
 975 static void test_GetNumberFormatA(void)
 976 {
 977   static char szDot[] = { '.', '\0' };
 978   static char szComma[] = { ',', '\0' };
 979   int ret;
 980   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 981   char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
 982   NUMBERFMTA format;
 983
 984   memset(&format, 0, sizeof(format));
 985
 986   STRINGSA("23",""); /* NULL output, length > 0 --> Error */
 987   SetLastError(0xdeadbeef);
 988   ret = GetNumberFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
 989   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 990       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 991
 992   STRINGSA("23,53",""); /* Invalid character --> Error */
 993   SetLastError(0xdeadbeef);
 994   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 995   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
 996       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
 997
 998   STRINGSA("--",""); /* Double '-' --> Error */
 999   SetLastError(0xdeadbeef);
1000   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1001   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1002       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1003
1004   STRINGSA("0-",""); /* Trailing '-' --> Error */
1005   SetLastError(0xdeadbeef);
1006   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1007   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1008       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1009
1010   STRINGSA("0..",""); /* Double '.' --> Error */
1011   SetLastError(0xdeadbeef);
1012   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1013   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1014       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1015
1016   STRINGSA(" 0.1",""); /* Leading space --> Error */
1017   SetLastError(0xdeadbeef);
1018   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
1019   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1020       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1021
1022   STRINGSA("1234","1"); /* Length too small --> Write up to length chars */
1023   SetLastError(0xdeadbeef);
1024   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, 2);
1025   ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1026       "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
1027
1028   STRINGSA("2353",""); /* Format and flags given --> Error */
1029   SetLastError(0xdeadbeef);
1030   ret = GetNumberFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
1031   ok( !ret, "Expected ret == 0, got %d\n", ret);
1032   ok( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER,
1033       "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1034
1035   STRINGSA("2353",""); /* Invalid format --> Error */
1036   SetLastError(0xdeadbeef);
1037   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1038   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1039       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1040
1041   STRINGSA("2353","2,353.00"); /* Valid number */
1042   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1043   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1044   EXPECT_LENA; EXPECT_EQA;
1045
1046   STRINGSA("-2353","-2,353.00"); /* Valid negative number */
1047   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1048   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1049   EXPECT_LENA; EXPECT_EQA;
1050
1051   STRINGSA("-353","-353.00"); /* test for off by one error in grouping */
1052   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1053   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1054   EXPECT_LENA; EXPECT_EQA;
1055
1056   STRINGSA("2353.1","2,353.10"); /* Valid real number */
1057   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1058   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1059   EXPECT_LENA; EXPECT_EQA;
1060
1061   STRINGSA("2353.111","2,353.11"); /* Too many DP --> Truncated */
1062   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1063   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1064   EXPECT_LENA; EXPECT_EQA;
1065
1066   STRINGSA("2353.119","2,353.12");  /* Too many DP --> Rounded */
1067   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1068   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1069   EXPECT_LENA; EXPECT_EQA;
1070
1071   format.NumDigits = 0; /* No decimal separator */
1072   format.LeadingZero = 0;
1073   format.Grouping = 0;  /* No grouping char */
1074   format.NegativeOrder = 0;
1075   format.lpDecimalSep = szDot;
1076   format.lpThousandSep = szComma;
1077
1078   STRINGSA("2353","2353"); /* No decimal or grouping chars expected */
1079   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1080   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1081   EXPECT_LENA; EXPECT_EQA;
1082
1083   format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
1084   STRINGSA("2353","2353.0");
1085   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1086   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1087   EXPECT_LENA; EXPECT_EQA;
1088
1089   format.Grouping = 2; /* Group by 100's */
1090   STRINGSA("2353","23,53.0");
1091   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1092   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1093   EXPECT_LENA; EXPECT_EQA;
1094
1095   STRINGSA("235","235.0"); /* Grouping of a positive number */
1096   format.Grouping = 3;
1097   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1098   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1099   EXPECT_LENA; EXPECT_EQA;
1100
1101   STRINGSA("-235","-235.0"); /* Grouping of a negative number */
1102   format.NegativeOrder = NEG_LEFT;
1103   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1104   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1105   EXPECT_LENA; EXPECT_EQA;
1106
1107   format.LeadingZero = 1; /* Always provide leading zero */
1108   STRINGSA(".5","0.5");
1109   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1110   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1111   EXPECT_LENA; EXPECT_EQA;
1112
1113   format.NegativeOrder = NEG_PARENS;
1114   STRINGSA("-1","(1.0)");
1115   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1116   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1117   EXPECT_LENA; EXPECT_EQA;
1118
1119   format.NegativeOrder = NEG_LEFT;
1120   STRINGSA("-1","-1.0");
1121   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1122   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1123   EXPECT_LENA; EXPECT_EQA;
1124
1125   format.NegativeOrder = NEG_LEFT_SPACE;
1126   STRINGSA("-1","- 1.0");
1127   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1128   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1129   EXPECT_LENA; EXPECT_EQA;
1130
1131   format.NegativeOrder = NEG_RIGHT;
1132   STRINGSA("-1","1.0-");
1133   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1134   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1135   EXPECT_LENA; EXPECT_EQA;
1136
1137   format.NegativeOrder = NEG_RIGHT_SPACE;
1138   STRINGSA("-1","1.0 -");
1139   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1140   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1141   EXPECT_LENA; EXPECT_EQA;
1142
1143   lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
1144
1145   if (IsValidLocale(lcid, 0))
1146   {
1147     STRINGSA("-12345","-12 345,00"); /* Try French formatting */
1148     Expected[3] = 160; /* Non breaking space */
1149     ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1150     ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1151     EXPECT_LENA; EXPECT_EQA;
1152   }
1153 }
1154
1155 struct comparestringa_entry {
1156   LCID lcid;
1157   DWORD flags;
1158   const char *first;
1159   int first_len;
1160   const char *second;
1161   int second_len;
1162   int ret;
1163 };
1164
1165 static const struct comparestringa_entry comparestringa_data[] = {
1166   { LOCALE_SYSTEM_DEFAULT, 0, "EndDialog", -1, "_Property", -1, CSTR_GREATER_THAN },
1167   { LOCALE_SYSTEM_DEFAULT, 0, "osp_vba.sreg0070", -1, "_IEWWBrowserComp", -1, CSTR_GREATER_THAN },
1168   { LOCALE_SYSTEM_DEFAULT, 0, "r", -1, "\\", -1, CSTR_GREATER_THAN },
1169   { LOCALE_SYSTEM_DEFAULT, 0, "osp_vba.sreg0031", -1, "OriginalDatabase", -1, CSTR_GREATER_THAN },
1170   { LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aaa", -1, CSTR_GREATER_THAN },
1171   { LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aab", -1, CSTR_LESS_THAN },
1172   { LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "Aab", -1, CSTR_LESS_THAN },
1173   { LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "Aab", -1, CSTR_LESS_THAN },
1174   { LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "A.ab", -1, CSTR_LESS_THAN },
1175   { LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "AB", -1, CSTR_LESS_THAN },
1176   { LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "Aab", -1, CSTR_LESS_THAN },
1177   { LOCALE_SYSTEM_DEFAULT, 0, "aB", -1, "Aab", -1, CSTR_GREATER_THAN },
1178   { LOCALE_SYSTEM_DEFAULT, 0, "Ba", -1, "bab", -1, CSTR_LESS_THAN },
1179   { LOCALE_SYSTEM_DEFAULT, 0, "{100}{83}{71}{71}{71}", -1, "Global_DataAccess_JRO", -1, CSTR_LESS_THAN },
1180   { LOCALE_SYSTEM_DEFAULT, 0, "a", -1, "{", -1, CSTR_GREATER_THAN },
1181   { LOCALE_SYSTEM_DEFAULT, 0, "A", -1, "{", -1, CSTR_GREATER_THAN },
1182   { LOCALE_SYSTEM_DEFAULT, 0, "3.5", 0, "4.0", -1, CSTR_LESS_THAN },
1183   { LOCALE_SYSTEM_DEFAULT, 0, "3.5", -1, "4.0", -1, CSTR_LESS_THAN },
1184   { LOCALE_SYSTEM_DEFAULT, 0, "3.520.4403.2", -1, "4.0.2927.10", -1, CSTR_LESS_THAN },
1185   /* hyphen and apostrophe are treated differently depending on whether SORT_STRINGSORT specified or not */
1186   { LOCALE_SYSTEM_DEFAULT, 0, "-o", -1, "/m", -1, CSTR_GREATER_THAN },
1187   { LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "-o", -1, CSTR_LESS_THAN },
1188   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-o", -1, "/m", -1, CSTR_LESS_THAN },
1189   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "-o", -1, CSTR_GREATER_THAN },
1190   { LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "/m", -1, CSTR_GREATER_THAN },
1191   { LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "'o", -1, CSTR_LESS_THAN },
1192   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "/m", -1, CSTR_LESS_THAN },
1193   { LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "'o", -1, CSTR_GREATER_THAN },
1194   { LOCALE_SYSTEM_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ", 9, CSTR_EQUAL },
1195   { LOCALE_SYSTEM_DEFAULT, 0, "aLuZkUtZ", 7, "aLuZkUtZ\0A", 10, CSTR_LESS_THAN }
1196 };
1197
1198 static void test_CompareStringA(void)
1199 {
1200   int ret, i;
1201   LCID lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
1202
1203   for (i = 0; i < sizeof(comparestringa_data)/sizeof(struct comparestringa_entry); i++)
1204   {
1205       const struct comparestringa_entry *entry = &comparestringa_data[i];
1206
1207       ret = CompareStringA(entry->lcid, entry->flags, entry->first, entry->first_len,
1208           entry->second, entry->second_len);
1209       ok(ret == entry->ret, "%d: got %d, expected %d\n", i, ret, entry->ret);
1210   }
1211
1212   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "Salute", -1);
1213   ok (ret == CSTR_LESS_THAN, "(Salut/Salute) Expected CSTR_LESS_THAN, got %d\n", ret);
1214
1215   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "SaLuT", -1);
1216   ok (ret == CSTR_EQUAL, "(Salut/SaLuT) Expected CSTR_EQUAL, got %d\n", ret);
1217
1218   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "hola", -1);
1219   ok (ret == CSTR_GREATER_THAN, "(Salut/hola) Expected CSTR_GREATER_THAN, got %d\n", ret);
1220
1221   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
1222   ok (ret == CSTR_LESS_THAN, "(haha/hoho) Expected CSTR_LESS_THAN, got %d\n", ret);
1223
1224   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
1225
1226   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
1227   ok (ret == CSTR_LESS_THAN, "(haha/hoho) Expected CSTR_LESS_THAN, got %d\n", ret);
1228
1229   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", 0);
1230   ok (ret == CSTR_GREATER_THAN, "(haha/hoho) Expected CSTR_GREATER_THAN, got %d\n", ret);
1231
1232     ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", 5, "saLuT", -1);
1233     ok (ret == CSTR_EQUAL, "(Salut/saLuT) Expected CSTR_EQUAL, got %d\n", ret);
1234
1235     /* test for CompareStringA flags */
1236     SetLastError(0xdeadbeef);
1237     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0x8, "NULL", -1, "NULL", -1);
1238     ok(GetLastError() == ERROR_INVALID_FLAGS,
1239         "unexpected error code %d\n", GetLastError());
1240     ok(!ret, "CompareStringA must fail with invalid flag\n");
1241
1242     SetLastError(0xdeadbeef);
1243     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, LOCALE_USE_CP_ACP, "NULL", -1, "NULL", -1);
1244     ok(GetLastError() == 0xdeadbeef, "unexpected error code %d\n", GetLastError());
1245     ok(ret == CSTR_EQUAL, "CompareStringA error: %d != CSTR_EQUAL\n", ret);
1246     /* end of test for CompareStringA flags */
1247
1248     ret = lstrcmpA("", "");
1249     ok (ret == 0, "lstrcmpA(\"\", \"\") should return 0, got %d\n", ret);
1250
1251     ret = lstrcmpA(NULL, NULL);
1252     ok (ret == 0 || broken(ret == -2) /* win9x */, "lstrcmpA(NULL, NULL) should return 0, got %d\n", ret);
1253
1254     ret = lstrcmpA("", NULL);
1255     ok (ret == 1 || broken(ret == -2) /* win9x */, "lstrcmpA(\"\", NULL) should return 1, got %d\n", ret);
1256
1257     ret = lstrcmpA(NULL, "");
1258     ok (ret == -1 || broken(ret == -2) /* win9x */, "lstrcmpA(NULL, \"\") should return -1, got %d\n", ret);
1259
1260
1261     if (0) { /* this requires collation table patch to make it MS compatible */
1262     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "-o", -1 );
1263     ok(ret == CSTR_LESS_THAN, "'o vs -o expected CSTR_LESS_THAN, got %d\n", ret);
1264
1265     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "-o", -1 );
1266     ok(ret == CSTR_LESS_THAN, "'o vs -o expected CSTR_LESS_THAN, got %d\n", ret);
1267
1268     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'", -1, "-", -1 );
1269     ok(ret == CSTR_LESS_THAN, "' vs - expected CSTR_LESS_THAN, got %d\n", ret);
1270
1271     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'", -1, "-", -1 );
1272     ok(ret == CSTR_LESS_THAN, "' vs - expected CSTR_LESS_THAN, got %d\n", ret);
1273
1274     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "/m", -1 );
1275     ok(ret == CSTR_GREATER_THAN, "`o vs /m CSTR_GREATER_THAN got %d\n", ret);
1276
1277     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "`o", -1 );
1278     ok(ret == CSTR_LESS_THAN, "/m vs `o expected CSTR_LESS_THAN, got %d\n", ret);
1279
1280     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "/m", -1 );
1281     ok(ret == CSTR_GREATER_THAN, "`o vs /m CSTR_GREATER_THAN got %d\n", ret);
1282
1283     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "`o", -1 );
1284     ok(ret == CSTR_LESS_THAN, "/m vs `o expected CSTR_LESS_THAN, got %d\n", ret);
1285
1286     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "-m", -1 );
1287     ok(ret == CSTR_LESS_THAN, "`o vs -m expected CSTR_LESS_THAN, got %d\n", ret);
1288
1289     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "-m", -1, "`o", -1 );
1290     ok(ret == CSTR_GREATER_THAN, "-m vs `o CSTR_GREATER_THAN got %d\n", ret);
1291
1292     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "-m", -1 );
1293     ok(ret == CSTR_GREATER_THAN, "`o vs -m CSTR_GREATER_THAN got %d\n", ret);
1294
1295     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-m", -1, "`o", -1 );
1296     ok(ret == CSTR_LESS_THAN, "-m vs `o expected CSTR_LESS_THAN, got %d\n", ret);
1297     }
1298
1299
1300     /* WinXP handles embedded NULLs differently than earlier versions */
1301     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ\0A", 10);
1302     ok(ret == CSTR_LESS_THAN || ret == CSTR_EQUAL, "aLuZkUtZ vs aLuZkUtZ\\0A expected CSTR_LESS_THAN or CSTR_EQUAL, got %d\n", ret);
1303
1304     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLu\0ZkUtZ", 8, "aLu\0ZkUtZ\0A", 10);
1305     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);
1306
1307     ret = CompareStringA(lcid, 0, "a\0b", -1, "a", -1);
1308     ok(ret == CSTR_EQUAL, "a vs a expected CSTR_EQUAL, got %d\n", ret);
1309
1310     ret = CompareStringA(lcid, 0, "a\0b", 4, "a", 2);
1311     ok(ret == CSTR_EQUAL || /* win2k */
1312        ret == CSTR_GREATER_THAN,
1313        "a\\0b vs a expected CSTR_EQUAL or CSTR_GREATER_THAN, got %d\n", ret);
1314
1315     ret = CompareStringA(lcid, 0, "\2", 2, "\1", 2);
1316     todo_wine ok(ret != CSTR_EQUAL, "\\2 vs \\1 expected unequal\n");
1317
1318     ret = CompareStringA(lcid, NORM_IGNORECASE | LOCALE_USE_CP_ACP, "#", -1, ".", -1);
1319     todo_wine ok(ret == CSTR_LESS_THAN, "\"#\" vs \".\" expected CSTR_LESS_THAN, got %d\n", ret);
1320
1321     ret = CompareStringA(lcid, NORM_IGNORECASE, "_", -1, ".", -1);
1322     todo_wine ok(ret == CSTR_GREATER_THAN, "\"_\" vs \".\" expected CSTR_GREATER_THAN, got %d\n", ret);
1323
1324     ret = lstrcmpi("#", ".");
1325     todo_wine ok(ret == -1, "\"#\" vs \".\" expected -1, got %d\n", ret);
1326
1327     lcid = MAKELCID(MAKELANGID(LANG_POLISH, SUBLANG_DEFAULT), SORT_DEFAULT);
1328
1329     /* \xB9 character lies between a and b */
1330     ret = CompareStringA(lcid, 0, "a", 1, "\xB9", 1);
1331     todo_wine ok(ret == CSTR_LESS_THAN, "\'\\xB9\' character should be greater than \'a\'\n");
1332     ret = CompareStringA(lcid, 0, "\xB9", 1, "b", 1);
1333     ok(ret == CSTR_LESS_THAN, "\'\\xB9\' character should be smaller than \'b\'\n");
1334 }
1335
1336 static void test_LCMapStringA(void)
1337 {
1338     int ret, ret2;
1339     char buf[256], buf2[256];
1340     static const char upper_case[] = "\tJUST! A, TEST; STRING 1/*+-.\r\n";
1341     static const char lower_case[] = "\tjust! a, test; string 1/*+-.\r\n";
1342     static const char symbols_stripped[] = "justateststring1";
1343
1344     SetLastError(0xdeadbeef);
1345     ret = LCMapStringA(LOCALE_USER_DEFAULT, LOCALE_USE_CP_ACP | LCMAP_LOWERCASE,
1346                        lower_case, -1, buf, sizeof(buf));
1347     ok(ret == lstrlenA(lower_case) + 1,
1348        "ret %d, error %d, expected value %d\n",
1349        ret, GetLastError(), lstrlenA(lower_case) + 1);
1350     ok(!memcmp(buf, lower_case, ret), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1351
1352     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | LCMAP_UPPERCASE,
1353                        upper_case, -1, buf, sizeof(buf));
1354     ok(!ret, "LCMAP_LOWERCASE and LCMAP_UPPERCASE are mutually exclusive\n");
1355     ok(GetLastError() == ERROR_INVALID_FLAGS,
1356        "unexpected error code %d\n", GetLastError());
1357
1358     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_HIRAGANA | LCMAP_KATAKANA,
1359                        upper_case, -1, buf, sizeof(buf));
1360     ok(!ret, "LCMAP_HIRAGANA and LCMAP_KATAKANA are mutually exclusive\n");
1361     ok(GetLastError() == ERROR_INVALID_FLAGS,
1362        "unexpected error code %d\n", GetLastError());
1363
1364     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_HALFWIDTH | LCMAP_FULLWIDTH,
1365                        upper_case, -1, buf, sizeof(buf));
1366     ok(!ret, "LCMAP_HALFWIDTH | LCMAP_FULLWIDTH are mutually exclusive\n");
1367     ok(GetLastError() == ERROR_INVALID_FLAGS,
1368        "unexpected error code %d\n", GetLastError());
1369
1370     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE,
1371                        upper_case, -1, buf, sizeof(buf));
1372     ok(!ret, "LCMAP_TRADITIONAL_CHINESE and LCMAP_SIMPLIFIED_CHINESE are mutually exclusive\n");
1373     ok(GetLastError() == ERROR_INVALID_FLAGS,
1374        "unexpected error code %d\n", GetLastError());
1375
1376     /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
1377     SetLastError(0xdeadbeef);
1378     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | SORT_STRINGSORT,
1379                        upper_case, -1, buf, sizeof(buf));
1380     ok(GetLastError() == ERROR_INVALID_FLAGS, "expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1381     ok(!ret, "SORT_STRINGSORT without LCMAP_SORTKEY must fail\n");
1382
1383     /* test LCMAP_LOWERCASE */
1384     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1385                        upper_case, -1, buf, sizeof(buf));
1386     ok(ret == lstrlenA(upper_case) + 1,
1387        "ret %d, error %d, expected value %d\n",
1388        ret, GetLastError(), lstrlenA(upper_case) + 1);
1389     ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1390
1391     /* test LCMAP_UPPERCASE */
1392     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1393                        lower_case, -1, buf, sizeof(buf));
1394     ok(ret == lstrlenA(lower_case) + 1,
1395        "ret %d, error %d, expected value %d\n",
1396        ret, GetLastError(), lstrlenA(lower_case) + 1);
1397     ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
1398
1399     /* test buffer overflow */
1400     SetLastError(0xdeadbeef);
1401     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1402                        lower_case, -1, buf, 4);
1403     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1404        "should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", ret);
1405
1406     /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
1407     lstrcpyA(buf, lower_case);
1408     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1409                        buf, -1, buf, sizeof(buf));
1410     if (!ret) /* Win9x */
1411         trace("Ignoring LCMapStringA(LCMAP_UPPERCASE, buf, buf) error on Win9x\n");
1412     else
1413     {
1414         ok(ret == lstrlenA(lower_case) + 1,
1415            "ret %d, error %d, expected value %d\n",
1416            ret, GetLastError(), lstrlenA(lower_case) + 1);
1417         ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
1418     }
1419     lstrcpyA(buf, upper_case);
1420     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1421                        buf, -1, buf, sizeof(buf));
1422     if (!ret) /* Win9x */
1423         trace("Ignoring LCMapStringA(LCMAP_LOWERCASE, buf, buf) error on Win9x\n");
1424     else
1425     {
1426         ok(ret == lstrlenA(upper_case) + 1,
1427            "ret %d, error %d, expected value %d\n",
1428            ret, GetLastError(), lstrlenA(lower_case) + 1);
1429         ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1430     }
1431
1432     /* otherwise src == dst should fail */
1433     SetLastError(0xdeadbeef);
1434     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | LCMAP_UPPERCASE,
1435                        buf, 10, buf, sizeof(buf));
1436     ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
1437        GetLastError() == ERROR_INVALID_PARAMETER /* Win9x */,
1438        "unexpected error code %d\n", GetLastError());
1439     ok(!ret, "src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n");
1440
1441     /* test whether '\0' is always appended */
1442     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1443                        upper_case, -1, buf, sizeof(buf));
1444     ok(ret, "LCMapStringA must succeed\n");
1445     ok(buf[ret-1] == 0, "LCMapStringA not null-terminated\n");
1446     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1447                        upper_case, lstrlenA(upper_case), buf2, sizeof(buf2));
1448     ok(ret2, "LCMapStringA must succeed\n");
1449     ok(buf2[ret2-1] == 0, "LCMapStringA not null-terminated\n" );
1450     ok(ret == ret2, "lengths of sort keys must be equal\n");
1451     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1452
1453     /* test LCMAP_SORTKEY | NORM_IGNORECASE */
1454     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORECASE,
1455                        upper_case, -1, buf, sizeof(buf));
1456     ok(ret, "LCMapStringA must succeed\n");
1457     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1458                        lower_case, -1, buf2, sizeof(buf2));
1459     ok(ret2, "LCMapStringA must succeed\n");
1460     ok(ret == ret2, "lengths of sort keys must be equal\n");
1461     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1462
1463     /* Don't test LCMAP_SORTKEY | NORM_IGNORENONSPACE, produces different
1464        results from plain LCMAP_SORTKEY on Vista */
1465
1466     /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
1467     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
1468                        lower_case, -1, buf, sizeof(buf));
1469     ok(ret, "LCMapStringA must succeed\n");
1470     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1471                        symbols_stripped, -1, buf2, sizeof(buf2));
1472     ok(ret2, "LCMapStringA must succeed\n");
1473     ok(ret == ret2, "lengths of sort keys must be equal\n");
1474     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1475
1476     /* test NORM_IGNORENONSPACE */
1477     lstrcpyA(buf, "foo");
1478     ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORENONSPACE,
1479                        lower_case, -1, buf, sizeof(buf));
1480     ok(ret == lstrlenA(lower_case) + 1, "LCMapStringA should return %d, ret = %d\n",
1481         lstrlenA(lower_case) + 1, ret);
1482     ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1483
1484     /* test NORM_IGNORESYMBOLS */
1485     lstrcpyA(buf, "foo");
1486     ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORESYMBOLS,
1487                        lower_case, -1, buf, sizeof(buf));
1488     ok(ret == lstrlenA(symbols_stripped) + 1, "LCMapStringA should return %d, ret = %d\n",
1489         lstrlenA(symbols_stripped) + 1, ret);
1490     ok(!lstrcmpA(buf, symbols_stripped), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1491
1492     /* test srclen = 0 */
1493     SetLastError(0xdeadbeef);
1494     ret = LCMapStringA(LOCALE_USER_DEFAULT, 0, upper_case, 0, buf, sizeof(buf));
1495     ok(!ret, "LCMapStringA should fail with srclen = 0\n");
1496     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1497        "unexpected error code %d\n", GetLastError());
1498 }
1499
1500 typedef INT (*lcmapstring_wrapper)(DWORD, LPCWSTR, INT, LPWSTR, INT);
1501
1502 static void test_lcmapstring_unicode(lcmapstring_wrapper func_ptr, const char *func_name)
1503 {
1504     int ret, ret2;
1505     WCHAR buf[256], buf2[256];
1506     char *p_buf = (char *)buf, *p_buf2 = (char *)buf2;
1507
1508     ret = func_ptr(LCMAP_LOWERCASE | LCMAP_UPPERCASE,
1509                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1510     if (broken(ret))
1511         ok(lstrcmpW(buf, upper_case) == 0, "Expected upper case string\n");
1512     else
1513     {
1514         ok(!ret, "%s LCMAP_LOWERCASE and LCMAP_UPPERCASE are mutually exclusive\n", func_name);
1515         ok(GetLastError() == ERROR_INVALID_FLAGS, "%s unexpected error code %d\n",
1516            func_name, GetLastError());
1517     }
1518
1519     ret = func_ptr(LCMAP_HIRAGANA | LCMAP_KATAKANA,
1520                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1521     ok(!ret, "%s LCMAP_HIRAGANA and LCMAP_KATAKANA are mutually exclusive\n", func_name);
1522     ok(GetLastError() == ERROR_INVALID_FLAGS, "%s unexpected error code %d\n",
1523        func_name, GetLastError());
1524
1525     ret = func_ptr(LCMAP_HALFWIDTH | LCMAP_FULLWIDTH,
1526                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1527     ok(!ret, "%s LCMAP_HALFWIDTH | LCMAP_FULLWIDTH are mutually exclusive\n", func_name);
1528     ok(GetLastError() == ERROR_INVALID_FLAGS, "%s unexpected error code %d\n",
1529        func_name, GetLastError());
1530
1531     ret = func_ptr(LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE,
1532                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1533     ok(!ret, "%s LCMAP_TRADITIONAL_CHINESE and LCMAP_SIMPLIFIED_CHINESE are mutually exclusive\n",
1534        func_name);
1535     ok(GetLastError() == ERROR_INVALID_FLAGS, "%s unexpected error code %d\n",
1536        func_name, GetLastError());
1537
1538     /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
1539     SetLastError(0xdeadbeef);
1540     ret = func_ptr(LCMAP_LOWERCASE | SORT_STRINGSORT,
1541                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1542     ok(GetLastError() == ERROR_INVALID_FLAGS, "%s expected ERROR_INVALID_FLAGS, got %d\n",
1543        func_name, GetLastError());
1544     ok(!ret, "%s SORT_STRINGSORT without LCMAP_SORTKEY must fail\n", func_name);
1545
1546     /* test LCMAP_LOWERCASE */
1547     ret = func_ptr(LCMAP_LOWERCASE,
1548                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1549     ok(ret == lstrlenW(upper_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
1550        ret, GetLastError(), lstrlenW(upper_case) + 1);
1551     ok(!lstrcmpW(buf, lower_case), "%s string compare mismatch\n", func_name);
1552
1553     /* test LCMAP_UPPERCASE */
1554     ret = func_ptr(LCMAP_UPPERCASE,
1555                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1556     ok(ret == lstrlenW(lower_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
1557        ret, GetLastError(), lstrlenW(lower_case) + 1);
1558     ok(!lstrcmpW(buf, upper_case), "%s string compare mismatch\n", func_name);
1559
1560     /* test buffer overflow */
1561     SetLastError(0xdeadbeef);
1562     ret = func_ptr(LCMAP_UPPERCASE,
1563                        lower_case, -1, buf, 4);
1564     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1565        "%s should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", func_name, ret);
1566
1567     /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
1568     lstrcpyW(buf, lower_case);
1569     ret = func_ptr(LCMAP_UPPERCASE,
1570                        buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
1571     ok(ret == lstrlenW(lower_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
1572        ret, GetLastError(), lstrlenW(lower_case) + 1);
1573     ok(!lstrcmpW(buf, upper_case), "%s string compare mismatch\n", func_name);
1574
1575     lstrcpyW(buf, upper_case);
1576     ret = func_ptr(LCMAP_LOWERCASE,
1577                        buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
1578     ok(ret == lstrlenW(upper_case) + 1, "%s ret %d, error %d, expected value %d\n", func_name,
1579        ret, GetLastError(), lstrlenW(lower_case) + 1);
1580     ok(!lstrcmpW(buf, lower_case), "%s string compare mismatch\n", func_name);
1581
1582     /* otherwise src == dst should fail */
1583     SetLastError(0xdeadbeef);
1584     ret = func_ptr(LCMAP_SORTKEY | LCMAP_UPPERCASE,
1585                        buf, 10, buf, sizeof(buf));
1586     ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
1587        GetLastError() == ERROR_INVALID_PARAMETER /* Win7+ */,
1588        "%s unexpected error code %d\n", func_name, GetLastError());
1589     ok(!ret, "%s src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n", func_name);
1590
1591     /* test whether '\0' is always appended */
1592     ret = func_ptr(LCMAP_SORTKEY,
1593                        upper_case, -1, buf, sizeof(buf));
1594     ok(ret, "%s func_ptr must succeed\n", func_name);
1595     ret2 = func_ptr(LCMAP_SORTKEY,
1596                        upper_case, lstrlenW(upper_case), buf2, sizeof(buf2));
1597     ok(ret, "%s func_ptr must succeed\n", func_name);
1598     ok(ret == ret2, "%s lengths of sort keys must be equal\n", func_name);
1599     ok(!lstrcmpA(p_buf, p_buf2), "%s sort keys must be equal\n", func_name);
1600
1601     /* test LCMAP_SORTKEY | NORM_IGNORECASE */
1602     ret = func_ptr(LCMAP_SORTKEY | NORM_IGNORECASE,
1603                        upper_case, -1, buf, sizeof(buf));
1604     ok(ret, "%s func_ptr must succeed\n", func_name);
1605     ret2 = func_ptr(LCMAP_SORTKEY,
1606                        lower_case, -1, buf2, sizeof(buf2));
1607     ok(ret2, "%s func_ptr must succeed\n", func_name);
1608     ok(ret == ret2, "%s lengths of sort keys must be equal\n", func_name);
1609     ok(!lstrcmpA(p_buf, p_buf2), "%s sort keys must be equal\n", func_name);
1610
1611     /* Don't test LCMAP_SORTKEY | NORM_IGNORENONSPACE, produces different
1612        results from plain LCMAP_SORTKEY on Vista */
1613
1614     /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
1615     ret = func_ptr(LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
1616                        lower_case, -1, buf, sizeof(buf));
1617     ok(ret, "%s func_ptr must succeed\n", func_name);
1618     ret2 = func_ptr(LCMAP_SORTKEY,
1619                        symbols_stripped, -1, buf2, sizeof(buf2));
1620     ok(ret2, "%s func_ptr must succeed\n", func_name);
1621     ok(ret == ret2, "%s lengths of sort keys must be equal\n", func_name);
1622     ok(!lstrcmpA(p_buf, p_buf2), "%s sort keys must be equal\n", func_name);
1623
1624     /* test NORM_IGNORENONSPACE */
1625     lstrcpyW(buf, fooW);
1626     ret = func_ptr(NORM_IGNORENONSPACE,
1627                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1628     ok(ret == lstrlenW(lower_case) + 1, "%s func_ptr should return %d, ret = %d\n", func_name,
1629     lstrlenW(lower_case) + 1, ret);
1630     ok(!lstrcmpW(buf, lower_case), "%s string comparison mismatch\n", func_name);
1631
1632     /* test NORM_IGNORESYMBOLS */
1633     lstrcpyW(buf, fooW);
1634     ret = func_ptr(NORM_IGNORESYMBOLS,
1635                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1636     ok(ret == lstrlenW(symbols_stripped) + 1, "%s func_ptr should return %d, ret = %d\n", func_name,
1637     lstrlenW(symbols_stripped) + 1, ret);
1638     ok(!lstrcmpW(buf, symbols_stripped), "%s string comparison mismatch\n", func_name);
1639
1640     /* test srclen = 0 */
1641     SetLastError(0xdeadbeef);
1642     ret = func_ptr(0, upper_case, 0, buf, sizeof(buf)/sizeof(WCHAR));
1643     ok(!ret, "%s func_ptr should fail with srclen = 0\n", func_name);
1644     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1645        "%s unexpected error code %d\n", func_name, GetLastError());
1646 }
1647
1648 static INT LCMapStringW_wrapper(DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen)
1649 {
1650     return LCMapStringW(LOCALE_USER_DEFAULT, flags, src, srclen, dst, dstlen);
1651 }
1652
1653 static void test_LCMapStringW(void)
1654 {
1655     trace("testing LCMapStringW\n");
1656
1657     test_lcmapstring_unicode(LCMapStringW_wrapper, "LCMapStringW:");
1658 }
1659
1660 static INT LCMapStringEx_wrapper(DWORD flags, LPCWSTR src, INT srclen, LPWSTR dst, INT dstlen)
1661 {
1662     return pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, flags, src, srclen, dst, dstlen, NULL, NULL, 0);
1663 }
1664
1665 static void test_LCMapStringEx(void)
1666 {
1667     int ret;
1668     WCHAR buf[256];
1669
1670     if (!pLCMapStringEx)
1671     {
1672         skip( "LCMapStringEx not available\n" );
1673         return;
1674     }
1675
1676     trace("testing LCMapStringEx\n");
1677
1678     /* test reserved parameters */
1679     ret = pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, LCMAP_LOWERCASE,
1680                          upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR), NULL, NULL, 1);
1681     ok(ret == lstrlenW(upper_case) + 1, "ret %d, error %d, expected value %d\n",
1682        ret, GetLastError(), lstrlenW(upper_case) + 1);
1683     ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
1684
1685     ret = pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, LCMAP_LOWERCASE,
1686                          upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR), NULL, (void*)1, 0);
1687     ok(ret == lstrlenW(upper_case) + 1, "ret %d, error %d, expected value %d\n",
1688        ret, GetLastError(), lstrlenW(upper_case) + 1);
1689     ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
1690
1691     /* crashes on native */
1692     if(0)
1693         ret = pLCMapStringEx(LOCALE_NAME_USER_DEFAULT, LCMAP_LOWERCASE,
1694                              upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR), (void*)1, NULL, 0);
1695
1696     test_lcmapstring_unicode(LCMapStringEx_wrapper, "LCMapStringEx:");
1697 }
1698
1699 static void test_LocaleNames(void)
1700 {
1701     LCID lcid;
1702     INT ret;
1703     WCHAR buffer[LOCALE_NAME_MAX_LENGTH];
1704
1705     if (!pLocaleNameToLCID)
1706     {
1707         win_skip( "LocaleNameToLCID not available\n" );
1708         return;
1709     }
1710
1711     /* special cases */
1712     buffer[0] = 0;
1713     lcid = pLocaleNameToLCID(LOCALE_NAME_USER_DEFAULT, 0);
1714     ok(lcid == GetUserDefaultLCID() || broken(GetLastError() == ERROR_INVALID_PARAMETER /* Vista */),
1715        "Expected lcid == %08x, got %08x, error %d\n", lcid, GetUserDefaultLCID(), GetLastError());
1716     ret = pLCIDToLocaleName(lcid, buffer, LOCALE_NAME_MAX_LENGTH, 0);
1717     ok(ret > 0, "Expected ret > 0, got %d, error %d\n", ret, GetLastError());
1718     trace("%08x, %s\n", lcid, wine_dbgstr_w(buffer));
1719
1720     buffer[0] = 0;
1721     lcid = pLocaleNameToLCID(LOCALE_NAME_SYSTEM_DEFAULT, 0);
1722     todo_wine ok(!lcid && GetLastError() == ERROR_INVALID_PARAMETER,
1723                  "Expected lcid != 0, got %08x, error %d\n", lcid, GetLastError());
1724     ret = pLCIDToLocaleName(lcid, buffer, LOCALE_NAME_MAX_LENGTH, 0);
1725     ok(ret > 0, "Expected ret > 0, got %d, error %d\n", ret, GetLastError());
1726     trace("%08x, %s\n", lcid, wine_dbgstr_w(buffer));
1727
1728     buffer[0] = 0;
1729     lcid = pLocaleNameToLCID(LOCALE_NAME_INVARIANT, 0);
1730     todo_wine ok(lcid == 0x7F, "Expected lcid = 0x7F, got %08x, error %d\n", lcid, GetLastError());
1731     ret = pLCIDToLocaleName(lcid, buffer, LOCALE_NAME_MAX_LENGTH, 0);
1732     ok(ret > 0, "Expected ret > 0, got %d, error %d\n", ret, GetLastError());
1733     trace("%08x, %s\n", lcid, wine_dbgstr_w(buffer));
1734 }
1735
1736 /* this requires collation table patch to make it MS compatible */
1737 static const char * const strings_sorted[] =
1738 {
1739 "'",
1740 "-",
1741 "!",
1742 "\"",
1743 ".",
1744 ":",
1745 "\\",
1746 "_",
1747 "`",
1748 "{",
1749 "}",
1750 "+",
1751 "0",
1752 "1",
1753 "2",
1754 "3",
1755 "4",
1756 "5",
1757 "6",
1758 "7",
1759 "8",
1760 "9",
1761 "a",
1762 "A",
1763 "b",
1764 "B",
1765 "c",
1766 "C"
1767 };
1768
1769 static const char * const strings[] =
1770 {
1771 "C",
1772 "\"",
1773 "9",
1774 "'",
1775 "}",
1776 "-",
1777 "7",
1778 "+",
1779 "`",
1780 "1",
1781 "a",
1782 "5",
1783 "\\",
1784 "8",
1785 "B",
1786 "3",
1787 "_",
1788 "6",
1789 "{",
1790 "2",
1791 "c",
1792 "4",
1793 "!",
1794 "0",
1795 "A",
1796 ":",
1797 "b",
1798 "."
1799 };
1800
1801 static int compare_string1(const void *e1, const void *e2)
1802 {
1803     const char *s1 = *(const char *const *)e1;
1804     const char *s2 = *(const char *const *)e2;
1805
1806     return lstrcmpA(s1, s2);
1807 }
1808
1809 static int compare_string2(const void *e1, const void *e2)
1810 {
1811     const char *s1 = *(const char *const *)e1;
1812     const char *s2 = *(const char *const *)e2;
1813
1814     return CompareStringA(0, 0, s1, -1, s2, -1) - 2;
1815 }
1816
1817 static int compare_string3(const void *e1, const void *e2)
1818 {
1819     const char *s1 = *(const char *const *)e1;
1820     const char *s2 = *(const char *const *)e2;
1821     char key1[256], key2[256];
1822
1823     LCMapStringA(0, LCMAP_SORTKEY, s1, -1, key1, sizeof(key1));
1824     LCMapStringA(0, LCMAP_SORTKEY, s2, -1, key2, sizeof(key2));
1825     return strcmp(key1, key2);
1826 }
1827
1828 static void test_sorting(void)
1829 {
1830     char buf[256];
1831     char **str_buf = (char **)buf;
1832     int i;
1833
1834     assert(sizeof(buf) >= sizeof(strings));
1835
1836     /* 1. sort using lstrcmpA */
1837     memcpy(buf, strings, sizeof(strings));
1838     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string1);
1839     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1840     {
1841         ok(!strcmp(strings_sorted[i], str_buf[i]),
1842            "qsort using lstrcmpA failed for element %d\n", i);
1843     }
1844     /* 2. sort using CompareStringA */
1845     memcpy(buf, strings, sizeof(strings));
1846     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string2);
1847     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1848     {
1849         ok(!strcmp(strings_sorted[i], str_buf[i]),
1850            "qsort using CompareStringA failed for element %d\n", i);
1851     }
1852     /* 3. sort using sort keys */
1853     memcpy(buf, strings, sizeof(strings));
1854     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string3);
1855     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1856     {
1857         ok(!strcmp(strings_sorted[i], str_buf[i]),
1858            "qsort using sort keys failed for element %d\n", i);
1859     }
1860 }
1861
1862 static void test_FoldStringA(void)
1863 {
1864   int ret, i, j;
1865   BOOL is_special;
1866   char src[256], dst[256];
1867   static const char digits_src[] = { 0xB9,0xB2,0xB3,'\0'  };
1868   static const char digits_dst[] = { '1','2','3','\0'  };
1869   static const char composite_src[] =
1870   {
1871     0x8a,0x8e,0x9a,0x9e,0x9f,0xc0,0xc1,0xc2,
1872     0xc3,0xc4,0xc5,0xc7,0xc8,0xc9,0xca,0xcb,
1873     0xcc,0xcd,0xce,0xcf,0xd1,0xd2,0xd3,0xd4,
1874     0xd5,0xd6,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,
1875     0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe7,0xe8,
1876     0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,0xf1,
1877     0xf2,0xf3,0xf4,0xf5,0xf6,0xf8,0xf9,0xfa,
1878     0xfb,0xfc,0xfd,0xff,'\0'
1879   };
1880   static const char composite_dst[] =
1881   {
1882     0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
1883     0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
1884     0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
1885     0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
1886     0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
1887     0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
1888     0x4f,0x7e,0x4f,0xa8,0x4f,0x3f,0x55,0x60,
1889     0x55,0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,
1890     0x61,0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,
1891     0x61,0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,
1892     0x65,0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,
1893     0x69,0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,
1894     0x6f,0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,
1895     0x6f,0xa8,0x6f,0x3f,0x75,0x60,0x75,0xb4,
1896     0x75,0x5e,0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
1897   };
1898   static const char composite_dst_alt[] =
1899   {
1900     0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
1901     0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
1902     0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
1903     0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
1904     0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
1905     0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
1906     0x4f,0x7e,0x4f,0xa8,0xd8,0x55,0x60,0x55,
1907     0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,0x61,
1908     0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,0x61,
1909     0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,0x65,
1910     0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,0x69,
1911     0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,0x6f,
1912     0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,0x6f,
1913     0xa8,0xf8,0x75,0x60,0x75,0xb4,0x75,0x5e,
1914     0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
1915   };
1916   static const char ligatures_src[] =
1917   {
1918     0x8C,0x9C,0xC6,0xDE,0xDF,0xE6,0xFE,'\0'
1919   };
1920   static const char ligatures_dst[] =
1921   {
1922     'O','E','o','e','A','E','T','H','s','s','a','e','t','h','\0'
1923   };
1924   static const struct special
1925   {
1926     char src;
1927     char dst[4];
1928   }  foldczone_special[] =
1929   {
1930     /* src   dst                   */
1931     { 0x85, { 0x2e, 0x2e, 0x2e, 0x00 } },
1932     { 0x98, { 0x20, 0x7e, 0x00 } },
1933     { 0x99, { 0x54, 0x4d, 0x00 } },
1934     { 0xa0, { 0x20, 0x00 } },
1935     { 0xa8, { 0x20, 0xa8, 0x00 } },
1936     { 0xaa, { 0x61, 0x00 } },
1937     { 0xaf, { 0x20, 0xaf, 0x00 } },
1938     { 0xb2, { 0x32, 0x00 } },
1939     { 0xb3, { 0x33, 0x00 } },
1940     { 0xb4, { 0x20, 0xb4, 0x00 } },
1941     { 0xb8, { 0x20, 0xb8, 0x00 } },
1942     { 0xb9, { 0x31, 0x00 } },
1943     { 0xba, { 0x6f, 0x00 } },
1944     { 0xbc, { 0x31, 0x2f, 0x34, 0x00 } },
1945     { 0xbd, { 0x31, 0x2f, 0x32, 0x00 } },
1946     { 0xbe, { 0x33, 0x2f, 0x34, 0x00 } },
1947     { 0x00 }
1948   };
1949
1950   if (!pFoldStringA)
1951     return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
1952
1953   /* these tests are locale specific */
1954   if (GetACP() != 1252)
1955   {
1956       trace("Skipping FoldStringA tests for a not Latin 1 locale\n");
1957       return;
1958   }
1959
1960   /* MAP_FOLDDIGITS */
1961   SetLastError(0);
1962   ret = pFoldStringA(MAP_FOLDDIGITS, digits_src, -1, dst, 256);
1963   if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1964   {
1965     win_skip("FoldStringA is not implemented\n");
1966     return;
1967   }
1968   ok(ret == 4, "Expected ret == 4, got %d, error %d\n", ret, GetLastError());
1969   ok(strcmp(dst, digits_dst) == 0,
1970      "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", digits_dst, dst);
1971   for (i = 1; i < 256; i++)
1972   {
1973     if (!strchr(digits_src, i))
1974     {
1975       src[0] = i;
1976       src[1] = '\0';
1977       SetLastError(0);
1978       ret = pFoldStringA(MAP_FOLDDIGITS, src, -1, dst, 256);
1979       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
1980       ok(dst[0] == src[0],
1981          "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", src, dst);
1982     }
1983   }
1984
1985   /* MAP_EXPAND_LIGATURES */
1986   SetLastError(0);
1987   ret = pFoldStringA(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
1988   /* NT 4.0 doesn't support MAP_EXPAND_LIGATURES */
1989   if (!(ret == 0 && GetLastError() == ERROR_INVALID_FLAGS)) {
1990     ok(ret == sizeof(ligatures_dst), "Got %d, error %d\n", ret, GetLastError());
1991     ok(strcmp(dst, ligatures_dst) == 0,
1992        "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", ligatures_dst, dst);
1993     for (i = 1; i < 256; i++)
1994     {
1995       if (!strchr(ligatures_src, i))
1996       {
1997         src[0] = i;
1998         src[1] = '\0';
1999         SetLastError(0);
2000         ret = pFoldStringA(MAP_EXPAND_LIGATURES, src, -1, dst, 256);
2001         if (ret == 3)
2002         {
2003           /* Vista */
2004           ok((i == 0xDC && lstrcmpA(dst, "UE") == 0) ||
2005              (i == 0xFC && lstrcmpA(dst, "ue") == 0),
2006              "Got %s for %d\n", dst, i);
2007         }
2008         else
2009         {
2010           ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2011           ok(dst[0] == src[0],
2012              "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", src, dst);
2013         }
2014       }
2015     }
2016   }
2017
2018   /* MAP_COMPOSITE */
2019   SetLastError(0);
2020   ret = pFoldStringA(MAP_COMPOSITE, composite_src, -1, dst, 256);
2021   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
2022   ok(ret == 121 || ret == 119, "Expected 121 or 119, got %d\n", ret);
2023   ok(strcmp(dst, composite_dst) == 0 || strcmp(dst, composite_dst_alt) == 0,
2024      "MAP_COMPOSITE: Mismatch, got '%s'\n", dst);
2025
2026   for (i = 1; i < 256; i++)
2027   {
2028     if (!strchr(composite_src, i))
2029     {
2030       src[0] = i;
2031       src[1] = '\0';
2032       SetLastError(0);
2033       ret = pFoldStringA(MAP_COMPOSITE, src, -1, dst, 256);
2034       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2035       ok(dst[0] == src[0],
2036          "0x%02x, 0x%02x,0x%02x,0x%02x,\n", (unsigned char)src[0],
2037          (unsigned char)dst[0],(unsigned char)dst[1],(unsigned char)dst[2]);
2038     }
2039   }
2040
2041   /* MAP_FOLDCZONE */
2042   for (i = 1; i < 256; i++)
2043   {
2044     src[0] = i;
2045     src[1] = '\0';
2046     SetLastError(0);
2047     ret = pFoldStringA(MAP_FOLDCZONE, src, -1, dst, 256);
2048     is_special = FALSE;
2049     for (j = 0; foldczone_special[j].src != 0 && ! is_special; j++)
2050     {
2051       if (foldczone_special[j].src == src[0])
2052       {
2053         ok(ret == 2 || ret == lstrlenA(foldczone_special[j].dst) + 1,
2054            "Expected ret == 2 or %d, got %d, error %d\n",
2055            lstrlenA(foldczone_special[j].dst) + 1, ret, GetLastError());
2056         ok(src[0] == dst[0] || lstrcmpA(foldczone_special[j].dst, dst) == 0,
2057            "MAP_FOLDCZONE: string mismatch for 0x%02x\n",
2058            (unsigned char)src[0]);
2059         is_special = TRUE;
2060       }
2061     }
2062     if (! is_special)
2063     {
2064       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2065       ok(src[0] == dst[0],
2066          "MAP_FOLDCZONE: Expected 0x%02x, got 0x%02x\n",
2067          (unsigned char)src[0], (unsigned char)dst[0]);
2068     }
2069   }
2070
2071   /* MAP_PRECOMPOSED */
2072   for (i = 1; i < 256; i++)
2073   {
2074     src[0] = i;
2075     src[1] = '\0';
2076     SetLastError(0);
2077     ret = pFoldStringA(MAP_PRECOMPOSED, src, -1, dst, 256);
2078     ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2079     ok(src[0] == dst[0],
2080        "MAP_PRECOMPOSED: Expected 0x%02x, got 0x%02x\n",
2081        (unsigned char)src[0], (unsigned char)dst[0]);
2082   }
2083 }
2084
2085 static void test_FoldStringW(void)
2086 {
2087   int ret;
2088   unsigned int i, j;
2089   WCHAR src[256], dst[256], ch, prev_ch = 1;
2090   static const DWORD badFlags[] =
2091   {
2092     0,
2093     MAP_PRECOMPOSED|MAP_COMPOSITE,
2094     MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES,
2095     MAP_COMPOSITE|MAP_EXPAND_LIGATURES
2096   };
2097   /* Ranges of digits 0-9 : Must be sorted! */
2098   static const WCHAR digitRanges[] =
2099   {
2100     0x0030, /* '0'-'9' */
2101     0x0660, /* Eastern Arabic */
2102     0x06F0, /* Arabic - Hindu */
2103     0x0966, /* Devengari */
2104     0x09E6, /* Bengalii */
2105     0x0A66, /* Gurmukhi */
2106     0x0AE6, /* Gujarati */
2107     0x0B66, /* Oriya */
2108     0x0BE6, /* Tamil - No 0 */
2109     0x0C66, /* Telugu */
2110     0x0CE6, /* Kannada */
2111     0x0D66, /* Maylayalam */
2112     0x0E50, /* Thai */
2113     0x0ED0, /* Laos */
2114     0x0F29, /* Tibet - 0 is out of sequence */
2115     0x2070, /* Superscript - 1, 2, 3 are out of sequence */
2116     0x2080, /* Subscript */
2117     0x245F, /* Circled - 0 is out of sequence */
2118     0x2473, /* Bracketed */
2119     0x2487, /* Full stop */
2120     0x2775, /* Inverted circled - No 0 */
2121     0x277F, /* Patterned circled - No 0 */
2122     0x2789, /* Inverted Patterned circled - No 0 */
2123     0x3020, /* Hangzhou */
2124     0xff10, /* Pliene chasse (?) */
2125     0xffff  /* Terminator */
2126   };
2127   /* Digits which are represented, but out of sequence */
2128   static const WCHAR outOfSequenceDigits[] =
2129   {
2130       0xB9,   /* Superscript 1 */
2131       0xB2,   /* Superscript 2 */
2132       0xB3,   /* Superscript 3 */
2133       0x0F33, /* Tibetan half zero */
2134       0x24EA, /* Circled 0 */
2135       0x3007, /* Ideographic number zero */
2136       '\0'    /* Terminator */
2137   };
2138   /* Digits in digitRanges for which no representation is available */
2139   static const WCHAR noDigitAvailable[] =
2140   {
2141       0x0BE6, /* No Tamil 0 */
2142       0x0F29, /* No Tibetan half zero (out of sequence) */
2143       0x2473, /* No Bracketed 0 */
2144       0x2487, /* No 0 Full stop */
2145       0x2775, /* No inverted circled 0 */
2146       0x277F, /* No patterned circled */
2147       0x2789, /* No inverted Patterned circled */
2148       0x3020, /* No Hangzhou 0 */
2149       '\0'    /* Terminator */
2150   };
2151   static const WCHAR foldczone_src[] =
2152   {
2153     'W',    'i',    'n',    'e',    0x0348, 0x0551, 0x1323, 0x280d,
2154     0xff37, 0xff49, 0xff4e, 0xff45, '\0'
2155   };
2156   static const WCHAR foldczone_dst[] =
2157   {
2158     'W','i','n','e',0x0348,0x0551,0x1323,0x280d,'W','i','n','e','\0'
2159   };
2160   static const WCHAR foldczone_todo_src[] =
2161   {
2162       0x3c5,0x308,0x6a,0x30c,0xa0,0xaa,0
2163   };
2164   static const WCHAR foldczone_todo_dst[] =
2165   {
2166       0x3cb,0x1f0,' ','a',0
2167   };
2168   static const WCHAR foldczone_todo_broken_dst[] =
2169   {
2170       0x3cb,0x1f0,0xa0,0xaa,0
2171   };
2172   static const WCHAR ligatures_src[] =
2173   {
2174     'W',    'i',    'n',    'e',    0x03a6, 0x03b9, 0x03bd, 0x03b5,
2175     0x00c6, 0x00de, 0x00df, 0x00e6, 0x00fe, 0x0132, 0x0133, 0x0152,
2176     0x0153, 0x01c4, 0x01c5, 0x01c6, 0x01c7, 0x01c8, 0x01c9, 0x01ca,
2177     0x01cb, 0x01cc, 0x01e2, 0x01e3, 0x01f1, 0x01f2, 0x01f3, 0x01fc,
2178     0x01fd, 0x05f0, 0x05f1, 0x05f2, 0xfb00, 0xfb01, 0xfb02, 0xfb03,
2179     0xfb04, 0xfb05, 0xfb06, '\0'
2180   };
2181   static const WCHAR ligatures_dst[] =
2182   {
2183     'W','i','n','e',0x03a6,0x03b9,0x03bd,0x03b5,
2184     'A','E','T','H','s','s','a','e','t','h','I','J','i','j','O','E','o','e',
2185     'D',0x017d,'D',0x017e,'d',0x017e,'L','J','L','j','l','j','N','J','N','j',
2186     'n','j',0x0100,0x0112,0x0101,0x0113,'D','Z','D','z','d','z',0x00c1,0x00c9,
2187     0x00e1,0x00e9,0x05d5,0x05d5,0x05d5,0x05d9,0x05d9,0x05d9,'f','f','f','i',
2188     'f','l','f','f','i','f','f','l',0x017f,'t','s','t','\0'
2189   };
2190
2191   if (!pFoldStringW)
2192   {
2193     win_skip("FoldStringW is not available\n");
2194     return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
2195   }
2196
2197   /* Invalid flag combinations */
2198   for (i = 0; i < sizeof(badFlags)/sizeof(badFlags[0]); i++)
2199   {
2200     src[0] = dst[0] = '\0';
2201     SetLastError(0);
2202     ret = pFoldStringW(badFlags[i], src, 256, dst, 256);
2203     if (GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
2204     {
2205       win_skip("FoldStringW is not implemented\n");
2206       return;
2207     }
2208     ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
2209        "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2210   }
2211
2212   /* src & dst cannot be the same */
2213   SetLastError(0);
2214   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, src, 256);
2215   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2216       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2217
2218   /* src can't be NULL */
2219   SetLastError(0);
2220   ret = pFoldStringW(MAP_FOLDCZONE, NULL, -1, dst, 256);
2221   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2222       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2223
2224   /* srclen can't be 0 */
2225   SetLastError(0);
2226   ret = pFoldStringW(MAP_FOLDCZONE, src, 0, dst, 256);
2227   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2228       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2229
2230   /* dstlen can't be < 0 */
2231   SetLastError(0);
2232   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, -1);
2233   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2234       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2235
2236   /* Ret includes terminating NUL which is appended if srclen = -1 */
2237   SetLastError(0);
2238   src[0] = 'A';
2239   src[1] = '\0';
2240   dst[0] = '\0';
2241   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, 256);
2242   ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2243   ok(dst[0] == 'A' && dst[1] == '\0',
2244      "srclen=-1: Expected ret=2 [%d,%d], got ret=%d [%d,%d], err=%d\n",
2245      'A', '\0', ret, dst[0], dst[1], GetLastError());
2246
2247   /* If size is given, result is not NUL terminated */
2248   SetLastError(0);
2249   src[0] = 'A';
2250   src[1] = 'A';
2251   dst[0] = 'X';
2252   dst[1] = 'X';
2253   ret = pFoldStringW(MAP_FOLDCZONE, src, 1, dst, 256);
2254   ok(ret == 1, "Expected ret == 1, got %d, error %d\n", ret, GetLastError());
2255   ok(dst[0] == 'A' && dst[1] == 'X',
2256      "srclen=1: Expected ret=1, [%d,%d], got ret=%d,[%d,%d], err=%d\n",
2257      'A','X', ret, dst[0], dst[1], GetLastError());
2258
2259   /* MAP_FOLDDIGITS */
2260   for (j = 0; j < sizeof(digitRanges)/sizeof(digitRanges[0]); j++)
2261   {
2262     /* Check everything before this range */
2263     for (ch = prev_ch; ch < digitRanges[j]; ch++)
2264     {
2265       SetLastError(0);
2266       src[0] = ch;
2267       src[1] = dst[0] = '\0';
2268       ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
2269       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2270
2271       ok(dst[0] == ch || strchrW(outOfSequenceDigits, ch) ||
2272          /* Wine (correctly) maps all Unicode 4.0+ digits */
2273          isdigitW(ch) || (ch >= 0x24F5 && ch <= 0x24FD) || ch == 0x24FF || ch == 0x19da ||
2274          (ch >= 0x1369 && ch <= 0x1371),
2275          "MAP_FOLDDIGITS: ch %d 0x%04x Expected unchanged got %d\n", ch, ch, dst[0]);
2276     }
2277
2278     if (digitRanges[j] == 0xffff)
2279       break; /* Finished the whole code point space */
2280
2281     for (ch = digitRanges[j]; ch < digitRanges[j] + 10; ch++)
2282     {
2283       WCHAR c;
2284
2285       /* Map out of sequence characters */
2286       if      (ch == 0x2071) c = 0x00B9; /* Superscript 1 */
2287       else if (ch == 0x2072) c = 0x00B2; /* Superscript 2 */
2288       else if (ch == 0x2073) c = 0x00B3; /* Superscript 3 */
2289       else if (ch == 0x245F) c = 0x24EA; /* Circled 0     */
2290       else                   c = ch;
2291       SetLastError(0);
2292       src[0] = c;
2293       src[1] = dst[0] = '\0';
2294       ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
2295       ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2296
2297       ok((dst[0] == '0' + ch - digitRanges[j] && dst[1] == '\0') ||
2298          broken( dst[0] == ch ) ||  /* old Windows versions don't have all mappings */
2299          (digitRanges[j] == 0x3020 && dst[0] == ch) || /* Hangzhou not present in all Windows versions */
2300          (digitRanges[j] == 0x0F29 && dst[0] == ch) || /* Tibetan not present in all Windows versions */
2301          strchrW(noDigitAvailable, c),
2302          "MAP_FOLDDIGITS: ch %d Expected %d got %d\n",
2303          ch, '0' + digitRanges[j] - ch, dst[0]);
2304     }
2305     prev_ch = ch;
2306   }
2307
2308   /* MAP_FOLDCZONE */
2309   SetLastError(0);
2310   ret = pFoldStringW(MAP_FOLDCZONE, foldczone_src, -1, dst, 256);
2311   ok(ret == sizeof(foldczone_dst)/sizeof(foldczone_dst[0]),
2312      "Got %d, error %d\n", ret, GetLastError());
2313   ok(!memcmp(dst, foldczone_dst, sizeof(foldczone_dst)),
2314      "MAP_FOLDCZONE: Expanded incorrectly\n");
2315
2316   ret = pFoldStringW(MAP_FOLDCZONE|MAP_PRECOMPOSED, foldczone_todo_src, -1, dst, 256);
2317   todo_wine ok(ret == sizeof(foldczone_todo_dst)/sizeof(foldczone_todo_dst[0]),
2318           "Got %d, error %d\n", ret, GetLastError());
2319   todo_wine ok(!memcmp(dst, foldczone_todo_dst, sizeof(foldczone_todo_dst))
2320           || broken(!memcmp(dst, foldczone_todo_broken_dst, sizeof(foldczone_todo_broken_dst))),
2321           "MAP_FOLDCZONE: Expanded incorrectly (%s)\n", wine_dbgstr_w(dst));
2322
2323   /* MAP_EXPAND_LIGATURES */
2324   SetLastError(0);
2325   ret = pFoldStringW(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
2326   /* NT 4.0 doesn't support MAP_EXPAND_LIGATURES */
2327   if (!(ret == 0 && GetLastError() == ERROR_INVALID_FLAGS)) {
2328     ok(ret == sizeof(ligatures_dst)/sizeof(ligatures_dst[0]),
2329        "Got %d, error %d\n", ret, GetLastError());
2330     ok(!memcmp(dst, ligatures_dst, sizeof(ligatures_dst)),
2331        "MAP_EXPAND_LIGATURES: Expanded incorrectly\n");
2332   }
2333
2334   /* FIXME: MAP_PRECOMPOSED : MAP_COMPOSITE */
2335 }
2336
2337
2338
2339 #define LCID_OK(l) \
2340   ok(lcid == l, "Expected lcid = %08x, got %08x\n", l, lcid)
2341 #define MKLCID(x,y,z) MAKELCID(MAKELANGID(x, y), z)
2342 #define LCID_RES(src, res) lcid = ConvertDefaultLocale(src); LCID_OK(res)
2343 #define TEST_LCIDLANG(a,b) LCID_RES(MAKELCID(a,b), MAKELCID(a,b))
2344 #define TEST_LCID(a,b,c) LCID_RES(MKLCID(a,b,c), MKLCID(a,b,c))
2345
2346 static void test_ConvertDefaultLocale(void)
2347 {
2348   LCID lcid;
2349
2350   /* Doesn't change lcid, even if non default sublang/sort used */
2351   TEST_LCID(LANG_ENGLISH,  SUBLANG_ENGLISH_US, SORT_DEFAULT);
2352   TEST_LCID(LANG_ENGLISH,  SUBLANG_ENGLISH_UK, SORT_DEFAULT);
2353   TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT,    SORT_DEFAULT);
2354   TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT,    SORT_JAPANESE_UNICODE);
2355
2356   /* SUBLANG_NEUTRAL -> SUBLANG_DEFAULT */
2357   LCID_RES(MKLCID(LANG_ENGLISH,  SUBLANG_NEUTRAL, SORT_DEFAULT),
2358            MKLCID(LANG_ENGLISH,  SUBLANG_DEFAULT, SORT_DEFAULT));
2359   LCID_RES(MKLCID(LANG_JAPANESE, SUBLANG_NEUTRAL, SORT_DEFAULT),
2360            MKLCID(LANG_JAPANESE, SUBLANG_DEFAULT, SORT_DEFAULT));
2361
2362   /* Invariant language is not treated specially */
2363   TEST_LCID(LANG_INVARIANT, SUBLANG_DEFAULT, SORT_DEFAULT);
2364
2365   /* User/system default languages alone are not mapped */
2366   TEST_LCIDLANG(LANG_SYSTEM_DEFAULT, SORT_JAPANESE_UNICODE);
2367   TEST_LCIDLANG(LANG_USER_DEFAULT,   SORT_JAPANESE_UNICODE);
2368
2369   /* Default lcids */
2370   LCID_RES(LOCALE_SYSTEM_DEFAULT, GetSystemDefaultLCID());
2371   LCID_RES(LOCALE_USER_DEFAULT,   GetUserDefaultLCID());
2372   LCID_RES(LOCALE_NEUTRAL,        GetUserDefaultLCID());
2373 }
2374
2375 static BOOL CALLBACK langgrp_procA(LGRPID lgrpid, LPSTR lpszNum, LPSTR lpszName,
2376                                     DWORD dwFlags, LONG_PTR lParam)
2377 {
2378   trace("%08x, %s, %s, %08x, %08lx\n",
2379         lgrpid, lpszNum, lpszName, dwFlags, lParam);
2380
2381   ok(pIsValidLanguageGroup(lgrpid, dwFlags) == TRUE,
2382      "Enumerated grp %d not valid (flags %d)\n", lgrpid, dwFlags);
2383
2384   /* If lParam is one, we are calling with flags defaulted from 0 */
2385   ok(!lParam || (dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED),
2386          "Expected dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED, got %d\n", dwFlags);
2387
2388   return TRUE;
2389 }
2390
2391 static void test_EnumSystemLanguageGroupsA(void)
2392 {
2393   BOOL ret;
2394
2395   if (!pEnumSystemLanguageGroupsA || !pIsValidLanguageGroup)
2396   {
2397     win_skip("EnumSystemLanguageGroupsA and/or IsValidLanguageGroup are not available\n");
2398     return;
2399   }
2400
2401   /* No enumeration proc */
2402   SetLastError(0);
2403   ret = pEnumSystemLanguageGroupsA(0, LGRPID_INSTALLED, 0);
2404   if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2405   {
2406     win_skip("EnumSystemLanguageGroupsA is not implemented\n");
2407     return;
2408   }
2409   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2410       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2411
2412   /* Invalid flags */
2413   SetLastError(0);
2414   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED|LGRPID_SUPPORTED, 0);
2415   ok(GetLastError() == ERROR_INVALID_FLAGS, "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2416
2417   /* No flags - defaults to LGRPID_INSTALLED */
2418   SetLastError(0xdeadbeef);
2419   pEnumSystemLanguageGroupsA(langgrp_procA, 0, 1);
2420   ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
2421
2422   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED, 0);
2423   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_SUPPORTED, 0);
2424 }
2425
2426 static BOOL CALLBACK enum_func( LPWSTR name, DWORD flags, LPARAM lparam )
2427 {
2428     trace( "%s %x\n", wine_dbgstr_w(name), flags );
2429     return TRUE;
2430 }
2431
2432 static void test_EnumSystemLocalesEx(void)
2433 {
2434     BOOL ret;
2435
2436     if (!pEnumSystemLocalesEx)
2437     {
2438         win_skip( "EnumSystemLocalesEx not available\n" );
2439         return;
2440     }
2441     SetLastError( 0xdeadbeef );
2442     ret = pEnumSystemLocalesEx( enum_func, LOCALE_ALL, 0, (void *)1 );
2443     ok( !ret, "should have failed\n" );
2444     ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong error %u\n", GetLastError() );
2445     SetLastError( 0xdeadbeef );
2446     ret = pEnumSystemLocalesEx( enum_func, 0, 0, NULL );
2447     ok( ret, "failed err %u\n", GetLastError() );
2448 }
2449
2450 static BOOL CALLBACK lgrplocale_procA(LGRPID lgrpid, LCID lcid, LPSTR lpszNum,
2451                                       LONG_PTR lParam)
2452 {
2453   trace("%08x, %08x, %s, %08lx\n", lgrpid, lcid, lpszNum, lParam);
2454
2455   /* invalid locale enumerated on some platforms */
2456   if (lcid == 0)
2457       return TRUE;
2458
2459   ok(pIsValidLanguageGroup(lgrpid, LGRPID_SUPPORTED) == TRUE,
2460      "Enumerated grp %d not valid\n", lgrpid);
2461   ok(IsValidLocale(lcid, LCID_SUPPORTED) == TRUE,
2462      "Enumerated grp locale %d not valid\n", lcid);
2463   return TRUE;
2464 }
2465
2466 static void test_EnumLanguageGroupLocalesA(void)
2467 {
2468   BOOL ret;
2469
2470   if (!pEnumLanguageGroupLocalesA || !pIsValidLanguageGroup)
2471   {
2472     win_skip("EnumLanguageGroupLocalesA and/or IsValidLanguageGroup are not available\n");
2473     return;
2474   }
2475
2476   /* No enumeration proc */
2477   SetLastError(0);
2478   ret = pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0, 0);
2479   if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2480   {
2481     win_skip("EnumLanguageGroupLocalesA is not implemented\n");
2482     return;
2483   }
2484   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2485       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2486
2487   /* lgrpid too small */
2488   SetLastError(0);
2489   ret = pEnumLanguageGroupLocalesA(lgrplocale_procA, 0, 0, 0);
2490   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2491       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2492
2493   /* lgrpid too big */
2494   SetLastError(0);
2495   ret = pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_ARMENIAN + 1, 0, 0);
2496   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2497       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2498
2499   /* dwFlags is reserved */
2500   SetLastError(0);
2501   ret = pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0x1, 0);
2502   ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2503       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2504
2505   pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_WESTERN_EUROPE, 0, 0);
2506 }
2507
2508 static void test_SetLocaleInfoA(void)
2509 {
2510   BOOL bRet;
2511   LCID lcid = GetUserDefaultLCID();
2512
2513   /* Null data */
2514   SetLastError(0);
2515   bRet = SetLocaleInfoA(lcid, LOCALE_SDATE, 0);
2516   ok( !bRet && GetLastError() == ERROR_INVALID_PARAMETER,
2517       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2518
2519   /* IDATE */
2520   SetLastError(0);
2521   bRet = SetLocaleInfoA(lcid, LOCALE_IDATE, "test_SetLocaleInfoA");
2522   ok(!bRet && GetLastError() == ERROR_INVALID_FLAGS,
2523      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2524
2525   /* ILDATE */
2526   SetLastError(0);
2527   bRet = SetLocaleInfoA(lcid, LOCALE_ILDATE, "test_SetLocaleInfoA");
2528   ok(!bRet && GetLastError() == ERROR_INVALID_FLAGS,
2529      "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2530 }
2531
2532 static BOOL CALLBACK luilocale_proc1A(LPSTR value, LONG_PTR lParam)
2533 {
2534   trace("%s %08lx\n", value, lParam);
2535   return(TRUE);
2536 }
2537
2538 static BOOL CALLBACK luilocale_proc2A(LPSTR value, LONG_PTR lParam)
2539 {
2540   ok(!enumCount, "callback called again unexpected\n");
2541   enumCount++;
2542   return(FALSE);
2543 }
2544
2545 static BOOL CALLBACK luilocale_proc3A(LPSTR value, LONG_PTR lParam)
2546 {
2547   ok(0,"callback called unexpected\n");
2548   return(FALSE);
2549 }
2550
2551 static void test_EnumUILanguageA(void)
2552 {
2553   BOOL ret;
2554   if (!pEnumUILanguagesA) {
2555     win_skip("EnumUILanguagesA is not available on Win9x or NT4\n");
2556     return;
2557   }
2558
2559   SetLastError(ERROR_SUCCESS);
2560   ret = pEnumUILanguagesA(luilocale_proc1A, 0, 0);
2561   if (ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2562   {
2563     win_skip("EnumUILanguagesA is not implemented\n");
2564     return;
2565   }
2566   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
2567
2568   enumCount = 0;
2569   SetLastError(ERROR_SUCCESS);
2570   ret = pEnumUILanguagesA(luilocale_proc2A, 0, 0);
2571   ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
2572
2573   SetLastError(ERROR_SUCCESS);
2574   ret = pEnumUILanguagesA(NULL, 0, 0);
2575   ok(!ret, "Expected return value FALSE, got %u\n", ret);
2576   ok(GetLastError() == ERROR_INVALID_PARAMETER,
2577       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2578
2579   SetLastError(ERROR_SUCCESS);
2580   ret = pEnumUILanguagesA(luilocale_proc3A, 0x5a5a5a5a, 0);
2581   ok(!ret, "Expected return value FALSE, got %u\n", ret);
2582   ok(GetLastError() == ERROR_INVALID_FLAGS, "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2583
2584   SetLastError(ERROR_SUCCESS);
2585   ret = pEnumUILanguagesA(NULL, 0x5a5a5a5a, 0);
2586   ok(!ret, "Expected return value FALSE, got %u\n", ret);
2587   ok(GetLastError() == ERROR_INVALID_PARAMETER,
2588       "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2589 }
2590
2591 static char date_fmt_buf[1024];
2592
2593 static BOOL CALLBACK enum_datetime_procA(LPSTR fmt)
2594 {
2595     lstrcatA(date_fmt_buf, fmt);
2596     lstrcatA(date_fmt_buf, "\n");
2597     return TRUE;
2598 }
2599
2600 static void test_EnumDateFormatsA(void)
2601 {
2602     char *p, buf[256];
2603     BOOL ret;
2604     LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
2605
2606     trace("EnumDateFormatsA 0\n");
2607     date_fmt_buf[0] = 0;
2608     SetLastError(0xdeadbeef);
2609     ret = EnumDateFormatsA(enum_datetime_procA, lcid, 0);
2610     if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
2611     {
2612         win_skip("0 for dwFlags is not supported\n");
2613     }
2614     else
2615     {
2616         ok(ret, "EnumDateFormatsA(0) error %d\n", GetLastError());
2617         trace("%s\n", date_fmt_buf);
2618         /* test the 1st enumerated format */
2619         if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2620         ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
2621         ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
2622         ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2623     }
2624
2625     trace("EnumDateFormatsA LOCALE_USE_CP_ACP\n");
2626     date_fmt_buf[0] = 0;
2627     SetLastError(0xdeadbeef);
2628     ret = EnumDateFormatsA(enum_datetime_procA, lcid, LOCALE_USE_CP_ACP);
2629     if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
2630     {
2631         win_skip("LOCALE_USE_CP_ACP is not supported\n");
2632     }
2633     else
2634     {
2635         ok(ret, "EnumDateFormatsA(LOCALE_USE_CP_ACP) error %d\n", GetLastError());
2636         trace("%s\n", date_fmt_buf);
2637         /* test the 1st enumerated format */
2638         if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2639         ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
2640         ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
2641         ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2642     }
2643
2644     trace("EnumDateFormatsA DATE_SHORTDATE\n");
2645     date_fmt_buf[0] = 0;
2646     ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_SHORTDATE);
2647     ok(ret, "EnumDateFormatsA(DATE_SHORTDATE) error %d\n", GetLastError());
2648     trace("%s\n", date_fmt_buf);
2649     /* test the 1st enumerated format */
2650     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2651     ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
2652     ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
2653     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2654
2655     trace("EnumDateFormatsA DATE_LONGDATE\n");
2656     date_fmt_buf[0] = 0;
2657     ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_LONGDATE);
2658     ok(ret, "EnumDateFormatsA(DATE_LONGDATE) error %d\n", GetLastError());
2659     trace("%s\n", date_fmt_buf);
2660     /* test the 1st enumerated format */
2661     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2662     ret = GetLocaleInfoA(lcid, LOCALE_SLONGDATE, buf, sizeof(buf));
2663     ok(ret, "GetLocaleInfoA(LOCALE_SLONGDATE) error %d\n", GetLastError());
2664     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2665
2666     trace("EnumDateFormatsA DATE_YEARMONTH\n");
2667     date_fmt_buf[0] = 0;
2668     SetLastError(0xdeadbeef);
2669     ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_YEARMONTH);
2670     if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
2671     {
2672         skip("DATE_YEARMONTH is only present on W2K and later\n");
2673         return;
2674     }
2675     ok(ret, "EnumDateFormatsA(DATE_YEARMONTH) error %d\n", GetLastError());
2676     trace("%s\n", date_fmt_buf);
2677     /* test the 1st enumerated format */
2678     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2679     ret = GetLocaleInfoA(lcid, LOCALE_SYEARMONTH, buf, sizeof(buf));
2680     ok(ret, "GetLocaleInfoA(LOCALE_SYEARMONTH) error %d\n", GetLastError());
2681     ok(!lstrcmpA(date_fmt_buf, buf) || broken(!buf[0]) /* win9x */,
2682        "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2683 }
2684
2685 static void test_EnumTimeFormatsA(void)
2686 {
2687     char *p, buf[256];
2688     BOOL ret;
2689     LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
2690
2691     trace("EnumTimeFormatsA 0\n");
2692     date_fmt_buf[0] = 0;
2693     ret = EnumTimeFormatsA(enum_datetime_procA, lcid, 0);
2694     ok(ret, "EnumTimeFormatsA(0) error %d\n", GetLastError());
2695     trace("%s\n", date_fmt_buf);
2696     /* test the 1st enumerated format */
2697     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2698     ret = GetLocaleInfoA(lcid, LOCALE_STIMEFORMAT, buf, sizeof(buf));
2699     ok(ret, "GetLocaleInfoA(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
2700     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2701
2702     trace("EnumTimeFormatsA LOCALE_USE_CP_ACP\n");
2703     date_fmt_buf[0] = 0;
2704     ret = EnumTimeFormatsA(enum_datetime_procA, lcid, LOCALE_USE_CP_ACP);
2705     ok(ret, "EnumTimeFormatsA(LOCALE_USE_CP_ACP) error %d\n", GetLastError());
2706     trace("%s\n", date_fmt_buf);
2707     /* test the 1st enumerated format */
2708     if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2709     ret = GetLocaleInfoA(lcid, LOCALE_STIMEFORMAT, buf, sizeof(buf));
2710     ok(ret, "GetLocaleInfoA(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
2711     ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2712 }
2713
2714 static void test_GetCPInfo(void)
2715 {
2716     BOOL ret;
2717     CPINFO cpinfo;
2718
2719     SetLastError(0xdeadbeef);
2720     ret = GetCPInfo(CP_SYMBOL, &cpinfo);
2721     ok(!ret, "GetCPInfo(CP_SYMBOL) should fail\n");
2722     ok(GetLastError() == ERROR_INVALID_PARAMETER,
2723        "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
2724
2725     SetLastError(0xdeadbeef);
2726     ret = GetCPInfo(CP_UTF7, &cpinfo);
2727     if (!ret && GetLastError() == ERROR_INVALID_PARAMETER)
2728     {
2729         skip("Codepage CP_UTF7 is not installed/available\n");
2730     }
2731     else
2732     {
2733         ok(ret, "GetCPInfo(CP_UTF7) error %u\n", GetLastError());
2734         ok(cpinfo.DefaultChar[0] == 0x3f, "expected 0x3f, got 0x%x\n", cpinfo.DefaultChar[0]);
2735         ok(cpinfo.DefaultChar[1] == 0, "expected 0, got 0x%x\n", cpinfo.DefaultChar[1]);
2736         ok(cpinfo.LeadByte[0] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[0]);
2737         ok(cpinfo.LeadByte[1] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[1]);
2738         ok(cpinfo.MaxCharSize == 5, "expected 5, got 0x%x\n", cpinfo.MaxCharSize);
2739     }
2740
2741     SetLastError(0xdeadbeef);
2742     ret = GetCPInfo(CP_UTF8, &cpinfo);
2743     if (!ret && GetLastError() == ERROR_INVALID_PARAMETER)
2744     {
2745         skip("Codepage CP_UTF8 is not installed/available\n");
2746     }
2747     else
2748     {
2749         ok(ret, "GetCPInfo(CP_UTF8) error %u\n", GetLastError());
2750         ok(cpinfo.DefaultChar[0] == 0x3f, "expected 0x3f, got 0x%x\n", cpinfo.DefaultChar[0]);
2751         ok(cpinfo.DefaultChar[1] == 0, "expected 0, got 0x%x\n", cpinfo.DefaultChar[1]);
2752         ok(cpinfo.LeadByte[0] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[0]);
2753         ok(cpinfo.LeadByte[1] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[1]);
2754         ok(cpinfo.MaxCharSize == 4 || broken(cpinfo.MaxCharSize == 3) /* win9x */,
2755            "expected 4, got %u\n", cpinfo.MaxCharSize);
2756     }
2757 }
2758
2759 /*
2760  * The CT_TYPE1 has varied over windows version.
2761  * The current target for correct behavior is windows 7.
2762  * There was a big shift between windows 2000 (first introduced) and windows Xp
2763  * Most of the old values below are from windows 2000.
2764  * A smaller subset of changes happened between windows Xp and Window vista/7
2765  */
2766 static void test_GetStringTypeW(void)
2767 {
2768     static const WCHAR blanks[] = {0x9, 0x20, 0xa0, 0x3000, 0xfeff};
2769     static const WORD blanks_new[] = {C1_SPACE | C1_CNTRL | C1_BLANK | C1_DEFINED,
2770                                  C1_SPACE | C1_BLANK | C1_DEFINED,
2771                                  C1_SPACE | C1_BLANK | C1_DEFINED,
2772                                  C1_SPACE | C1_BLANK | C1_DEFINED,
2773                                  C1_CNTRL | C1_BLANK | C1_DEFINED};
2774     static const WORD blanks_old[] ={C1_SPACE | C1_CNTRL | C1_BLANK,
2775                                     C1_SPACE | C1_BLANK,
2776                                     C1_SPACE | C1_BLANK,
2777                                     C1_SPACE | C1_BLANK,
2778                                     C1_SPACE | C1_BLANK};
2779
2780     static const WCHAR undefined[] = {0x378, 0x379, 0x604, 0xfff8, 0xfffe};
2781
2782                                   /* Lu, Ll, Lt */
2783     static const WCHAR alpha[] = {0x47, 0x67, 0x1c5};
2784     static const WORD alpha_old[] = {C1_UPPER | C1_ALPHA,
2785                                      C1_LOWER | C1_ALPHA,
2786                                      C1_UPPER | C1_LOWER | C1_ALPHA,
2787                                      C1_ALPHA};
2788
2789                                   /* Sk, Sk, Mn, So, Me */
2790     static const WCHAR oldpunc[] = { 0x2c2, 0x2e5, 0x322, 0x482, 0x6de,
2791                                  /* Sc, Sm, No,*/
2792                                      0xffe0, 0xffe9, 0x2153};
2793
2794                                 /* Lm, Nl, Cf, 0xad(Cf), 0x1f88 (Lt), Lo, Mc */
2795     static const WCHAR changed[] = {0x2b0, 0x2160, 0x600, 0xad, 0x1f88, 0x294, 0x903};
2796     static const WORD changed_old[] = { C1_PUNCT, C1_PUNCT, 0, C1_PUNCT, C1_UPPER | C1_ALPHA, C1_ALPHA, C1_PUNCT };
2797     static const WORD changed_xp[] = {C1_ALPHA | C1_DEFINED,
2798                                       C1_ALPHA | C1_DEFINED,
2799                                       C1_CNTRL | C1_DEFINED,
2800                                       C1_PUNCT | C1_DEFINED,
2801                                       C1_UPPER | C1_LOWER | C1_ALPHA | C1_DEFINED,
2802                                       C1_ALPHA | C1_LOWER | C1_DEFINED,
2803                                       C1_ALPHA | C1_DEFINED };
2804     static const WORD changed_new[] = { C1_ALPHA | C1_DEFINED,
2805                                       C1_ALPHA | C1_DEFINED,
2806                                       C1_CNTRL | C1_DEFINED,
2807                                       C1_PUNCT | C1_CNTRL | C1_DEFINED,
2808                                       C1_UPPER | C1_LOWER | C1_ALPHA | C1_DEFINED,
2809                                       C1_ALPHA | C1_DEFINED,
2810                                       C1_DEFINED
2811  };
2812                                 /* Pc,  Pd, Ps, Pe, Pi, Pf, Po*/
2813     static const WCHAR punct[] = { 0x5f, 0x2d, 0x28, 0x29, 0xab, 0xbb, 0x21 };
2814
2815     static const WCHAR punct_special[] = {0x24, 0x2b, 0x3c, 0x3e, 0x5e, 0x60,
2816                                           0x7c, 0x7e, 0xa2, 0xbe, 0xd7, 0xf7};
2817     static const WCHAR digit_special[] = {0xb2, 0xb3, 0xb9};
2818     static const WCHAR lower_special[] = {0x2071, 0x207f};
2819     static const WCHAR cntrl_special[] = {0x070f, 0x200c, 0x200d,
2820                   0x200e, 0x200f, 0x202a, 0x202b, 0x202c, 0x202d, 0x202e,
2821                   0x206a, 0x206b, 0x206c, 0x206d, 0x206e, 0x206f, 0xfeff,
2822                   0xfff9, 0xfffa, 0xfffb};
2823     static const WCHAR space_special[] = {0x09, 0x0d, 0x85};
2824
2825     WORD types[20];
2826     int i;
2827
2828     memset(types,0,sizeof(types));
2829     GetStringTypeW(CT_CTYPE1, blanks, 5, types);
2830     for (i = 0; i < 5; i++)
2831         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]);
2832
2833     memset(types,0,sizeof(types));
2834     GetStringTypeW(CT_CTYPE1, alpha, 3, types);
2835     for (i = 0; i < 3; i++)
2836         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]));
2837     memset(types,0,sizeof(types));
2838     GetStringTypeW(CT_CTYPE1, undefined, 5, types);
2839     for (i = 0; i < 5; i++)
2840         ok(types[i] == 0, "incorrect types returned for %x -> (%x != 0)\n",undefined[i], types[i]);
2841
2842     memset(types,0,sizeof(types));
2843     GetStringTypeW(CT_CTYPE1, oldpunc, 8, types);
2844     for (i = 0; i < 8; i++)
2845         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);
2846
2847     memset(types,0,sizeof(types));
2848     GetStringTypeW(CT_CTYPE1, changed, 7, types);
2849     for (i = 0; i < 7; i++)
2850         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]);
2851
2852     memset(types,0,sizeof(types));
2853     GetStringTypeW(CT_CTYPE1, punct, 7, types);
2854     for (i = 0; i < 7; i++)
2855         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));
2856
2857
2858     memset(types,0,sizeof(types));
2859     GetStringTypeW(CT_CTYPE1, punct_special, 12, types);
2860     for (i = 0; i < 12; i++)
2861         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);
2862
2863     memset(types,0,sizeof(types));
2864     GetStringTypeW(CT_CTYPE1, digit_special, 3, types);
2865     for (i = 0; i < 3; i++)
2866         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);
2867
2868     memset(types,0,sizeof(types));
2869     GetStringTypeW(CT_CTYPE1, lower_special, 2, types);
2870     for (i = 0; i < 2; i++)
2871         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);
2872
2873     memset(types,0,sizeof(types));
2874     GetStringTypeW(CT_CTYPE1, cntrl_special, 20, types);
2875     for (i = 0; i < 20; i++)
2876         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);
2877
2878     memset(types,0,sizeof(types));
2879     GetStringTypeW(CT_CTYPE1, space_special, 3, types);
2880     for (i = 0; i < 3; i++)
2881         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 );
2882 }
2883
2884 static void test_IdnToNameprepUnicode(void)
2885 {
2886     struct {
2887         DWORD in_len;
2888         const WCHAR in[64];
2889         DWORD ret;
2890         const WCHAR out[64];
2891         DWORD flags;
2892         DWORD err;
2893         DWORD todo;
2894     } test_data[] = {
2895         {
2896             5, {'t','e','s','t',0},
2897             5, {'t','e','s','t',0},
2898             0, 0xdeadbeef
2899         },
2900         {
2901             3, {'a',0xe111,'b'},
2902             0, {0},
2903             0, ERROR_INVALID_NAME
2904         },
2905         {
2906             4, {'t',0,'e',0},
2907             0, {0},
2908             0, ERROR_INVALID_NAME
2909         },
2910         {
2911             1, {'T',0},
2912             1, {'T',0},
2913             0, 0xdeadbeef
2914         },
2915         {
2916             1, {0},
2917             0, {0},
2918             0, ERROR_INVALID_NAME
2919         },
2920         {
2921             6, {' ','-','/','[',']',0},
2922             6, {' ','-','/','[',']',0},
2923             0, 0xdeadbeef
2924         },
2925         {
2926             3, {'a','-','a'},
2927             3, {'a','-','a'},
2928             IDN_USE_STD3_ASCII_RULES, 0xdeadbeef
2929         },
2930         {
2931             3, {'a','a','-'},
2932             0, {0},
2933             IDN_USE_STD3_ASCII_RULES, ERROR_INVALID_NAME
2934         },
2935         { /* FoldString is not working as expected when MAP_FOLDCZONE is specified (composition+compatibility) */
2936             10, {'T',0xdf,0x130,0x143,0x37a,0x6a,0x30c,' ',0xaa,0},
2937             12, {'t','s','s','i',0x307,0x144,' ',0x3b9,0x1f0,' ','a',0},
2938             0, 0xdeadbeef, TRUE
2939         },
2940         {
2941             11, {'t',0xad,0x34f,0x1806,0x180b,0x180c,0x180d,0x200b,0x200c,0x200d,0},
2942             2, {'t',0},
2943             0, 0xdeadbeef
2944         },
2945         { /* Another example of incorrectly working FoldString (composition) */
2946             2, {0x3b0, 0},
2947             2, {0x3b0, 0},
2948             0, 0xdeadbeef, TRUE
2949         },
2950         {
2951             2, {0x221, 0},
2952             0, {0},
2953             0, ERROR_NO_UNICODE_TRANSLATION
2954         },
2955         {
2956             2, {0x221, 0},
2957             2, {0x221, 0},
2958             IDN_ALLOW_UNASSIGNED, 0xdeadbeef
2959         },
2960         {
2961             5, {'a','.','.','a',0},
2962             0, {0},
2963             0, ERROR_INVALID_NAME
2964         },
2965         {
2966             3, {'a','.',0},
2967             3, {'a','.',0},
2968             0, 0xdeadbeef
2969         },
2970     };
2971
2972     WCHAR buf[1024];
2973     DWORD i, ret, err;
2974
2975     if (!pIdnToNameprepUnicode)
2976     {
2977         win_skip("IdnToNameprepUnicode is not available\n");
2978         return;
2979     }
2980
2981     ret = pIdnToNameprepUnicode(0, test_data[0].in,
2982             test_data[0].in_len, NULL, 0);
2983     ok(ret == test_data[0].ret, "ret = %d\n", ret);
2984
2985     SetLastError(0xdeadbeef);
2986     ret = pIdnToNameprepUnicode(0, test_data[1].in,
2987             test_data[1].in_len, NULL, 0);
2988     err = GetLastError();
2989     ok(ret == test_data[1].ret, "ret = %d\n", ret);
2990     ok(err == test_data[1].err, "err = %d\n", err);
2991
2992     SetLastError(0xdeadbeef);
2993     ret = pIdnToNameprepUnicode(0, test_data[0].in, -1,
2994             buf, sizeof(buf)/sizeof(WCHAR));
2995     err = GetLastError();
2996     ok(ret == test_data[0].ret, "ret = %d\n", ret);
2997     ok(err == 0xdeadbeef, "err = %d\n", err);
2998
2999     SetLastError(0xdeadbeef);
3000     ret = pIdnToNameprepUnicode(0, test_data[0].in, -2,
3001             buf, sizeof(buf)/sizeof(WCHAR));
3002     err = GetLastError();
3003     ok(ret == 0, "ret = %d\n", ret);
3004     ok(err == ERROR_INVALID_PARAMETER, "err = %d\n", err);
3005
3006     SetLastError(0xdeadbeef);
3007     ret = pIdnToNameprepUnicode(0, test_data[0].in, 0,
3008             buf, sizeof(buf)/sizeof(WCHAR));
3009     err = GetLastError();
3010     ok(ret == 0, "ret = %d\n", ret);
3011     ok(err == ERROR_INVALID_NAME, "err = %d\n", err);
3012
3013     ret = pIdnToNameprepUnicode(IDN_ALLOW_UNASSIGNED|IDN_USE_STD3_ASCII_RULES,
3014             test_data[0].in, -1, buf, sizeof(buf)/sizeof(WCHAR));
3015     ok(ret == test_data[0].ret, "ret = %d\n", ret);
3016
3017     SetLastError(0xdeadbeef);
3018     ret = pIdnToNameprepUnicode(0, NULL, 0, NULL, 0);
3019     err = GetLastError();
3020     ok(ret == 0, "ret = %d\n", ret);
3021     ok(err == ERROR_INVALID_PARAMETER, "err = %d\n", err);
3022
3023     SetLastError(0xdeadbeef);
3024     ret = pIdnToNameprepUnicode(4, NULL, 0, NULL, 0);
3025     err = GetLastError();
3026     ok(ret == 0, "ret = %d\n", ret);
3027     ok(err == ERROR_INVALID_FLAGS, "err = %d\n", err);
3028
3029     for (i=0; i<sizeof(test_data)/sizeof(*test_data); i++)
3030     {
3031         SetLastError(0xdeadbeef);
3032         ret = pIdnToNameprepUnicode(test_data[i].flags, test_data[i].in,
3033                 test_data[i].in_len, buf, sizeof(buf)/sizeof(WCHAR));
3034         err = GetLastError();
3035         if(!test_data[i].todo) {
3036             ok(ret == test_data[i].ret, "%d) ret = %d\n", i, ret);
3037             ok(err == test_data[i].err, "%d) err = %d\n", i, err);
3038             ok(!memcmp(test_data[i].out, buf, ret*sizeof(WCHAR)),
3039                     "%d) buf = %s\n", i, wine_dbgstr_wn(buf, ret));
3040         }else {
3041             todo_wine ok(!memcmp(test_data[i].out, buf, ret*sizeof(WCHAR)),
3042                     "%d) buf = %s\n", i, wine_dbgstr_wn(buf, ret));
3043         }
3044     }
3045 }
3046
3047 static void test_IdnToAscii(void)
3048 {
3049     struct {
3050         DWORD in_len;
3051         const WCHAR in[64];
3052         DWORD ret;
3053         const WCHAR out[64];
3054         DWORD flags;
3055         DWORD err;
3056     } test_data[] = {
3057         {
3058             5, {'T','e','s','t',0},
3059             5, {'T','e','s','t',0},
3060             0, 0xdeadbeef
3061         },
3062         {
3063             5, {'T','e',0x017c,'s','t',0},
3064             12, {'x','n','-','-','t','e','s','t','-','c','b','b',0},
3065             0, 0xdeadbeef
3066         },
3067         {
3068             12, {'t','e',0x0105,'s','t','.','t','e',0x017c,'s','t',0},
3069             26, {'x','n','-','-','t','e','s','t','-','c','t','a','.','x','n','-','-','t','e','s','t','-','c','b','b',0},
3070             0, 0xdeadbeef
3071         },
3072         {
3073             3, {0x0105,'.',0},
3074             9, {'x','n','-','-','2','d','a','.',0},
3075             0, 0xdeadbeef
3076         },
3077         {
3078             10, {'h','t','t','p',':','/','/','t',0x0106,0},
3079             17, {'x','n','-','-','h','t','t','p',':','/','/','t','-','7','8','a',0},
3080             0, 0xdeadbeef
3081         },
3082         {
3083             10, {0x4e3a,0x8bf4,0x4e0d,0x4ed6,0x5011,0x10d,0x11b,0x305c,0x306a,0},
3084             35, {'x','n','-','-','b','e','a','2','a','1','6','3','1','a','v','b','a',
3085                 'v','4','4','t','y','h','a','3','2','b','9','1','e','g','s','2','t',0},
3086             0, 0xdeadbeef
3087         },
3088         {
3089             2, {0x221,0},
3090             8, {'x','n','-','-','6','l','a',0},
3091             IDN_ALLOW_UNASSIGNED, 0xdeadbeef
3092         },
3093     };
3094
3095     WCHAR buf[1024];
3096     DWORD i, ret, err;
3097
3098     if (!pIdnToAscii)
3099     {
3100         win_skip("IdnToAscii is not available\n");
3101         return;
3102     }
3103
3104     for (i=0; i<sizeof(test_data)/sizeof(*test_data); i++)
3105     {
3106         SetLastError(0xdeadbeef);
3107         ret = pIdnToAscii(test_data[i].flags, test_data[i].in,
3108                 test_data[i].in_len, buf, sizeof(buf));
3109         err = GetLastError();
3110         ok(ret == test_data[i].ret, "%d) ret = %d\n", i, ret);
3111         ok(err == test_data[i].err, "%d) err = %d\n", i, err);
3112         ok(!memcmp(test_data[i].out, buf, ret*sizeof(WCHAR)),
3113                 "%d) buf = %s\n", i, wine_dbgstr_wn(buf, ret));
3114     }
3115 }
3116
3117 static void test_IdnToUnicode(void)
3118 {
3119     struct {
3120         DWORD in_len;
3121         const WCHAR in[64];
3122         DWORD ret;
3123         const WCHAR out[64];
3124         DWORD flags;
3125         DWORD err;
3126     } test_data[] = {
3127         {
3128             5, {'T','e','s','.',0},
3129             5, {'T','e','s','.',0},
3130             0, 0xdeadbeef
3131         },
3132         {
3133             2, {0x105,0},
3134             0, {0},
3135             0, ERROR_INVALID_NAME
3136         },
3137         {
3138             33, {'x','n','-','-','4','d','b','c','a','g','d','a','h','y','m','b',
3139                 'x','e','k','h','e','h','6','e','0','a','7','f','e','i','0','b',0},
3140             23, {0x05dc,0x05de,0x05d4,0x05d4,0x05dd,0x05e4,0x05e9,0x05d5,0x05d8,
3141                 0x05dc,0x05d0,0x05de,0x05d3,0x05d1,0x05e8,0x05d9,0x05dd,0x05e2,
3142                 0x05d1,0x05e8,0x05d9,0x05ea,0},
3143             0, 0xdeadbeef
3144         },
3145         {
3146             34, {'t','e','s','t','.','x','n','-','-','k','d','a','9','a','g','5','e',
3147                 '9','j','n','f','s','j','.','x','n','-','-','p','d','-','f','n','a'},
3148             16, {'t','e','s','t','.',0x0105,0x0119,0x015b,0x0107,
3149                 0x0142,0x00f3,0x017c,'.','p',0x0119,'d'},
3150             0, 0xdeadbeef
3151         },
3152         {
3153             64, {'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
3154                 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
3155                 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a',
3156                 'a','a','a','a','a','a','a','a','a','a','a','a','a','a','a','a'},
3157             0, {0},
3158             0, ERROR_INVALID_NAME
3159         },
3160         {
3161             8, {'x','n','-','-','6','l','a',0},
3162             2, {0x221,0},
3163             IDN_ALLOW_UNASSIGNED, 0xdeadbeef
3164         },
3165     };
3166
3167     WCHAR buf[1024];
3168     DWORD i, ret, err;
3169
3170     if (!pIdnToUnicode)
3171     {
3172         win_skip("IdnToUnicode is not available\n");
3173         return;
3174     }
3175
3176     for (i=0; i<sizeof(test_data)/sizeof(*test_data); i++)
3177     {
3178         SetLastError(0xdeadbeef);
3179         ret = pIdnToUnicode(test_data[i].flags, test_data[i].in,
3180                 test_data[i].in_len, buf, sizeof(buf));
3181         err = GetLastError();
3182         ok(ret == test_data[i].ret, "%d) ret = %d\n", i, ret);
3183         ok(err == test_data[i].err, "%d) err = %d\n", i, err);
3184         ok(!memcmp(test_data[i].out, buf, ret*sizeof(WCHAR)),
3185                 "%d) buf = %s\n", i, wine_dbgstr_wn(buf, ret));
3186     }
3187 }
3188
3189 START_TEST(locale)
3190 {
3191   InitFunctionPointers();
3192
3193   test_EnumTimeFormatsA();
3194   test_EnumDateFormatsA();
3195   test_GetLocaleInfoA();
3196   test_GetLocaleInfoW();
3197   test_GetTimeFormatA();
3198   test_GetDateFormatA();
3199   test_GetDateFormatW();
3200   test_GetCurrencyFormatA(); /* Also tests the W version */
3201   test_GetNumberFormatA();   /* Also tests the W version */
3202   test_CompareStringA();
3203   test_LCMapStringA();
3204   test_LCMapStringW();
3205   test_LCMapStringEx();
3206   test_LocaleNames();
3207   test_FoldStringA();
3208   test_FoldStringW();
3209   test_ConvertDefaultLocale();
3210   test_EnumSystemLanguageGroupsA();
3211   test_EnumSystemLocalesEx();
3212   test_EnumLanguageGroupLocalesA();
3213   test_SetLocaleInfoA();
3214   test_EnumUILanguageA();
3215   test_GetCPInfo();
3216   test_GetStringTypeW();
3217   test_IdnToNameprepUnicode();
3218   test_IdnToAscii();
3219   test_IdnToUnicode();
3220   /* this requires collation table patch to make it MS compatible */
3221   if (0) test_sorting();
3222 }