git.oblomov.eu Git - wine/blob - dlls/kernel/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., 59 Temple Place, Suite 330, Boston, MA  02111-1307  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
  32 #include "wine/test.h"
  33 #include "windef.h"
  34 #include "winbase.h"
  35 #include "winerror.h"
  36 #include "winnls.h"
  37
  38 static inline unsigned int strlenW( const WCHAR *str )
  39 {
  40     const WCHAR *s = str;
  41     while (*s) s++;
  42     return s - str;
  43 }
  44
  45 static inline int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
  46 {
  47     if (n <= 0) return 0;
  48     while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
  49     return *str1 - *str2;
  50 }
  51
  52 static inline WCHAR *strchrW( const WCHAR *str, WCHAR ch )
  53 {
  54     for ( ; *str; str++) if (*str == ch) return (WCHAR *)str;
  55     return NULL;
  56 }
  57
  58 inline static int isdigitW( WCHAR wc )
  59 {
  60     WORD type;
  61     GetStringTypeW( CT_CTYPE1, &wc, 1, &type );
  62     return type & C1_DIGIT;
  63 }
  64
  65 /* Some functions are only in later versions of kernel32.dll */
  66 static HMODULE hKernel32;
  67
  68 typedef BOOL (WINAPI *EnumSystemLanguageGroupsAFn)(LANGUAGEGROUP_ENUMPROC,
  69                                                    DWORD, LONG_PTR);
  70 static EnumSystemLanguageGroupsAFn pEnumSystemLanguageGroupsA;
  71 typedef BOOL (WINAPI *EnumLanguageGroupLocalesAFn)(LANGGROUPLOCALE_ENUMPROC,
  72                                                    LGRPID, DWORD, LONG_PTR);
  73 static EnumLanguageGroupLocalesAFn pEnumLanguageGroupLocalesA;
  74
  75 typedef INT (WINAPI *FoldStringAFn)(DWORD, LPCSTR, INT, LPSTR, INT);
  76 static FoldStringAFn pFoldStringA;
  77 typedef INT (WINAPI *FoldStringWFn)(DWORD, LPCWSTR, INT, LPWSTR, INT);
  78 static FoldStringWFn pFoldStringW;
  79
  80 typedef BOOL (WINAPI *IsValidLanguageGroupFn)(LGRPID, DWORD);
  81 static IsValidLanguageGroupFn pIsValidLanguageGroup;
  82
  83 static void InitFunctionPointers(void)
  84 {
  85   hKernel32 = GetModuleHandleA("kernel32");
  86
  87   if (hKernel32)
  88   {
  89     pEnumSystemLanguageGroupsA = (void*)GetProcAddress(hKernel32, "EnumSystemLanguageGroupsA");
  90     pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
  91     pFoldStringA = (void*)GetProcAddress(hKernel32, "FoldStringA");
  92     pFoldStringW = (void*)GetProcAddress(hKernel32, "FoldStringW");
  93     pIsValidLanguageGroup = (void*)GetProcAddress(hKernel32, "IsValidLanguageGroup");
  94   }
  95 }
  96
  97 #define eq(received, expected, label, type) \
  98         ok((received) == (expected), "%s: got " type " instead of " type "\n", \
  99            (label), (received), (expected))
 100
 101 #define BUFFER_SIZE    128
 102 char GlobalBuffer[BUFFER_SIZE]; /* Buffer used by callback function */
 103 #define COUNTOF(x) (sizeof(x)/sizeof(x)[0])
 104
 105 #define EXPECT_LEN(len) ok(ret == (len), "Expected Len %d, got %d\n", (len), ret)
 106 #define EXPECT_INVALID  ok(GetLastError() == ERROR_INVALID_PARAMETER, \
 107  "Expected ERROR_INVALID_PARAMETER, got %ld\n", GetLastError())
 108 #define EXPECT_BUFFER  ok(GetLastError() == ERROR_INSUFFICIENT_BUFFER, \
 109  "Expected ERROR_INSUFFICIENT_BUFFER, got %ld\n", GetLastError())
 110 #define EXPECT_FLAGS  ok(GetLastError() == ERROR_INVALID_FLAGS, \
 111  "Expected ERROR_INVALID_FLAGS, got %ld\n", GetLastError())
 112 #define EXPECT_INVALIDFLAGS ok(GetLastError() == ERROR_INVALID_FLAGS || \
 113   GetLastError() == ERROR_INVALID_PARAMETER, \
 114  "Expected ERROR_INVALID_FLAGS, got %ld\n", GetLastError())
 115 #define EXPECT_VALID    ok(GetLastError() == 0, \
 116  "Expected GetLastError() == 0, got %ld\n", GetLastError())
 117
 118 #define STRINGSA(x,y) strcpy(input, x); strcpy(Expected, y); SetLastError(0); buffer[0] = '\0'
 119 #define EXPECT_LENA EXPECT_LEN((int)strlen(Expected)+1)
 120 #define EXPECT_EQA ok(strncmp(buffer, Expected, strlen(Expected)) == 0, \
 121   "Expected '%s', got '%s'\n", Expected, buffer)
 122
 123 #define STRINGSW(x,y) MultiByteToWideChar(CP_ACP,0,x,-1,input,COUNTOF(input)); \
 124    MultiByteToWideChar(CP_ACP,0,y,-1,Expected,COUNTOF(Expected)); \
 125    SetLastError(0); buffer[0] = '\0'
 126 #define EXPECT_LENW EXPECT_LEN((int)strlenW(Expected)+1)
 127 #define EXPECT_EQW  ok(strncmpW(buffer, Expected, strlenW(Expected)) == 0, "Bad conversion\n")
 128
 129 #define NUO LOCALE_NOUSEROVERRIDE
 130
 131 static void test_GetLocaleInfoA()
 132 {
 133   int ret;
 134   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 135   char buffer[BUFFER_SIZE];
 136
 137   ok(lcid == 0x409, "wrong LCID calculated - %ld\n", lcid);
 138
 139   /* HTMLKit and "Font xplorer lite" expect GetLocaleInfoA to
 140    * partially fill the buffer even if it is too short. See bug 637.
 141    */
 142   SetLastError(0); memset(buffer, 0, COUNTOF(buffer));
 143   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 0);
 144   ok(ret == 7 && !buffer[0], "Expected len=7, got %d\n", ret);
 145
 146   SetLastError(0); memset(buffer, 0, COUNTOF(buffer));
 147   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 3);
 148   EXPECT_BUFFER; EXPECT_LEN(0);
 149   ok(!strcmp(buffer, "Mon"), "Expected 'Mon', got '%s'\n", buffer);
 150
 151   SetLastError(0); memset(buffer, 0, COUNTOF(buffer));
 152   ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 10);
 153   EXPECT_VALID; EXPECT_LEN(7);
 154   ok(!strcmp(buffer, "Monday"), "Expected 'Monday', got '%s'\n", buffer);
 155 }
 156
 157 static void test_GetTimeFormatA()
 158 {
 159   int ret;
 160   SYSTEMTIME  curtime;
 161   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 162   char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 163
 164   memset(&curtime, 2, sizeof(SYSTEMTIME));
 165   STRINGSA("tt HH':'mm'@'ss", ""); /* Invalid time */
 166   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 167   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 168
 169   curtime.wHour = 8;
 170   curtime.wMinute = 56;
 171   curtime.wSecond = 13;
 172   curtime.wMilliseconds = 22;
 173   STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Valid time */
 174   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 175   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 176
 177   STRINGSA("tt HH':'mm'@'ss", "A"); /* Insufficent buffer */
 178   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, 2);
 179   EXPECT_BUFFER; EXPECT_LEN(0); EXPECT_EQA;
 180
 181   STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Calculate length only */
 182   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, NULL, 0);
 183   EXPECT_VALID; EXPECT_LENA;
 184
 185   STRINGSA("", "8 AM"); /* TIME_NOMINUTESORSECONDS, default format */
 186   ret = GetTimeFormatA(lcid, NUO|TIME_NOMINUTESORSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 187   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 188
 189   STRINGSA("m1s2m3s4", ""); /* TIME_NOMINUTESORSECONDS/complex format */
 190   ret = GetTimeFormatA(lcid, TIME_NOMINUTESORSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 191   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 192
 193   STRINGSA("", "8:56 AM"); /* TIME_NOSECONDS/Default format */
 194   ret = GetTimeFormatA(lcid, NUO|TIME_NOSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
 195   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 196
 197   STRINGSA("h:m:s tt", "8:56 AM"); /* TIME_NOSECONDS */
 198   strcpy(Expected, "8:56 AM");
 199   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 200   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 201
 202   STRINGSA("h.@:m.@:s.@:tt", "8.@:56AM"); /* Multiple delimiters */
 203   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 204   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 205
 206   STRINGSA("s1s2s3", ""); /* Duplicate tokens */
 207   ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
 208   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 209
 210   STRINGSA("t/tt", "A/AM"); /* AM time marker */
 211   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 212   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 213
 214   curtime.wHour = 13;
 215   STRINGSA("t/tt", "P/PM"); /* PM time marker */
 216   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 217   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 218
 219   STRINGSA("h1t2tt3m", "156"); /* TIME_NOTIMEMARKER: removes text around time marker token */
 220   ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 221   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 222
 223   STRINGSA("h:m:s tt", "13:56:13 PM"); /* TIME_FORCE24HOURFORMAT */
 224   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 225   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 226
 227   STRINGSA("h:m:s", "13:56:13"); /* TIME_FORCE24HOURFORMAT doesn't add time marker */
 228   ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
 229   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 230
 231   curtime.wHour = 14; /* change this to 14 or 2pm */
 232   curtime.wMinute = 5;
 233   curtime.wSecond = 3;
 234   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 */
 235   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 236   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 237
 238   curtime.wHour = 0;
 239   STRINGSA("h/H/hh/HH", "12/0/12/00"); /* "hh" and "HH" */
 240   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 241   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 242
 243   STRINGSA("h:m:s tt", "12:5:3 AM"); /* non-zero flags should fail with format, doesn't */
 244   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 245   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 246
 247   /* try to convert formatting strings with more than two letters
 248    * "h:hh:hhh:H:HH:HHH:m:mm:mmm:M:MM:MMM:s:ss:sss:S:SS:SSS"
 249    * NOTE: We expect any letter for which there is an upper case value
 250    *       we should see a replacement.  For letters that DO NOT have
 251    *       upper case values we should see NO REPLACEMENT.
 252    */
 253   curtime.wHour = 8;
 254   curtime.wMinute = 56;
 255   curtime.wSecond = 13;
 256   curtime.wMilliseconds = 22;
 257   STRINGSA("h:hh:hhh H:HH:HHH m:mm:mmm M:MM:MMM s:ss:sss S:SS:SSS",
 258            "8:08:08 8:08:08 56:56:56 M:MM:MMM 13:13:13 S:SS:SSS");
 259   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 260   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 261
 262   STRINGSA("h", "text"); /* Don't write to buffer if len is 0 */
 263   strcpy(buffer, "text");
 264   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, 0);
 265   EXPECT_VALID; EXPECT_LEN(2); EXPECT_EQA;
 266
 267   STRINGSA("h 'h' H 'H' HH 'HH' m 'm' s 's' t 't' tt 'tt'",
 268            "8 h 8 H 08 HH 56 m 13 s A t AM tt"); /* "'" preserves tokens */
 269   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 270   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 271
 272   STRINGSA("'''", "'"); /* invalid quoted string */
 273   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 274   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 275
 276   /* test that msdn suggested single quotation usage works as expected */
 277   STRINGSA("''''", "'"); /* single quote mark */
 278   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 279   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 280
 281   STRINGSA("''HHHHHH", "08"); /* Normal use */
 282   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 283   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 284
 285   /* and test for normal use of the single quotation mark */
 286   STRINGSA("'''HHHHHH'", "'HHHHHH"); /* Normal use */
 287   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 288   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 289
 290   STRINGSA("'''HHHHHH", "'HHHHHH"); /* Odd use */
 291   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 292   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 293
 294   STRINGSA("'123'tt", ""); /* TIME_NOTIMEMARKER drops literals too */
 295   ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
 296   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 297
 298   curtime.wHour = 25;
 299   STRINGSA("'123'tt", ""); /* Invalid time */
 300   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 301   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 302
 303   curtime.wHour = 12;
 304   curtime.wMonth = 60; /* Invalid */
 305   STRINGSA("h:m:s", "12:56:13"); /* Invalid date */
 306   ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 307   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 308 }
 309
 310 static void test_GetDateFormatA()
 311 {
 312   int ret;
 313   SYSTEMTIME  curtime;
 314   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 315   char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 316
 317   memset(&curtime, 2, sizeof(SYSTEMTIME)); /* Invalid time */
 318   STRINGSA("ddd',' MMM dd yy","");
 319   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 320   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 321
 322   curtime.wYear = 2002;
 323   curtime.wMonth = 5;
 324   curtime.wDay = 4;
 325   curtime.wDayOfWeek = 3;
 326   STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Simple case */
 327   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 328   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 329
 330   STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Format containing "'" */
 331   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 332   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 333
 334   curtime.wHour = 36; /* Invalid */
 335   STRINGSA("ddd',' MMM dd ''''yy","Sat, May 04 '02"); /* Invalid time */
 336   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 337   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 338
 339   STRINGSA("ddd',' MMM dd ''''yy",""); /* Get size only */
 340   ret = GetDateFormatA(lcid, 0, &curtime, input, NULL, 0);
 341   EXPECT_VALID; EXPECT_LEN(16); EXPECT_EQA;
 342
 343   STRINGSA("ddd',' MMM dd ''''yy",""); /* Buffer too small */
 344   ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, 2);
 345   EXPECT_BUFFER; EXPECT_LEN(0); EXPECT_EQA;
 346
 347   STRINGSA("ddd',' MMM dd ''''yy","5/4/2002"); /* Default to DATE_SHORTDATE */
 348   ret = GetDateFormat(lcid, NUO, &curtime, NULL, buffer, COUNTOF(buffer));
 349   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 350
 351   STRINGSA("ddd',' MMM dd ''''yy", "Saturday, May 04, 2002"); /* DATE_LONGDATE */
 352   ret = GetDateFormat(lcid, NUO|DATE_LONGDATE, &curtime, NULL, buffer, COUNTOF(buffer));
 353   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 354
 355   /* test for expected DATE_YEARMONTH behavior with null format */
 356   /* NT4 returns ERROR_INVALID_FLAGS for DATE_YEARMONTH */
 357   STRINGSA("ddd',' MMM dd ''''yy", ""); /* DATE_YEARMONTH */
 358   ret = GetDateFormat(lcid, NUO|DATE_YEARMONTH, &curtime, input, buffer, COUNTOF(buffer));
 359   EXPECT_FLAGS; EXPECT_LEN(0); EXPECT_EQA;
 360
 361   /* Test that using invalid DATE_* flags results in the correct error */
 362   /* and return values */
 363   STRINGSA("m/d/y", ""); /* Invalid flags */
 364   ret = GetDateFormat(lcid, DATE_YEARMONTH|DATE_SHORTDATE|DATE_LONGDATE,
 365                       &curtime, input, buffer, COUNTOF(buffer));
 366   EXPECT_FLAGS; EXPECT_LEN(0); EXPECT_EQA;
 367 }
 368
 369 static void test_GetDateFormatW()
 370 {
 371   int ret;
 372   SYSTEMTIME  curtime;
 373   WCHAR buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
 374   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 375
 376   STRINGSW("",""); /* If flags is not zero then format must be NULL */
 377   ret = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, DATE_LONGDATE, NULL,
 378                        input, buffer, COUNTOF(buffer));
 379   if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
 380       return;
 381   EXPECT_FLAGS; EXPECT_LEN(0); EXPECT_EQW;
 382
 383   STRINGSW("",""); /* NULL buffer, len > 0 */
 384   ret = GetDateFormatW (lcid, 0, NULL, input, NULL, COUNTOF(buffer));
 385   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQW;
 386
 387   STRINGSW("",""); /* NULL buffer, len == 0 */
 388   ret = GetDateFormatW (lcid, 0, NULL, input, NULL, 0);
 389   EXPECT_VALID; EXPECT_LENW; EXPECT_EQW;
 390
 391   curtime.wYear = 2002;
 392   curtime.wMonth = 10;
 393   curtime.wDay = 23;
 394   curtime.wDayOfWeek = 45612; /* Should be 3 - Wednesday */
 395   curtime.wHour = 65432; /* Invalid */
 396   curtime.wMinute = 34512; /* Invalid */
 397   curtime.wSecond = 65535; /* Invalid */
 398   curtime.wMilliseconds = 12345;
 399   STRINGSW("dddd d MMMM yyyy","Wednesday 23 October 2002"); /* Incorrect DOW and time */
 400   ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
 401   EXPECT_VALID; EXPECT_LENW; EXPECT_EQW;
 402 }
 403
 404
 405 #define CY_POS_LEFT  0
 406 #define CY_POS_RIGHT 1
 407 #define CY_POS_LEFT_SPACE  2
 408 #define CY_POS_RIGHT_SPACE 3
 409
 410 static void test_GetCurrencyFormatA()
 411 {
 412   static char szDot[] = { '.', '\0' };
 413   static char szComma[] = { ',', '\0' };
 414   static char szDollar[] = { '$', '\0' };
 415   int ret;
 416   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 417   char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
 418   CURRENCYFMTA format;
 419
 420   memset(&format, 0, sizeof(format));
 421
 422   STRINGSA("23",""); /* NULL output, length > 0 --> Error */
 423   ret = GetCurrencyFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
 424   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 425
 426   STRINGSA("23,53",""); /* Invalid character --> Error */
 427   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 428   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 429
 430   STRINGSA("--",""); /* Double '-' --> Error */
 431   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 432   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 433
 434   STRINGSA("0-",""); /* Trailing '-' --> Error */
 435   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 436   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 437
 438   STRINGSA("0..",""); /* Double '.' --> Error */
 439   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 440   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 441
 442   STRINGSA(" 0.1",""); /* Leading space --> Error */
 443   ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 444   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 445
 446   STRINGSA("1234","$"); /* Length too small --> Write up to length chars */
 447   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, 2);
 448   EXPECT_BUFFER; EXPECT_LEN(0); EXPECT_EQA;
 449
 450   STRINGSA("2353",""); /* Format and flags given --> Error */
 451   ret = GetCurrencyFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
 452   EXPECT_INVALIDFLAGS; EXPECT_LEN(0); EXPECT_EQA;
 453
 454   STRINGSA("2353",""); /* Invalid format --> Error */
 455   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 456   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 457
 458   STRINGSA("2353","$2,353.00"); /* Valid number */
 459   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 460   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 461
 462   STRINGSA("-2353","($2,353.00)"); /* Valid negative number */
 463   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 464   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 465
 466   STRINGSA("2353.1","$2,353.10"); /* Valid real number */
 467   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 468   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 469
 470   STRINGSA("2353.111","$2,353.11"); /* Too many DP --> Truncated */
 471   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 472   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 473
 474   STRINGSA("2353.119","$2,353.12");  /* Too many DP --> Rounded */
 475   ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 476   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 477
 478   format.NumDigits = 0; /* No decimal separator */
 479   format.LeadingZero = 0;
 480   format.Grouping = 0;  /* No grouping char */
 481   format.NegativeOrder = 0;
 482   format.PositiveOrder = CY_POS_LEFT;
 483   format.lpDecimalSep = szDot;
 484   format.lpThousandSep = szComma;
 485   format.lpCurrencySymbol = szDollar;
 486
 487   STRINGSA("2353","$2353"); /* No decimal or grouping chars expected */
 488   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 489   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 490
 491   format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
 492   STRINGSA("2353","$2353.0");
 493   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 494   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 495
 496   format.Grouping = 2; /* Group by 100's */
 497   STRINGSA("2353","$23,53.0");
 498   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 499   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 500
 501   format.LeadingZero = 1; /* Always provide leading zero */
 502   STRINGSA(".5","$0.5");
 503   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 504   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 505
 506   format.PositiveOrder = CY_POS_RIGHT;
 507   STRINGSA("1","1.0$");
 508   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 509   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 510
 511   format.PositiveOrder = CY_POS_LEFT_SPACE;
 512   STRINGSA("1","$ 1.0");
 513   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 514   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 515
 516   format.PositiveOrder = CY_POS_RIGHT_SPACE;
 517   STRINGSA("1","1.0 $");
 518   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 519   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 520
 521   format.NegativeOrder = 0;
 522   STRINGSA("-1","($1.0)");
 523   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 524   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 525
 526   format.NegativeOrder = 1;
 527   STRINGSA("-1","-$1.0");
 528   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 529   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 530
 531   format.NegativeOrder = 2;
 532   STRINGSA("-1","$-1.0");
 533   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 534   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 535
 536   format.NegativeOrder = 3;
 537   STRINGSA("-1","$1.0-");
 538   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 539   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 540
 541   format.NegativeOrder = 4;
 542   STRINGSA("-1","(1.0$)");
 543   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 544   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 545
 546   format.NegativeOrder = 5;
 547   STRINGSA("-1","-1.0$");
 548   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 549   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 550
 551   format.NegativeOrder = 6;
 552   STRINGSA("-1","1.0-$");
 553   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 554   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 555
 556   format.NegativeOrder = 7;
 557   STRINGSA("-1","1.0$-");
 558   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 559   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 560
 561   format.NegativeOrder = 8;
 562   STRINGSA("-1","-1.0 $");
 563   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 564   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 565
 566   format.NegativeOrder = 9;
 567   STRINGSA("-1","-$ 1.0");
 568   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 569   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 570
 571   format.NegativeOrder = 10;
 572   STRINGSA("-1","1.0 $-");
 573   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 574   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 575
 576   format.NegativeOrder = 11;
 577   STRINGSA("-1","$ 1.0-");
 578   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 579   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 580
 581   format.NegativeOrder = 12;
 582   STRINGSA("-1","$ -1.0");
 583   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 584   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 585
 586   format.NegativeOrder = 13;
 587   STRINGSA("-1","1.0- $");
 588   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 589   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 590
 591   format.NegativeOrder = 14;
 592   STRINGSA("-1","($ 1.0)");
 593   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 594   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 595
 596   format.NegativeOrder = 15;
 597   STRINGSA("-1","(1.0 $)");
 598   ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 599   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 600 }
 601
 602 #define NEG_PARENS      0 /* "(1.1)" */
 603 #define NEG_LEFT        1 /* "-1.1"  */
 604 #define NEG_LEFT_SPACE  2 /* "- 1.1" */
 605 #define NEG_RIGHT       3 /* "1.1-"  */
 606 #define NEG_RIGHT_SPACE 4 /* "1.1 -" */
 607
 608 static void test_GetNumberFormatA()
 609 {
 610   static char szDot[] = { '.', '\0' };
 611   static char szComma[] = { ',', '\0' };
 612   int ret;
 613   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 614   char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
 615   NUMBERFMTA format;
 616
 617   memset(&format, 0, sizeof(format));
 618
 619   STRINGSA("23",""); /* NULL output, length > 0 --> Error */
 620   ret = GetNumberFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
 621   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 622
 623   STRINGSA("23,53",""); /* Invalid character --> Error */
 624   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 625   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 626
 627   STRINGSA("--",""); /* Double '-' --> Error */
 628   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 629   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 630
 631   STRINGSA("0-",""); /* Trailing '-' --> Error */
 632   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 633   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 634
 635   STRINGSA("0..",""); /* Double '.' --> Error */
 636   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 637   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 638
 639   STRINGSA(" 0.1",""); /* Leading space --> Error */
 640   ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
 641   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 642
 643   STRINGSA("1234","1"); /* Length too small --> Write up to length chars */
 644   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, 2);
 645   EXPECT_BUFFER; EXPECT_LEN(0); EXPECT_EQA;
 646
 647   STRINGSA("2353",""); /* Format and flags given --> Error */
 648   ret = GetNumberFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
 649   EXPECT_INVALIDFLAGS; EXPECT_LEN(0); EXPECT_EQA;
 650
 651   STRINGSA("2353",""); /* Invalid format --> Error */
 652   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 653   EXPECT_INVALID; EXPECT_LEN(0); EXPECT_EQA;
 654
 655   STRINGSA("2353","2,353.00"); /* Valid number */
 656   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 657   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 658
 659   STRINGSA("-2353","-2,353.00"); /* Valid negative number */
 660   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 661   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 662
 663   STRINGSA("-353","-353.00"); /* test for off by one error in grouping */
 664   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 665   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 666
 667   STRINGSA("2353.1","2,353.10"); /* Valid real number */
 668   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 669   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 670
 671   STRINGSA("2353.111","2,353.11"); /* Too many DP --> Truncated */
 672   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 673   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 674
 675   STRINGSA("2353.119","2,353.12");  /* Too many DP --> Rounded */
 676   ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 677   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 678
 679   format.NumDigits = 0; /* No decimal separator */
 680   format.LeadingZero = 0;
 681   format.Grouping = 0;  /* No grouping char */
 682   format.NegativeOrder = 0;
 683   format.lpDecimalSep = szDot;
 684   format.lpThousandSep = szComma;
 685
 686   STRINGSA("2353","2353"); /* No decimal or grouping chars expected */
 687   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 688   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 689
 690   format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
 691   STRINGSA("2353","2353.0");
 692   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 693   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 694
 695   format.Grouping = 2; /* Group by 100's */
 696   STRINGSA("2353","23,53.0");
 697   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 698   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 699
 700   format.LeadingZero = 1; /* Always provide leading zero */
 701   STRINGSA(".5","0.5");
 702   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 703   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 704
 705   format.NegativeOrder = NEG_PARENS;
 706   STRINGSA("-1","(1.0)");
 707   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 708   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 709
 710   format.NegativeOrder = NEG_LEFT;
 711   STRINGSA("-1","-1.0");
 712   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 713   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 714
 715   format.NegativeOrder = NEG_LEFT_SPACE;
 716   STRINGSA("-1","- 1.0");
 717   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 718   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 719
 720   format.NegativeOrder = NEG_RIGHT;
 721   STRINGSA("-1","1.0-");
 722   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 723   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 724
 725   format.NegativeOrder = NEG_RIGHT_SPACE;
 726   STRINGSA("-1","1.0 -");
 727   ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
 728   EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 729
 730   lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
 731
 732   if (IsValidLocale(lcid, 0))
 733   {
 734     STRINGSA("-12345","-12 345,00"); /* Try French formatting */
 735     Expected[3] = 160; /* Non breaking space */
 736     ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
 737     EXPECT_VALID; EXPECT_LENA; EXPECT_EQA;
 738   }
 739 }
 740
 741
 742 /* Callback function used by TestEnumTimeFormats */
 743 static BOOL CALLBACK EnumTimeFormatsProc(char * lpTimeFormatString)
 744 {
 745   trace("%s\n", lpTimeFormatString);
 746   strcpy(GlobalBuffer, lpTimeFormatString);
 747 #if 0
 748   return TRUE;
 749 #endif
 750   return FALSE;
 751 }
 752
 753 void test_EnumTimeFormats()
 754 {
 755   int ret;
 756   LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 757
 758   GlobalBuffer[0] = '\0';
 759   ret = EnumTimeFormatsA(EnumTimeFormatsProc, lcid, 0);
 760   ok (ret == 1 && !strcmp(GlobalBuffer,"h:mm:ss tt"), "Expected %d '%s'\n", ret, GlobalBuffer);
 761 }
 762
 763 static void test_CompareStringA()
 764 {
 765   int ret;
 766   LCID lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
 767
 768   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "Salute", -1);
 769   ok (ret== 1, "(Salut/Salute) Expected 1, got %d\n", ret);
 770
 771   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "SaLuT", -1);
 772   ok (ret== 2, "(Salut/SaLuT) Expected 2, got %d\n", ret);
 773
 774   ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "hola", -1);
 775   ok (ret== 3, "(Salut/hola) Expected 3, got %d\n", ret);
 776
 777   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
 778   ok (ret== 1, "(haha/hoho) Expected 1, got %d\n", ret);
 779
 780   lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
 781
 782   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
 783   ok (ret== 1, "(haha/hoho) Expected 1, got %d\n", ret);
 784
 785   ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", 0);
 786   ok (ret== 3, "(haha/hoho) Expected 3, got %d\n", ret);
 787
 788     ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", 5, "saLuT", -1);
 789     ok (ret == 2, "(Salut/saLuT) Expected 2, got %d\n", ret);
 790
 791     SetLastError(0xdeadbeef);
 792     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0x10, "NULL", -1, "NULL", -1);
 793     ok(GetLastError() == ERROR_INVALID_FLAGS,
 794         "unexpected error code %ld\n", GetLastError());
 795     ok(!ret, "CompareStringA must fail with invalid flag\n");
 796
 797     ret = lstrcmpA("", "");
 798     ok (ret == 0, "lstrcmpA(\"\", \"\") should return 0, got %d\n", ret);
 799
 800     ret = lstrcmpA(NULL, NULL);
 801     ok (ret == 0, "lstrcmpA(NULL, NULL) should return 0, got %d\n", ret);
 802
 803     ret = lstrcmpA("", NULL);
 804     ok (ret == 1, "lstrcmpA(\"\", NULL) should return 1, got %d\n", ret);
 805
 806     ret = lstrcmpA(NULL, "");
 807     ok (ret == -1, "lstrcmpA(NULL, \"\") should return -1, got %d\n", ret);
 808
 809     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"EndDialog",-1,"_Property",-1);
 810     ok( ret == 3, "EndDialog vs _Property ... expected 3, got %d\n", ret);
 811
 812     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"osp_vba.sreg0070",-1,"_IEWWBrowserComp",-1);
 813     ok( ret == 3, "osp_vba.sreg0070 vs _IEWWBrowserComp ... expected 3, got %d\n", ret);
 814
 815     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"r",-1,"\\",-1);
 816     ok( ret == 3, "r vs \\ ... expected 3, got %d\n", ret);
 817
 818     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"osp_vba.sreg0031", -1, "OriginalDatabase", -1 );
 819     ok( ret == 3, "osp_vba.sreg0031 vs OriginalDatabase ... expected 3, got %d\n", ret);
 820
 821     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aaa", -1 );
 822     ok( ret == 3, "AAA vs aaa expected 3, got %d\n", ret);
 823
 824     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aab", -1 );
 825     ok( ret == 1, "AAA vs aab expected 1, got %d\n", ret);
 826
 827     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "Aab", -1 );
 828     ok( ret == 1, "AAA vs Aab expected 1, got %d\n", ret);
 829
 830     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "Aab", -1 );
 831     ok( ret == 1, ".AAA vs Aab expected 1, got %d\n", ret);
 832
 833     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "A.ab", -1 );
 834     ok( ret == 1, ".AAA vs A.ab expected 1, got %d\n", ret);
 835
 836     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "AB", -1 );
 837     ok( ret == 1, "aa vs AB expected 1, got %d\n", ret);
 838
 839     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "Aab", -1 );
 840     ok( ret == 1, "aa vs Aab expected 1, got %d\n", ret);
 841
 842     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "aB", -1, "Aab", -1 );
 843     ok( ret == 3, "aB vs Aab expected 3, got %d\n", ret);
 844
 845     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "Ba", -1, "bab", -1 );
 846     ok( ret == 1, "Ba vs bab expected 1, got %d\n", ret);
 847
 848     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "{100}{83}{71}{71}{71}", -1, "Global_DataAccess_JRO", -1 );
 849     ok( ret == 1, "{100}{83}{71}{71}{71} vs Global_DataAccess_JRO expected 1, got %d\n", ret);
 850
 851     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "a", -1, "{", -1 );
 852     ok( ret == 3, "a vs { expected 3, got %d\n", ret);
 853
 854     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "A", -1, "{", -1 );
 855     ok( ret == 3, "A vs { expected 3, got %d\n", ret);
 856
 857     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "3.5", 0, "4.0", -1 );
 858     ok(ret == 1, "3.5/0 vs 4.0/-1 expected 1, got %d\n", ret);
 859
 860     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "3.5", -1, "4.0", -1 );
 861     ok(ret == 1, "3.5 vs 4.0 expected 1, got %d\n", ret);
 862
 863     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "3.520.4403.2", -1, "4.0.2927.10", -1 );
 864     ok(ret == 1, "3.520.4403.2 vs 4.0.2927.10 expected 1, got %d\n", ret);
 865
 866    /* hyphen and apostrophe are treated differently depending on
 867     * whether SORT_STRINGSORT specified or not
 868     */
 869     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "-o", -1, "/m", -1 );
 870     ok(ret == 3, "-o vs /m expected 3, got %d\n", ret);
 871
 872     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "-o", -1 );
 873     ok(ret == 1, "/m vs -o expected 1, got %d\n", ret);
 874
 875     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-o", -1, "/m", -1 );
 876     ok(ret == 1, "-o vs /m expected 1, got %d\n", ret);
 877
 878     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "-o", -1 );
 879     ok(ret == 3, "/m vs -o expected 3, got %d\n", ret);
 880
 881     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "/m", -1 );
 882     ok(ret == 3, "'o vs /m expected 3, got %d\n", ret);
 883
 884     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "'o", -1 );
 885     ok(ret == 1, "/m vs 'o expected 1, got %d\n", ret);
 886
 887     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "/m", -1 );
 888     ok(ret == 1, "'o vs /m expected 1, got %d\n", ret);
 889
 890     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "'o", -1 );
 891     ok(ret == 3, "/m vs 'o expected 3, got %d\n", ret);
 892
 893 #if 0 /* this requires collation table patch to make it MS compatible */
 894     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "-o", -1 );
 895     ok(ret == 1, "'o vs -o expected 1, got %d\n", ret);
 896
 897     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "-o", -1 );
 898     ok(ret == 1, "'o vs -o expected 1, got %d\n", ret);
 899
 900     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'", -1, "-", -1 );
 901     ok(ret == 1, "' vs - expected 1, got %d\n", ret);
 902
 903     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'", -1, "-", -1 );
 904     ok(ret == 1, "' vs - expected 1, got %d\n", ret);
 905
 906     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "/m", -1 );
 907     ok(ret == 3, "`o vs /m expected 3, got %d\n", ret);
 908
 909     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "`o", -1 );
 910     ok(ret == 1, "/m vs `o expected 1, got %d\n", ret);
 911
 912     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "/m", -1 );
 913     ok(ret == 3, "`o vs /m expected 3, got %d\n", ret);
 914
 915     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "`o", -1 );
 916     ok(ret == 1, "/m vs `o expected 1, got %d\n", ret);
 917
 918     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "-m", -1 );
 919     ok(ret == 1, "`o vs -m expected 1, got %d\n", ret);
 920
 921     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "-m", -1, "`o", -1 );
 922     ok(ret == 3, "-m vs `o expected 3, got %d\n", ret);
 923
 924     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "-m", -1 );
 925     ok(ret == 3, "`o vs -m expected 3, got %d\n", ret);
 926
 927     ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-m", -1, "`o", -1 );
 928     ok(ret == 1, "-m vs `o expected 1, got %d\n", ret);
 929 #endif
 930
 931     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ", 9);
 932     ok(ret == 2, "aLuZkUtZ vs aLuZkUtZ\\0 expected 2, got %d\n", ret);
 933
 934     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 7, "aLuZkUtZ\0A", 10);
 935     ok(ret == 1, "aLuZkUtZ vs aLuZkUtZ\\0A expected 1, got %d\n", ret);
 936
 937     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ\0A", 10);
 938     ok(ret == 2, "aLuZkUtZ vs aLuZkUtZ\\0A expected 2, got %d\n", ret);
 939
 940     ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLu\0ZkUtZ", 8, "aLu\0ZkUtZ\0A", 10);
 941     ok(ret == 2, "aLu\\0ZkUtZ vs aLu\\0ZkUtZ\\0A expected 2, got %d\n", ret);
 942 }
 943
 944 void test_LCMapStringA(void)
 945 {
 946     int ret, ret2;
 947     char buf[256], buf2[256];
 948     static const char upper_case[] = "\tJUST! A, TEST; STRING 1/*+-.\r\n";
 949     static const char lower_case[] = "\tjust! a, test; string 1/*+-.\r\n";
 950     static const char symbols_stripped[] = "justateststring1";
 951
 952     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | LCMAP_UPPERCASE,
 953                        upper_case, -1, buf, sizeof(buf));
 954     ok(!ret, "LCMAP_LOWERCASE and LCMAP_UPPERCASE are mutually exclusive\n");
 955     ok(GetLastError() == ERROR_INVALID_FLAGS,
 956        "unexpected error code %ld\n", GetLastError());
 957
 958     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_HIRAGANA | LCMAP_KATAKANA,
 959                        upper_case, -1, buf, sizeof(buf));
 960     ok(!ret, "LCMAP_HIRAGANA and LCMAP_KATAKANA are mutually exclusive\n");
 961     ok(GetLastError() == ERROR_INVALID_FLAGS,
 962        "unexpected error code %ld\n", GetLastError());
 963
 964     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_HALFWIDTH | LCMAP_FULLWIDTH,
 965
 966                        upper_case, -1, buf, sizeof(buf));
 967     ok(!ret, "LCMAP_HALFWIDTH | LCMAP_FULLWIDTH are mutually exclusive\n");
 968     ok(GetLastError() == ERROR_INVALID_FLAGS,
 969        "unexpected error code %ld\n", GetLastError());
 970
 971     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE,
 972                        upper_case, -1, buf, sizeof(buf));
 973     ok(!ret, "LCMAP_TRADITIONAL_CHINESE and LCMAP_SIMPLIFIED_CHINESE are mutually exclusive\n");
 974     ok(GetLastError() == ERROR_INVALID_FLAGS,
 975        "unexpected error code %ld\n", GetLastError());
 976
 977     /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
 978     SetLastError(0xdeadbeef);
 979     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | SORT_STRINGSORT,
 980                        upper_case, -1, buf, sizeof(buf));
 981     ok(GetLastError() == ERROR_INVALID_FLAGS, "expected ERROR_INVALID_FLAGS, got %ld\n", GetLastError());
 982     ok(!ret, "SORT_STRINGSORT without LCMAP_SORTKEY must fail\n");
 983
 984     /* test LCMAP_LOWERCASE */
 985     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
 986                        upper_case, -1, buf, sizeof(buf));
 987     ok(ret == lstrlenA(upper_case) + 1,
 988        "ret %d, error %ld, expected value %d\n",
 989        ret, GetLastError(), lstrlenA(upper_case) + 1);
 990     ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
 991
 992     /* test LCMAP_UPPERCASE */
 993     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
 994                        lower_case, -1, buf, sizeof(buf));
 995     ok(ret == lstrlenA(lower_case) + 1,
 996        "ret %d, error %ld, expected value %d\n",
 997        ret, GetLastError(), lstrlenA(lower_case) + 1);
 998     ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
 999
