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