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