1000     /* test buffer overflow */
1001     SetLastError(0xdeadbeef);
1002     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1003                        lower_case, -1, buf, 4);
1004     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1005        "should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", ret);
1006
1007     /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
1008     lstrcpyA(buf, lower_case);
1009     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1010                        buf, -1, buf, sizeof(buf));
1011     if (!ret) /* Win9x */
1012         trace("Ignoring LCMapStringA(LCMAP_UPPERCASE, buf, buf) error on Win9x\n");
1013     else
1014     {
1015         ok(ret == lstrlenA(lower_case) + 1,
1016            "ret %d, error %ld, expected value %d\n",
1017            ret, GetLastError(), lstrlenA(lower_case) + 1);
1018         ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
1019     }
1020     lstrcpyA(buf, upper_case);
1021     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1022                        buf, -1, buf, sizeof(buf));
1023     if (!ret) /* Win9x */
1024         trace("Ignoring LCMapStringA(LCMAP_LOWERCASE, buf, buf) error on Win9x\n");
1025     else
1026     {
1027         ok(ret == lstrlenA(upper_case) + 1,
1028            "ret %d, error %ld, expected value %d\n",
1029            ret, GetLastError(), lstrlenA(lower_case) + 1);
1030         ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1031     }
1032
1033     /* otherwise src == dst should fail */
1034     SetLastError(0xdeadbeef);
1035     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | LCMAP_UPPERCASE,
1036                        buf, 10, buf, sizeof(buf));
1037     ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
1038        GetLastError() == ERROR_INVALID_PARAMETER /* Win9x */,
1039        "unexpected error code %ld\n", GetLastError());
1040     ok(!ret, "src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n");
1041
1042     /* test whether '\0' is always appended */
1043     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1044                        upper_case, -1, buf, sizeof(buf));
1045     ok(ret, "LCMapStringA must succeed\n");
1046     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1047                        upper_case, lstrlenA(upper_case), buf2, sizeof(buf2));
1048     ok(ret, "LCMapStringA must succeed\n");
1049     ok(ret == ret2, "lengths of sort keys must be equal\n");
1050     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1051
1052     /* test LCMAP_SORTKEY | NORM_IGNORECASE */
1053     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORECASE,
1054                        upper_case, -1, buf, sizeof(buf));
1055     ok(ret, "LCMapStringA must succeed\n");
1056     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1057                        lower_case, -1, buf2, sizeof(buf2));
1058     ok(ret2, "LCMapStringA must succeed\n");
1059     ok(ret == ret2, "lengths of sort keys must be equal\n");
1060     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1061
1062     /* test LCMAP_SORTKEY | NORM_IGNORENONSPACE */
1063     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORENONSPACE,
1064                        lower_case, -1, buf, sizeof(buf));
1065     ok(ret, "LCMapStringA must succeed\n");
1066     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1067                        lower_case, -1, buf2, sizeof(buf2));
1068     ok(ret2, "LCMapStringA must succeed\n");
1069     ok(ret == ret2, "lengths of sort keys must be equal\n");
1070     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1071
1072     /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
1073     ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
1074                        lower_case, -1, buf, sizeof(buf));
1075     ok(ret, "LCMapStringA must succeed\n");
1076     ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1077                        symbols_stripped, -1, buf2, sizeof(buf2));
1078     ok(ret2, "LCMapStringA must succeed\n");
1079     ok(ret == ret2, "lengths of sort keys must be equal\n");
1080     ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1081
1082     /* test NORM_IGNORENONSPACE */
1083     lstrcpyA(buf, "foo");
1084     ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORENONSPACE,
1085                        lower_case, -1, buf, sizeof(buf));
1086     ok(ret == lstrlenA(lower_case) + 1, "LCMapStringA should return %d, ret = %d\n",
1087         lstrlenA(lower_case) + 1, ret);
1088     ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1089
1090     /* test NORM_IGNORESYMBOLS */
1091     lstrcpyA(buf, "foo");
1092     ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORESYMBOLS,
1093                        lower_case, -1, buf, sizeof(buf));
1094     ok(ret == lstrlenA(symbols_stripped) + 1, "LCMapStringA should return %d, ret = %d\n",
1095         lstrlenA(symbols_stripped) + 1, ret);
1096     ok(!lstrcmpA(buf, symbols_stripped), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1097
1098     /* test srclen = 0 */
1099     SetLastError(0xdeadbeef);
1100     ret = LCMapStringA(LOCALE_USER_DEFAULT, 0, upper_case, 0, buf, sizeof(buf));
1101     ok(!ret, "LCMapStringA should fail with srclen = 0\n");
1102     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1103        "unexpected error code %ld\n", GetLastError());
1104 }
1105
1106 void test_LCMapStringW(void)
1107 {
1108     int ret, ret2;
1109     WCHAR buf[256], buf2[256];
1110     char *p_buf = (char *)buf, *p_buf2 = (char *)buf2;
1111     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};
1112     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};
1113     static const WCHAR symbols_stripped[] = {'j','u','s','t','a','t','e','s','t','s','t','r','i','n','g','1',0};
1114     static const WCHAR fooW[] = {'f','o','o',0};
1115
1116     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | LCMAP_UPPERCASE,
1117                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1118     if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1119     {
1120         trace("Skipping LCMapStringW tests on Win9x\n");
1121         return;
1122     }
1123     ok(!ret, "LCMAP_LOWERCASE and LCMAP_UPPERCASE are mutually exclusive\n");
1124     ok(GetLastError() == ERROR_INVALID_FLAGS,
1125        "unexpected error code %ld\n", GetLastError());
1126
1127     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_HIRAGANA | LCMAP_KATAKANA,
1128                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1129     ok(!ret, "LCMAP_HIRAGANA and LCMAP_KATAKANA are mutually exclusive\n");
1130     ok(GetLastError() == ERROR_INVALID_FLAGS,
1131        "unexpected error code %ld\n", GetLastError());
1132
1133     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_HALFWIDTH | LCMAP_FULLWIDTH,
1134                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1135     ok(!ret, "LCMAP_HALFWIDTH | LCMAP_FULLWIDTH are mutually exclusive\n");
1136     ok(GetLastError() == ERROR_INVALID_FLAGS,
1137        "unexpected error code %ld\n", GetLastError());
1138
1139     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE,
1140                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1141     ok(!ret, "LCMAP_TRADITIONAL_CHINESE and LCMAP_SIMPLIFIED_CHINESE are mutually exclusive\n");
1142     ok(GetLastError() == ERROR_INVALID_FLAGS,
1143        "unexpected error code %ld\n", GetLastError());
1144
1145     /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
1146     SetLastError(0xdeadbeef);
1147     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | SORT_STRINGSORT,
1148                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1149     ok(GetLastError() == ERROR_INVALID_FLAGS, "expected ERROR_INVALID_FLAGS, got %ld\n", GetLastError());
1150     ok(!ret, "SORT_STRINGSORT without LCMAP_SORTKEY must fail\n");
1151
1152     /* test LCMAP_LOWERCASE */
1153     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1154                        upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1155     ok(ret == lstrlenW(upper_case) + 1,
1156        "ret %d, error %ld, expected value %d\n",
1157        ret, GetLastError(), lstrlenW(upper_case) + 1);
1158     ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
1159
1160     /* test LCMAP_UPPERCASE */
1161     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1162                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1163     ok(ret == lstrlenW(lower_case) + 1,
1164        "ret %d, error %ld, expected value %d\n",
1165        ret, GetLastError(), lstrlenW(lower_case) + 1);
1166     ok(!lstrcmpW(buf, upper_case), "string compare mismatch\n");
1167
1168     /* test buffer overflow */
1169     SetLastError(0xdeadbeef);
1170     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1171                        lower_case, -1, buf, 4);
1172     ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1173        "should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", ret);
1174
1175     /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
1176     lstrcpyW(buf, lower_case);
1177     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1178                        buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
1179     ok(ret == lstrlenW(lower_case) + 1,
1180        "ret %d, error %ld, expected value %d\n",
1181        ret, GetLastError(), lstrlenW(lower_case) + 1);
1182     ok(!lstrcmpW(buf, upper_case), "string compare mismatch\n");
1183
1184     lstrcpyW(buf, upper_case);
1185     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1186                        buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
1187     ok(ret == lstrlenW(upper_case) + 1,
1188        "ret %d, error %ld, expected value %d\n",
1189        ret, GetLastError(), lstrlenW(lower_case) + 1);
1190     ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
1191
1192     /* otherwise src == dst should fail */
1193     SetLastError(0xdeadbeef);
1194     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | LCMAP_UPPERCASE,
1195                        buf, 10, buf, sizeof(buf));
1196     ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
1197        GetLastError() == ERROR_INVALID_PARAMETER /* Win9x */,
1198        "unexpected error code %ld\n", GetLastError());
1199     ok(!ret, "src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n");
1200
1201     /* test whether '\0' is always appended */
1202     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1203                        upper_case, -1, buf, sizeof(buf));
1204     ok(ret, "LCMapStringW must succeed\n");
1205     ret2 = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1206                        upper_case, lstrlenW(upper_case), buf2, sizeof(buf2));
1207     ok(ret, "LCMapStringW must succeed\n");
1208     ok(ret == ret2, "lengths of sort keys must be equal\n");
1209     ok(!lstrcmpA(p_buf, p_buf2), "sort keys must be equal\n");
1210
1211     /* test LCMAP_SORTKEY | NORM_IGNORECASE */
1212     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORECASE,
1213                        upper_case, -1, buf, sizeof(buf));
1214     ok(ret, "LCMapStringW must succeed\n");
1215     ret2 = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1216                        lower_case, -1, buf2, sizeof(buf2));
1217     ok(ret2, "LCMapStringW must succeed\n");
1218     ok(ret == ret2, "lengths of sort keys must be equal\n");
1219     ok(!lstrcmpA(p_buf, p_buf2), "sort keys must be equal\n");
1220
1221     /* test LCMAP_SORTKEY | NORM_IGNORENONSPACE */
1222     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORENONSPACE,
1223                        lower_case, -1, buf, sizeof(buf));
1224     ok(ret, "LCMapStringW must succeed\n");
1225     ret2 = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1226                        lower_case, -1, buf2, sizeof(buf2));
1227     ok(ret2, "LCMapStringW must succeed\n");
1228     ok(ret == ret2, "lengths of sort keys must be equal\n");
1229     ok(!lstrcmpA(p_buf, p_buf2), "sort keys must be equal\n");
1230
1231     /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
1232     ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
1233                        lower_case, -1, buf, sizeof(buf));
1234     ok(ret, "LCMapStringW must succeed\n");
1235     ret2 = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1236                        symbols_stripped, -1, buf2, sizeof(buf2));
1237     ok(ret2, "LCMapStringW must succeed\n");
1238     ok(ret == ret2, "lengths of sort keys must be equal\n");
1239     ok(!lstrcmpA(p_buf, p_buf2), "sort keys must be equal\n");
1240
1241     /* test NORM_IGNORENONSPACE */
1242     lstrcpyW(buf, fooW);
1243     ret = LCMapStringW(LOCALE_USER_DEFAULT, NORM_IGNORENONSPACE,
1244                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1245     ok(ret == lstrlenW(lower_case) + 1, "LCMapStringW should return %d, ret = %d\n",
1246         lstrlenW(lower_case) + 1, ret);
1247     ok(!lstrcmpW(buf, lower_case), "string comparison mismatch\n");
1248
1249     /* test NORM_IGNORESYMBOLS */
1250     lstrcpyW(buf, fooW);
1251     ret = LCMapStringW(LOCALE_USER_DEFAULT, NORM_IGNORESYMBOLS,
1252                        lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1253     ok(ret == lstrlenW(symbols_stripped) + 1, "LCMapStringW should return %d, ret = %d\n",
1254         lstrlenW(symbols_stripped) + 1, ret);
1255     ok(!lstrcmpW(buf, symbols_stripped), "string comparison mismatch\n");
1256
1257     /* test srclen = 0 */
1258     SetLastError(0xdeadbeef);
1259     ret = LCMapStringW(LOCALE_USER_DEFAULT, 0, upper_case, 0, buf, sizeof(buf));
1260     ok(!ret, "LCMapStringW should fail with srclen = 0\n");
1261     ok(GetLastError() == ERROR_INVALID_PARAMETER,
1262        "unexpected error code %ld\n", GetLastError());
1263 }
1264
1265 #if 0 /* this requires collation table patch to make it MS compatible */
1266 const char *strings_sorted[] =
1267 {
1268 "'",
1269 "-",
1270 "!",
1271 "\"",
1272 ".",
1273 ":",
1274 "\\",
1275 "_",
1276 "`",
1277 "{",
1278 "}",
1279 "+",
1280 "0",
1281 "1",
1282 "2",
1283 "3",
1284 "4",
1285 "5",
1286 "6",
1287 "7",
1288 "8",
1289 "9",
1290 "a",
1291 "A",
1292 "b",
1293 "B",
1294 "c",
1295 "C"
1296 };
1297
1298 const char *strings[] =
1299 {
1300 "C",
1301 "\"",
1302 "9",
1303 "'",
1304 "}",
1305 "-",
1306 "7",
1307 "+",
1308 "`",
1309 "1",
1310 "a",
1311 "5",
1312 "\\",
1313 "8",
1314 "B",
1315 "3",
1316 "_",
1317 "6",
1318 "{",
1319 "2",
1320 "c",
1321 "4",
1322 "!",
1323 "0",
1324 "A",
1325 ":",
1326 "b",
1327 "."
1328 };
1329
1330 static int compare_string1(const void *e1, const void *e2)
1331 {
1332     const char *s1 = *(const char **)e1;
1333     const char *s2 = *(const char **)e2;
1334
1335     return lstrcmpA(s1, s2);
1336 }
1337
1338 static int compare_string2(const void *e1, const void *e2)
1339 {
1340     const char *s1 = *(const char **)e1;
1341     const char *s2 = *(const char **)e2;
1342
1343     return CompareStringA(0, 0, s1, -1, s2, -1) - 2;
1344 }
1345
1346 static int compare_string3(const void *e1, const void *e2)
1347 {
1348     const char *s1 = *(const char **)e1;
1349     const char *s2 = *(const char **)e2;
1350     char key1[256], key2[256];
1351
1352     LCMapStringA(0, LCMAP_SORTKEY, s1, -1, key1, sizeof(key1));
1353     LCMapStringA(0, LCMAP_SORTKEY, s2, -1, key2, sizeof(key2));
1354     return strcmp(key1, key2);
1355 }
1356
1357 static void test_sorting(void)
1358 {
1359     char buf[256];
1360     char **str_buf = (char **)buf;
1361     int i;
1362
1363     assert(sizeof(buf) >= sizeof(strings));
1364
1365     /* 1. sort using lstrcmpA */
1366     memcpy(buf, strings, sizeof(strings));
1367     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string1);
1368     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1369     {
1370         ok(!strcmp(strings_sorted[i], str_buf[i]),
1371            "qsort using lstrcmpA failed for element %d\n", i);
1372     }
1373     /* 2. sort using CompareStringA */
1374     memcpy(buf, strings, sizeof(strings));
1375     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string2);
1376     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1377     {
1378         ok(!strcmp(strings_sorted[i], str_buf[i]),
1379            "qsort using CompareStringA failed for element %d\n", i);
1380     }
1381     /* 3. sort using sort keys */
1382     memcpy(buf, strings, sizeof(strings));
1383     qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string3);
1384     for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1385     {
1386         ok(!strcmp(strings_sorted[i], str_buf[i]),
1387            "qsort using sort keys failed for element %d\n", i);
1388     }
1389 }
1390 #endif
1391
1392 static void test_FoldStringA(void)
1393 {
1394   int ret, i;
1395   char src[256], dst[256];
1396   static const char digits_src[] = { 0xB9,0xB2,0xB3,'\0'  };
1397   static const char digits_dst[] = { '1','2','3','\0'  };
1398   static const char composite_src[] =
1399   {
1400     0x8a,0x8e,0x9a,0x9e,0x9f,0xc0,0xc1,0xc2,
1401     0xc3,0xc4,0xc5,0xc7,0xc8,0xc9,0xca,0xcb,
1402     0xcc,0xcd,0xce,0xcf,0xd1,0xd2,0xd3,0xd4,
1403     0xd5,0xd6,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,
1404     0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe7,0xe8,
1405     0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,0xf1,
1406     0xf2,0xf3,0xf4,0xf5,0xf6,0xf8,0xf9,0xfa,
1407     0xfb,0xfc,0xfd,0xff,'\0'
1408   };
1409   static const char composite_dst[] =
1410   {
1411     0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
1412     0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
1413     0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
1414     0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
1415     0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
1416     0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
1417     0x4f,0x7e,0x4f,0xa8,0x4f,0x3f,0x55,0x60,
1418     0x55,0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,
1419     0x61,0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,
1420     0x61,0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,
1421     0x65,0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,
1422     0x69,0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,
1423     0x6f,0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,
1424     0x6f,0xa8,0x6f,0x3f,0x75,0x60,0x75,0xb4,
1425     0x75,0x5e,0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
1426   };
1427   static const char ligatures_src[] =
1428   {
1429     0x8C,0x9C,0xC6,0xDE,0xDF,0xE6,0xFE,'\0'
1430   };
1431   static const char ligatures_dst[] =
1432   {
1433     'O','E','o','e','A','E','T','H','s','s','a','e','t','h','\0'
1434   };
1435
1436   if (!pFoldStringA)
1437     return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
1438
1439   /* these tests are locale specific */
1440   if (GetACP() != 1252)
1441   {
1442       trace("Skipping FoldStringA tests for a not Latin 1 locale\n");
1443       return;
1444   }
1445
1446   /* MAP_FOLDDIGITS */
1447   SetLastError(0);
1448   ret = pFoldStringA(MAP_FOLDDIGITS, digits_src, -1, dst, 256);
1449   if (GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
1450     return;
1451   EXPECT_LEN(4); EXPECT_VALID;
1452   ok(strcmp(dst, digits_dst) == 0,
1453      "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", digits_dst, dst);
1454   for (i = 1; i < 256; i++)
1455   {
1456     if (!strchr(digits_src, i))
1457     {
1458       src[0] = i;
1459       src[1] = '\0';
1460       SetLastError(0);
1461       ret = pFoldStringA(MAP_FOLDDIGITS, src, -1, dst, 256);
1462       EXPECT_LEN(2); EXPECT_VALID;
1463       ok(dst[0] == src[0],
1464          "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", src, dst);
1465     }
1466   }
1467
1468   /* MAP_EXPAND_LIGATURES */
1469   SetLastError(0);
1470   ret = pFoldStringA(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
1471   EXPECT_LEN(sizeof(ligatures_dst)); EXPECT_VALID;
1472   ok(strcmp(dst, ligatures_dst) == 0,
1473      "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", ligatures_dst, dst);
1474   for (i = 1; i < 256; i++)
1475   {
1476     if (!strchr(ligatures_src, i))
1477     {
1478       src[0] = i;
1479       src[1] = '\0';
1480       SetLastError(0);
1481       ret = pFoldStringA(MAP_EXPAND_LIGATURES, src, -1, dst, 256);
1482       EXPECT_LEN(2); EXPECT_VALID;
1483       ok(dst[0] == src[0],
1484          "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", src, dst);
1485     }
1486   }
1487
1488   /* MAP_COMPOSITE */
1489   SetLastError(0);
1490   ret = pFoldStringA(MAP_COMPOSITE, composite_src, -1, dst, 256);
1491   EXPECT_VALID;
1492   todo_wine
1493   {
1494     /* Wine gets close, but doesn't produce quite the same result as native */
1495     EXPECT_LEN(121);
1496     ok(strcmp(dst, composite_dst) == 0,
1497        "MAP_COMPOSITE: Expected '%s', got '%s'\n", composite_dst, dst);
1498   }
1499
1500   for (i = 1; i < 256; i++)
1501   {
1502     if (!strchr(composite_src, i))
1503     {
1504       src[0] = i;
1505       src[1] = '\0';
1506       SetLastError(0);
1507       ret = pFoldStringA(MAP_COMPOSITE, src, -1, dst, 256);
1508       EXPECT_LEN(2); EXPECT_VALID;
1509       ok(dst[0] == src[0],
1510          "0x%02x, 0x%02x,0x%02x,0x%02x,\n", (unsigned char)src[0],
1511          (unsigned char)dst[0],(unsigned char)dst[1],(unsigned char)dst[2]);
1512     }
1513   }
1514
1515   /* MAP_FOLDCZONE */
1516   for (i = 1; i < 256; i++)
1517   {
1518     src[0] = i;
1519     src[1] = '\0';
1520     SetLastError(0);
1521     ret = pFoldStringA(MAP_FOLDCZONE, src, -1, dst, 256);
1522     EXPECT_LEN(2); EXPECT_VALID;
1523     ok(src[0] == dst[0],
1524        "MAP_FOLDCZONE: Expected 0x%02x, got 0x%02x\n",
1525        (unsigned char)src[0], (unsigned char)dst[0]);
1526   }
1527
1528   /* MAP_PRECOMPOSED */
1529   for (i = 1; i < 256; i++)
1530   {
1531     src[0] = i;
1532     src[1] = '\0';
1533     SetLastError(0);
1534     ret = pFoldStringA(MAP_PRECOMPOSED, src, -1, dst, 256);
1535     EXPECT_LEN(2); EXPECT_VALID;
1536     ok(src[0] == dst[0],
1537        "MAP_PRECOMPOSED: Expected 0x%02x, got 0x%02x\n",
1538        (unsigned char)src[0], (unsigned char)dst[0]);
1539   }
1540 }
1541
1542 static void test_FoldStringW(void)
1543 {
1544   int ret;
1545   size_t i, j;
1546   WCHAR src[256], dst[256], ch, prev_ch = 1;
1547   static const DWORD badFlags[] =
1548   {
1549     0,
1550     MAP_PRECOMPOSED|MAP_COMPOSITE,
1551     MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES,
1552     MAP_COMPOSITE|MAP_EXPAND_LIGATURES
1553   };
1554   /* Ranges of digits 0-9 : Must be sorted! */
1555   static const WCHAR digitRanges[] =
1556   {
1557     0x0030, /* '0'-'9' */
1558     0x0660, /* Eastern Arabic */
1559     0x06F0, /* Arabic - Hindu */
1560     0x0966, /* Devengari */
1561     0x09E6, /* Bengalii */
1562     0x0A66, /* Gurmukhi */
1563     0x0AE6, /* Gujarati */
1564     0x0B66, /* Oriya */
1565     0x0BE6, /* Tamil - No 0 */
1566     0x0C66, /* Telugu */
1567     0x0CE6, /* Kannada */
1568     0x0D66, /* Maylayalam */
1569     0x0E50, /* Thai */
1570     0x0ED0, /* Laos */
1571     0x2070, /* Superscript - 1, 2, 3 are out of sequence */
1572     0x2080, /* Subscript */
1573     0x245F, /* Circled - 0 is out of sequence */
1574     0x2473, /* Bracketed */
1575     0x2487, /* Full stop */
1576     0x2775, /* Inverted circled - No 0 */
1577     0x277F, /* Patterned circled - No 0 */
1578     0x2789, /* Inverted Patterned circled - No 0 */
1579     0xff10, /* Pliene chasse (?) */
1580     0xffff  /* Terminator */
1581   };
1582   /* Digits which are represented, but out of sequence */
1583   static const WCHAR outOfSequenceDigits[] =
1584   {
1585       0xB9,   /* Superscript 1 */
1586       0xB2,   /* Superscript 2 */
1587       0xB3,   /* Superscript 3 */
1588       0x24EA, /* Circled 0 */
1589       '\0'    /* Terminator */
1590   };
1591   /* Digits in digitRanges for which no representation is available */
1592   static const WCHAR noDigitAvailable[] =
1593   {
1594       0x0BE6, /* No Tamil 0 */
1595       0x2473, /* No Bracketed 0 */
1596       0x2487, /* No 0 Full stop */
1597       0x2775, /* No inverted circled 0 */
1598       0x277F, /* No patterned circled */
1599       0x2789, /* No inverted Patterned circled */
1600       '\0'    /* Terminator */
1601   };
1602   /* Compatibility conversion results */
1603   static const WCHAR compat_F900_FA2F[256+48] =
1604   {
1605       0x8c48, 0x66f4, 0x8eca, 0x8cc8, 0x6ed1, 0x4e32, 0x53e5, 0x9f9c,
1606       0x9f9c, 0x5951, 0x91d1, 0x5587, 0x5948, 0x61f6, 0x7669, 0x7f85,
1607       0x863f, 0x87ba, 0x88f8, 0x908f, 0x6a02, 0x6d1b, 0x70d9, 0x73de,
1608       0x843d, 0x916a, 0x99f1, 0x4e82, 0x5375, 0x6b04, 0x721b, 0x862d,
1609       0x9e1e, 0x5d50, 0x6feb, 0x85cd, 0x8964, 0x62c9, 0x81d8, 0x881f,
1610       0x5eca, 0x6717, 0x6d6a, 0x72fc, 0x0000, 0x4f86, 0x51b7, 0x52de,
1611       0x64c4, 0x6ad3, 0x7210, 0x76e7, 0x8001, 0x8606, 0x865c, 0x8def,
1612       0x9732, 0x9b6f, 0x9dfa, 0x788c, 0x797f, 0x7da0, 0x83c9, 0x9304,
1613       0x9e7f, 0x8ad6, 0x58df, 0x5f04, 0x7c60, 0x807e, 0x7262, 0x78ca,
1614       0x8cc2, 0x96f7, 0x58d8, 0x5c62, 0x6a13, 0x6dda, 0x6f0f, 0x7d2f,
1615       0x7e37, 0x964b, 0x52d2, 0x808b, 0x51dc, 0x51cc, 0x7a1c, 0x7dbe,
1616       0x83f1, 0x9675, 0x8b80, 0x62cf, 0x6a02, 0x8afe, 0x4e39, 0x5be7,
1617       0x6012, 0x7387, 0x7570, 0x5317, 0x78fb, 0x4fbf, 0x5fa9, 0x4e0d,
1618       0x6ccc, 0x6578, 0x7d22, 0x53c3, 0x585e, 0x7701, 0x8449, 0x8aaa,
1619       0x6bba, 0x8fb0, 0x6c88, 0x62fe, 0x82e5, 0x63a0, 0x7565, 0x4eae,
1620       0x5169, 0x0000, 0x6881, 0x7ce7, 0x826f, 0x8ad2, 0x91cf, 0x52f5,
1621       0x5442, 0x5973, 0x5eec, 0x65c5, 0x6ffe, 0x792a, 0x95ad, 0x9a6a,
1622       0x9e97, 0x9ece, 0x529b, 0x66c6, 0x6b77, 0x8f62, 0x5e74, 0x6190,
1623       0x6200, 0x649a, 0x6f23, 0x7149, 0x7489, 0x0000, 0x7df4, 0x806f,
1624       0x8f26, 0x84ee, 0x9023, 0x934a, 0x5217, 0x52a3, 0x54bd, 0x70c8,
1625       0x88c2, 0x8aaa, 0x5ec9, 0x5ff5, 0x637b, 0x6bae, 0x7c3e, 0x7375,
1626       0x4ee4, 0x56f9, 0x5be7, 0x5dba, 0x601c, 0x73b2, 0x7469, 0x7f9a,
1627       0x8046, 0x9234, 0x96f6, 0x9748, 0x9818, 0x4f8b, 0x79ae, 0x91b4,
1628       0x96b8, 0x60e1, 0x4e86, 0x50da, 0x5bee, 0x5c3f, 0x6599, 0x6a02,
1629       0x71ce, 0x7642, 0x84fc, 0x907c, 0x9f8d, 0x6688, 0x962e, 0x5289,
1630       0x677b, 0x67f3, 0x6d41, 0x6e9c, 0x7409, 0x7559, 0x786b, 0x7d10,
1631       0x985e, 0x516d, 0x622e, 0x9678, 0x502b, 0x5d19, 0x6dea, 0x8f2a,
1632       0x5f8b, 0x6144, 0x6817, 0x7387, 0x9686, 0x5229, 0x540f, 0x5c65,
1633       0x6613, 0x674e, 0x68a8, 0x6ce5, 0x7406, 0x75e2, 0x7f79, 0x0000,
1634       0x88e1, 0x91cc, 0x96e2, 0x533f, 0x6eba, 0x541d, 0x71d0, 0x7498,
1635       0x85fa, 0x0000, 0x9c57, 0x9e9f, 0x6797, 0x6dcb, 0x81e8, 0x7acb,
1636       0x7b20, 0x7c92, 0x72c0, 0x7099, 0x8b58, 0x4ec0, 0x8336, 0x523a,
1637       0x5207, 0x5ea6, 0x62d3, 0x7cd6, 0x5b85, 0x6d1e, 0x66b4, 0x8f3b,
1638       0x884c, 0x964d, 0x898b, 0x5ed3, 0x0000, 0x0000, 0x0000, 0x0000,
1639       0x585a, 0x0000, 0x6674, 0x0000, 0x0000, 0x51de, 0x8c6c, 0x76ca,
1640       0x0000, 0x795e, 0x7965, 0x798f, 0x9756, 0x7cbe, 0x7fbd, 0x0000,
1641       0x0000, 0x0000, 0x8af8, 0x0000, 0x0000, 0x9038, 0x90fd, 0x0000,
1642       0x0000, 0x0000, 0x98ef, 0x98fc, 0x9928, 0x9db4, 0x0000, 0x0000
1643   };
1644   static const WCHAR compat_FE30_FEF7[200] =
1645   {
1646       0x2025, 0x2014, 0x2013, 0x005f, 0x005f, 0x0028, 0x0029, 0x007b,
1647       0x007d, 0x3014, 0x3015, 0x3010, 0x3011, 0x300a, 0x300b, 0x3008,
1648       0x3009, 0x300c, 0x300d, 0x300e, 0x300f, 0x0000, 0x0000, 0x0000,
1649       0x0000, 0x203e, 0x203e, 0x203e, 0x203e, 0x005f, 0x005f, 0x005f,
1650       0x002c, 0x3001, 0x002e, 0x0000, 0x003b, 0x003a, 0x003f, 0x0021,
1651       0x2014, 0x0028, 0x0029, 0x007b, 0x007d, 0x3014, 0x3015, 0x0023,
1652       0x0026, 0x002a, 0x002b, 0x002d, 0x003c, 0x003e, 0x003d, 0x0000,
1653       0x0000, 0x0024, 0x0025, 0x0040, 0x0000, 0x0000, 0x0000, 0x0000,
1654       0x064b, 0x064b, 0x064c, 0x0000, 0x064d, 0x0000, 0x064e, 0x064e,
1655       0x064f, 0x064f, 0x0650, 0x0650, 0x0651, 0x0651, 0x0652, 0x0652,
1656       0x0621, 0x0622, 0x0622, 0x0623, 0x0623, 0x0624, 0x0624, 0x0625,
1657       0x0625, 0x0626, 0x0626, 0x0626, 0x0626, 0x0627, 0x0627, 0x0628,
1658       0x0628, 0x0628, 0x0628, 0x0629, 0x0629, 0x062a, 0x062a, 0x062a,
1659       0x062a, 0x062b, 0x062b, 0x062b, 0x062b, 0x062c, 0x062c, 0x062c,
1660       0x062c, 0x062d, 0x062d, 0x062d, 0x062d, 0x062e, 0x062e, 0x062e,
1661       0x062e, 0x062f, 0x062f, 0x0630, 0x0630, 0x0631, 0x0631, 0x0632,
1662       0x0632, 0x0633, 0x0633, 0x0633, 0x0633, 0x0634, 0x0634, 0x0634,
1663       0x0634, 0x0635, 0x0635, 0x0635, 0x0635, 0x0636, 0x0636, 0x0636,
1664       0x0636, 0x0637, 0x0637, 0x0637, 0x0637, 0x0638, 0x0638, 0x0638,
1665       0x0638, 0x0639, 0x0639, 0x0639, 0x0639, 0x063a, 0x063a, 0x063a,
1666       0x063a, 0x0641, 0x0641, 0x0641, 0x0641, 0x0642, 0x0642, 0x0642,
1667       0x0642, 0x0643, 0x0643, 0x0643, 0x0643, 0x0644, 0x0644, 0x0644,
1668       0x0644, 0x0645, 0x0645, 0x0645, 0x0645, 0x0646, 0x0646, 0x0646,
1669       0x0646, 0x0647, 0x0647, 0x0647, 0x0647, 0x0648, 0x0648, 0x0649,
1670       0x0649, 0x064a, 0x064a, 0x064a, 0x064a, 0x0000, 0x0000, 0x0000
1671   };
1672   static const WCHAR compat_FF00_FFEF[240] =
1673   {
1674       0x0000, 0x0021, 0x0022, 0x0023, 0x0024, 0x0025, 0x0026, 0x0027,
1675       0x0028, 0x0029, 0x002a, 0x002b, 0x002c, 0x002d, 0x002e, 0x002f,
1676       0x0030, 0x0031, 0x0032, 0x0033, 0x0034, 0x0035, 0x0036, 0x0037,
1677       0x0038, 0x0039, 0x003a, 0x003b, 0x003c, 0x003d, 0x003e, 0x003f,
1678       0x0040, 0x0041, 0x0042, 0x0043, 0x0044, 0x0045, 0x0046, 0x0047,
1679       0x0048, 0x0049, 0x004a, 0x004b, 0x004c, 0x004d, 0x004e, 0x004f,
1680       0x0050, 0x0051, 0x0052, 0x0053, 0x0054, 0x0055, 0x0056, 0x0057,
1681       0x0058, 0x0059, 0x005a, 0x005b, 0x0000, 0x005d, 0x005e, 0x005f,
1682       0x0060, 0x0061, 0x0062, 0x0063, 0x0064, 0x0065, 0x0066, 0x0067,
1683       0x0068, 0x0069, 0x006a, 0x006b, 0x006c, 0x006d, 0x006e, 0x006f,
1684       0x0070, 0x0071, 0x0072, 0x0073, 0x0074, 0x0075, 0x0076, 0x0077,
1685       0x0078, 0x0079, 0x007a, 0x007b, 0x007c, 0x007d, 0x007e, 0x0000,
1686       0x0000, 0x3002, 0x300c, 0x300d, 0x3001, 0x30fb, 0x30f2, 0x30a1,
1687       0x30a3, 0x30a5, 0x30a7, 0x30a9, 0x30e3, 0x30e5, 0x30e7, 0x30c3,
1688       0x30fc, 0x30a2, 0x30a4, 0x30a6, 0x30a8, 0x30aa, 0x30ab, 0x30ad,
1689       0x30af, 0x30b1, 0x30b3, 0x30b5, 0x30b7, 0x30b9, 0x30bb, 0x30bd,
1690       0x30bf, 0x30c1, 0x30c4, 0x30c6, 0x30c8, 0x30ca, 0x30cb, 0x30cc,
1691       0x30cd, 0x30ce, 0x30cf, 0x30d2, 0x30d5, 0x30d8, 0x30db, 0x30de,
1692       0x30df, 0x30e0, 0x30e1, 0x30e2, 0x30e4, 0x30e6, 0x30e8, 0x30e9,
1693       0x30ea, 0x30eb, 0x30ec, 0x30ed, 0x30ef, 0x30f3, 0x309b, 0x309c,
1694       0x3164, 0x3131, 0x3132, 0x3133, 0x3134, 0x3135, 0x3136, 0x3137,
1695       0x3138, 0x3139, 0x313a, 0x313b, 0x313c, 0x313d, 0x313e, 0x313f,
1696       0x3140, 0x3141, 0x3142, 0x3143, 0x3144, 0x3145, 0x3146, 0x3147,
1697       0x3148, 0x3149, 0x314a, 0x314b, 0x314c, 0x314d, 0x314e, 0x0000,
1698       0x0000, 0x0000, 0x314f, 0x3150, 0x3151, 0x3152, 0x3153, 0x3154,
1699       0x0000, 0x0000, 0x3155, 0x3156, 0x3157, 0x3158, 0x3159, 0x315a,
1700       0x0000, 0x0000, 0x315b, 0x315c, 0x315d, 0x315e, 0x315f, 0x3160,
1701       0x0000, 0x0000, 0x3161, 0x3162, 0x3163, 0x0000, 0x0000, 0x0000,
1702       0x00a2, 0x00a3, 0x00ac, 0x00af, 0x00a6, 0x00a5, 0x20a9, 0x0000,
1703       0x2502, 0x2190, 0x2191, 0x2192, 0x2193, 0x25a0, 0x25cb, 0x0000
1704   };
1705   static const WCHAR ligatures_src[] =
1706   {
1707     0x00c6, 0x00de, 0x00df, 0x00e6, 0x00fe, 0x0132, 0x0133, 0x0152,
1708     0x0153, 0x01c4, 0x01c5, 0x01c6, 0x01c7, 0x01c8, 0x01c9, 0x01ca,
1709     0x01cb, 0x01cc, 0x01e2, 0x01e3, 0x01f1, 0x01f2, 0x01f3, 0x01fc,
1710     0x01fd, 0x05f0, 0x05f1, 0x05f2, 0xfb00, 0xfb01, 0xfb02, 0xfb03,
1711     0xfb04, 0xfb05, 0xfb06, '\0'
1712   };
1713   static const WCHAR ligatures_dst[] =
1714   {
1715     'A','E','T','H','s','s','a','e','t','h','I','J','i','j','O','E','o','e',
1716     'D',0x017d,'D',0x017e,'d',0x017e,'L','J','L','j','l','j','N','J','N','j',
1717     'n','j',0x0100,0x0112,0x0101,0x0113,'D','Z','D','z','d','z',0x00c1,0x00c9,
1718     0x00e1,0x00e9,0x05d5,0x05d5,0x05d5,0x05d9,0x05d9,0x05d9,'f','f','f','i',
1719     'f','l','f','f','i','f','f','l',0x017f,'t','s','t','\0'
1720   };
1721
1722   if (!pFoldStringW)
1723     return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
1724
1725   /* Invalid flag combinations */
1726   for (i = 0; i < sizeof(badFlags)/sizeof(badFlags[0]); i++)
1727   {
1728     src[0] = dst[0] = '\0';
1729     SetLastError(0);
1730     ret = pFoldStringW(badFlags[i], src, 256, dst, 256);
1731     if (GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
1732       return;
1733     EXPECT_LEN(0); EXPECT_FLAGS;
1734   }
1735
1736   /* src & dst cannot be the same */
1737   SetLastError(0);
1738   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, src, 256);
1739   EXPECT_LEN(0); EXPECT_INVALID;
1740
1741   /* src can't be NULL */
1742   SetLastError(0);
1743   ret = pFoldStringW(MAP_FOLDCZONE, NULL, -1, dst, 256);
1744   EXPECT_LEN(0); EXPECT_INVALID;
1745
1746   /* srclen can't be 0 */
1747   SetLastError(0);
1748   ret = pFoldStringW(MAP_FOLDCZONE, src, 0, dst, 256);
1749   EXPECT_LEN(0); EXPECT_INVALID;
1750
1751   /* dstlen can't be < 0 */
1752   SetLastError(0);
1753   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, -1);
1754   EXPECT_LEN(0); EXPECT_INVALID;
1755
1756   /* Ret includes terminating NUL which is appended if srclen = -1 */
1757   SetLastError(0);
1758   src[0] = 'A';
1759   src[1] = '\0';
1760   dst[0] = '\0';
1761   ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, 256);
1762   EXPECT_LEN(2); EXPECT_VALID;
1763   ok(dst[0] == 'A' && dst[1] == '\0',
1764      "srclen=-1: Expected ret=2 [%d,%d], got ret=%d [%d,%d], err=%ld\n",
1765      'A', '\0', ret, dst[0], dst[1], GetLastError());
1766
1767   /* If size is given, result is not NUL terminated */
1768   SetLastError(0);
1769   src[0] = 'A';
1770   src[1] = 'A';
1771   dst[0] = 'X';
1772   dst[1] = 'X';
1773   ret = pFoldStringW(MAP_FOLDCZONE, src, 1, dst, 256);
1774   EXPECT_LEN(1); EXPECT_VALID;
1775   ok(dst[0] == 'A' && dst[1] == 'X',
1776      "srclen=1: Expected ret=1, [%d,%d], got ret=%d,[%d,%d], err=%ld\n",
1777      'A','X', ret, dst[0], dst[1], GetLastError());
1778
1779   /* MAP_FOLDDIGITS */
1780   for (j = 0; j < sizeof(digitRanges)/sizeof(digitRanges[0]); j++)
1781   {
1782     /* Check everything before this range */
1783     for (ch = prev_ch; ch < digitRanges[j]; ch++)
1784     {
1785       SetLastError(0);
1786       src[0] = ch;
1787       src[1] = dst[0] = '\0';
1788       ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
1789       EXPECT_LEN(2); EXPECT_VALID;
1790
1791       ok(dst[0] == ch || strchrW(outOfSequenceDigits, ch) ||
1792          /* Wine (correctly) maps all Unicode 4.0+ digits */
1793          isdigitW(ch) || (ch >= 0x24F5 && ch <= 0x24FD) || ch == 0x24FF,
1794          "MAP_FOLDDIGITS: ch %d 0x%04x Expected unchanged got %d\n", ch, ch, dst[0]);
1795     }
1796
1797     if (digitRanges[j] == 0xffff)
1798       break; /* Finished the whole code point space */
1799
1800     for (ch = digitRanges[j]; ch < digitRanges[j] + 10; ch++)
1801     {
1802       WCHAR c;
1803
1804       /* Map out of sequence characters */
1805       if      (ch == 0x2071) c = 0x00B9; /* Superscript 1 */
1806       else if (ch == 0x2072) c = 0x00B2; /* Superscript 2 */
1807       else if (ch == 0x2073) c = 0x00B3; /* Superscript 3 */
1808       else if (ch == 0x245F) c = 0x24EA; /* Circled 0     */
1809       else                   c = ch;
1810       SetLastError(0);
1811       src[0] = c;
1812       src[1] = dst[0] = '\0';
1813       ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
1814       EXPECT_LEN(2); EXPECT_VALID;
1815
1816       ok((dst[0] == '0' + ch - digitRanges[j] && dst[1] == '\0') ||
1817          strchrW(noDigitAvailable, c),
1818          "MAP_FOLDDIGITS: ch %d Expected %d got %d\n",
1819          ch, '0' + digitRanges[j] - ch, dst[0]);
1820     }
1821     prev_ch = ch;
1822   }
1823
1824   /* MAP_FOLDCZONE */
1825   for (ch = 1; ch <0xffff; ch++)
1826   {
1827     WCHAR expected = 0;
1828
1829     if (ch >= 0xF900 && ch <= 0xFA2F)
1830       expected = compat_F900_FA2F[ch - 0xF900];
1831     else if (ch >= 0xFE30 && ch <= 0xFEF7)
1832       expected = compat_FE30_FEF7[ch - 0xFE30];
1833     else if (ch >= 0xFF00 && ch <= 0xFFEF)
1834       expected = compat_FF00_FFEF[ch - 0xFF00];
1835
1836     if (!expected)
1837       expected = ch;
1838
1839     SetLastError(0);
1840     src[0] = ch;
1841     src[1] = dst[0] = '\0';
1842     ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, 256);
1843     EXPECT_LEN(2); EXPECT_VALID;
1844     ok(dst[0] == expected ||
1845        /* Wine (correctly) uses updated mappings for some Unicode 4.0 chars */
1846        (ch >= 0xFA0D && ch <= 0xFA47) ||
1847        0xf92c || ch == 0xf979 || ch == 0xf995 || ch == 0xf9e7 || ch == 0xf9f1,
1848        "MAP_FOLDCZONE: ch %d 0x%04x Expected 0x%04x got 0x%04x\n",
1849        ch, ch, expected, dst[0]);
1850   }
1851
1852   /* MAP_EXPAND_LIGATURES */
1853   SetLastError(0);
1854   ret = pFoldStringW(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
1855   EXPECT_LEN(sizeof(ligatures_dst)/sizeof(ligatures_dst[0])); EXPECT_VALID;
1856   ok(!memcmp(dst, ligatures_dst, sizeof(ligatures_dst)),
1857      "MAP_EXPAND_LIGATURES: Expanded incorrectly\n");
1858   for (i = 1; i <= 0xffff; i++)
1859   {
1860     if (!strchrW(ligatures_src, i))
1861     {
1862       src[0] = i;
1863       src[1] = '\0';
1864       SetLastError(0);
1865       ret = pFoldStringW(MAP_EXPAND_LIGATURES, src, -1, dst, 256);
1866       EXPECT_LEN(2); EXPECT_VALID;
1867       ok(dst[0] == src[0],
1868          "MAP_EXPAND_LIGATURES: 0x%02x : Expected 0x%02x, got 0x%02x\n",
1869          i, src[0], dst[0]);
1870     }
1871   }
1872
1873   /* FIXME: MAP_PRECOMPOSED : MAP_COMPOSITE */
1874 }
1875
1876
1877
1878 #define LCID_OK(l) \
1879   ok(lcid == l, "Expected lcid = %08lx, got %08lx\n", l, lcid)
1880 #define MKLCID(x,y,z) MAKELCID(MAKELANGID(x, y), z)
1881 #define LCID_RES(src, res) lcid = ConvertDefaultLocale(src); LCID_OK(res)
1882 #define TEST_LCIDLANG(a,b) LCID_RES(MAKELCID(a,b), MAKELCID(a,b))
1883 #define TEST_LCID(a,b,c) LCID_RES(MKLCID(a,b,c), MKLCID(a,b,c))
1884
1885 static void test_ConvertDefaultLocale(void)
1886 {
1887   LCID lcid;
1888
1889   /* Doesn't change lcid, even if non default sublang/sort used */
1890   TEST_LCID(LANG_ENGLISH,  SUBLANG_ENGLISH_US, SORT_DEFAULT);
1891   TEST_LCID(LANG_ENGLISH,  SUBLANG_ENGLISH_UK, SORT_DEFAULT);
1892   TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT,    SORT_DEFAULT);
1893   TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT,    SORT_JAPANESE_UNICODE);
1894
1895   /* SUBLANG_NEUTRAL -> SUBLANG_DEFAULT */
1896   LCID_RES(MKLCID(LANG_ENGLISH,  SUBLANG_NEUTRAL, SORT_DEFAULT),
1897            MKLCID(LANG_ENGLISH,  SUBLANG_DEFAULT, SORT_DEFAULT));
1898   LCID_RES(MKLCID(LANG_JAPANESE, SUBLANG_NEUTRAL, SORT_DEFAULT),
1899            MKLCID(LANG_JAPANESE, SUBLANG_DEFAULT, SORT_DEFAULT));
1900   LCID_RES(MKLCID(LANG_JAPANESE, SUBLANG_NEUTRAL, SORT_JAPANESE_UNICODE),
1901            MKLCID(LANG_JAPANESE, SUBLANG_DEFAULT, SORT_JAPANESE_UNICODE));
1902
1903   /* Invariant language is not treated specially */
1904   TEST_LCID(LANG_INVARIANT, SUBLANG_DEFAULT, SORT_DEFAULT);
1905   LCID_RES(MKLCID(LANG_INVARIANT, SUBLANG_NEUTRAL, SORT_DEFAULT),
1906            MKLCID(LANG_INVARIANT, SUBLANG_DEFAULT, SORT_DEFAULT));
1907
1908   /* User/system default languages alone are not mapped */
1909   TEST_LCIDLANG(LANG_SYSTEM_DEFAULT, SORT_JAPANESE_UNICODE);
1910   TEST_LCIDLANG(LANG_USER_DEFAULT,   SORT_JAPANESE_UNICODE);
1911
1912   /* Default lcids */
1913   LCID_RES(LOCALE_SYSTEM_DEFAULT, GetSystemDefaultLCID());
1914   LCID_RES(LOCALE_USER_DEFAULT,   GetUserDefaultLCID());
1915   LCID_RES(LOCALE_NEUTRAL,        GetUserDefaultLCID());
1916 }
1917
1918 static BOOL CALLBACK langgrp_procA(LGRPID lgrpid, LPSTR lpszNum, LPSTR lpszName,
1919                                     DWORD dwFlags, LONG_PTR lParam)
1920 {
1921   trace("%08lx, %s, %s, %08lx, %08lx\n",
1922         lgrpid, lpszNum, lpszName, dwFlags, lParam);
1923
1924   ok(pIsValidLanguageGroup(lgrpid, dwFlags) == TRUE,
1925      "Enumerated grp %ld not valid (flags %ld)\n", lgrpid, dwFlags);
1926
1927   /* If lParam is one, we are calling with flags defaulted from 0 */
1928   ok(!lParam || (dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED),
1929          "Expected dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED, got %ld\n", dwFlags);
1930
1931   return TRUE;
1932 }
1933
1934 static void test_EnumSystemLanguageGroupsA(void)
1935 {
1936   if (!pEnumSystemLanguageGroupsA || !pIsValidLanguageGroup)
1937     return;
1938
1939   /* No enumeration proc */
1940   SetLastError(0);
1941   pEnumSystemLanguageGroupsA(0, LGRPID_INSTALLED, 0);
1942   EXPECT_INVALID;
1943
1944   /* Invalid flags */
1945   SetLastError(0);
1946   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED|LGRPID_SUPPORTED, 0);
1947   EXPECT_FLAGS;
1948
1949   /* No flags - defaults to LGRPID_INSTALLED */
1950   SetLastError(0);
1951   pEnumSystemLanguageGroupsA(langgrp_procA, 0, 1);
1952   EXPECT_VALID;
1953
1954   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED, 0);
1955   pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_SUPPORTED, 0);
1956 }
1957
1958
1959 static BOOL CALLBACK lgrplocale_procA(LGRPID lgrpid, LCID lcid, LPSTR lpszNum,
1960                                       LONG_PTR lParam)
1961 {
1962   trace("%08lx, %08lx, %s, %08lx\n", lgrpid, lcid, lpszNum, lParam);
1963
1964   ok(pIsValidLanguageGroup(lgrpid, LGRPID_SUPPORTED) == TRUE,
1965      "Enumerated grp %ld not valid\n", lgrpid);
1966   ok(IsValidLocale(lcid, LCID_SUPPORTED) == TRUE,
1967      "Enumerated grp locale %ld not valid\n", lcid);
1968   return TRUE;
1969 }
1970
1971 static void test_EnumLanguageGroupLocalesA(void)
1972 {
1973   if (!pEnumLanguageGroupLocalesA || !pIsValidLanguageGroup)
1974     return;
1975
1976   /* No enumeration proc */
1977   SetLastError(0);
1978   pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0, 0);
1979   EXPECT_INVALID;
1980
1981   /* lgrpid too small */
1982   SetLastError(0);
1983   pEnumLanguageGroupLocalesA(lgrplocale_procA, 0, 0, 0);
1984   EXPECT_INVALID;
1985
1986   /* lgrpid too big */
1987   SetLastError(0);
1988   pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_ARMENIAN + 1, 0, 0);
1989   EXPECT_INVALID;
1990
1991   /* dwFlags is reserved */
1992   SetLastError(0);
1993   pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0x1, 0);
1994   EXPECT_INVALID;
1995
1996   pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_WESTERN_EUROPE, 0, 0);
1997 }
1998
1999 static void test_SetLocaleInfoA(void)
2000 {
2001   BOOL bRet;
2002   LCID lcid = GetUserDefaultLCID();
2003
2004   /* Null data */
2005   SetLastError(0);
2006   bRet = SetLocaleInfoA(lcid, LOCALE_SDATE, 0);
2007   EXPECT_INVALID;
2008
2009   /* IDATE */
2010   SetLastError(0);
2011   bRet = SetLocaleInfoA(lcid, LOCALE_IDATE, (LPSTR)test_SetLocaleInfoA);
2012   EXPECT_FLAGS;
2013
2014   /* ILDATE */
2015   SetLastError(0);
2016   bRet = SetLocaleInfoA(lcid, LOCALE_ILDATE, (LPSTR)test_SetLocaleInfoA);
2017   EXPECT_FLAGS;
2018 }
2019
2020 START_TEST(locale)
2021 {
2022   InitFunctionPointers();
2023
2024 #if 0
2025   test_EnumTimeFormats();
2026 #endif
2027   test_GetLocaleInfoA();
2028   test_GetTimeFormatA();
2029   test_GetDateFormatA();
2030   test_GetDateFormatW();
2031   test_GetCurrencyFormatA(); /* Also tests the W version */
2032   test_GetNumberFormatA();   /* Also tests the W version */
2033   test_CompareStringA();
2034   test_LCMapStringA();
2035   test_LCMapStringW();
2036   test_FoldStringA();
2037   test_FoldStringW();
2038   test_ConvertDefaultLocale();
2039   test_EnumSystemLanguageGroupsA();
2040   test_EnumLanguageGroupLocalesA();
2041   test_SetLocaleInfoA();
2042 #if 0 /* this requires collation table patch to make it MS compatible */
2043   test_sorting();
2044 #endif
2045 }