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