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