?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
push 149f0a5527ac85057a8ef03858d34d91c36f97e8
[wine/hacks.git] / dlls / kernel32 / tests / locale.c
blob48ab35006355275771663a49eb33be0a2449ec57
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 #include <stdio.h>
32
33 #include "wine/test.h"
34 #include "windef.h"
35 #include "winbase.h"
36 #include "winerror.h"
37 #include "winnls.h"
38
39 static inline unsigned int strlenW( const WCHAR *str )
40 {
41 const WCHAR *s = str;
42 while (*s) s++;
43 return s - str;
44 }
45
46 static inline int strncmpW( const WCHAR *str1, const WCHAR *str2, int n )
47 {
48 if (n <= 0) return 0;
49 while ((--n > 0) && *str1 && (*str1 == *str2)) { str1++; str2++; }
50 return *str1 - *str2;
51 }
52
53 static inline WCHAR *strchrW( const WCHAR *str, WCHAR ch )
54 {
55 do { if (*str == ch) return (WCHAR *)str; } while (*str++);
56 return NULL;
57 }
58
59 static inline int isdigitW( WCHAR wc )
60 {
61 WORD type;
62 GetStringTypeW( CT_CTYPE1, &wc, 1, &type );
63 return type & C1_DIGIT;
64 }
65
66 /* Some functions are only in later versions of kernel32.dll */
67 static HMODULE hKernel32;
68 static WORD enumCount;
69
70 typedef BOOL (WINAPI *EnumSystemLanguageGroupsAFn)(LANGUAGEGROUP_ENUMPROC,
71 DWORD, LONG_PTR);
72 static EnumSystemLanguageGroupsAFn pEnumSystemLanguageGroupsA;
73 typedef BOOL (WINAPI *EnumLanguageGroupLocalesAFn)(LANGGROUPLOCALE_ENUMPROC,
74 LGRPID, DWORD, LONG_PTR);
75 static EnumLanguageGroupLocalesAFn pEnumLanguageGroupLocalesA;
76 typedef BOOL (WINAPI *EnumUILanguagesAFn)(UILANGUAGE_ENUMPROC,
77 DWORD, LONG_PTR);
78 static EnumUILanguagesAFn pEnumUILanguagesA;
79
80 typedef INT (WINAPI *FoldStringAFn)(DWORD, LPCSTR, INT, LPSTR, INT);
81 static FoldStringAFn pFoldStringA;
82 typedef INT (WINAPI *FoldStringWFn)(DWORD, LPCWSTR, INT, LPWSTR, INT);
83 static FoldStringWFn pFoldStringW;
84
85 typedef BOOL (WINAPI *IsValidLanguageGroupFn)(LGRPID, DWORD);
86 static IsValidLanguageGroupFn pIsValidLanguageGroup;
87
88 static void InitFunctionPointers(void)
89 {
90 hKernel32 = GetModuleHandleA("kernel32");
91 pEnumSystemLanguageGroupsA = (void*)GetProcAddress(hKernel32, "EnumSystemLanguageGroupsA");
92 pEnumLanguageGroupLocalesA = (void*)GetProcAddress(hKernel32, "EnumLanguageGroupLocalesA");
93 pFoldStringA = (void*)GetProcAddress(hKernel32, "FoldStringA");
94 pFoldStringW = (void*)GetProcAddress(hKernel32, "FoldStringW");
95 pIsValidLanguageGroup = (void*)GetProcAddress(hKernel32, "IsValidLanguageGroup");
96 pEnumUILanguagesA = (void*)GetProcAddress(hKernel32, "EnumUILanguagesA");
97 }
98
99 #define eq(received, expected, label, type) \
100 ok((received) == (expected), "%s: got " type " instead of " type "\n", \
101 (label), (received), (expected))
102
103 #define BUFFER_SIZE 128
104 #define COUNTOF(x) (sizeof(x)/sizeof(x)[0])
105
106 #define STRINGSA(x,y) strcpy(input, x); strcpy(Expected, y); SetLastError(0xdeadbeef); buffer[0] = '\0'
107 #define EXPECT_LENA ok(ret == lstrlen(Expected)+1, "Expected Len %d, got %d\n", lstrlen(Expected)+1, ret)
108 #define EXPECT_EQA ok(strncmp(buffer, Expected, strlen(Expected)) == 0, \
109 "Expected '%s', got '%s'\n", Expected, buffer)
110
111 #define STRINGSW(x,y) MultiByteToWideChar(CP_ACP,0,x,-1,input,COUNTOF(input)); \
112 MultiByteToWideChar(CP_ACP,0,y,-1,Expected,COUNTOF(Expected)); \
113 SetLastError(0xdeadbeef); buffer[0] = '\0'
114 #define EXPECT_LENW ok(ret == lstrlenW(Expected)+1, "Expected Len %d, got %d\n", lstrlenW(Expected)+1, ret)
115 #define EXPECT_EQW ok(strncmpW(buffer, Expected, strlenW(Expected)) == 0, "Bad conversion\n")
116
117 #define NUO LOCALE_NOUSEROVERRIDE
118
119 static void test_GetLocaleInfoA(void)
120 {
121 int ret;
122 int len;
123 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
124 char buffer[BUFFER_SIZE];
125 char expected[BUFFER_SIZE];
126
127 ok(lcid == 0x409, "wrong LCID calculated - %d\n", lcid);
128
129 /* en and ar use SUBLANG_NEUTRAL, but GetLocaleInfo assume SUBLANG_DEFAULT
130 Same is true for zh on pre-Vista, but on Vista and higher GetLocaleInfo
131 assumes SUBLANG_NEUTRAL for zh */
132 memset(expected, 0, COUNTOF(expected));
133 len = GetLocaleInfoA(MAKELANGID(LANG_ENGLISH, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
134 SetLastError(0xdeadbeef);
135 memset(buffer, 0, COUNTOF(buffer));
136 ret = GetLocaleInfoA(LANG_ENGLISH, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
137 ok((ret == len) && !lstrcmpA(buffer, expected),
138 "got %d with '%s' (expected %d with '%s')\n",
139 ret, buffer, len, expected);
140
141 memset(expected, 0, COUNTOF(expected));
142 len = GetLocaleInfoA(MAKELANGID(LANG_ARABIC, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
143 if (len) {
144 SetLastError(0xdeadbeef);
145 memset(buffer, 0, COUNTOF(buffer));
146 ret = GetLocaleInfoA(LANG_ARABIC, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
147 ok((ret == len) && !lstrcmpA(buffer, expected),
148 "got %d with '%s' (expected %d with '%s')\n",
149 ret, buffer, len, expected);
150 }
151 else
152 win_skip("LANG_ARABIC not installed\n");
153
154 /* SUBLANG_DEFAULT is required for mlang.dll, but optional for GetLocaleInfo */
155 memset(expected, 0, COUNTOF(expected));
156 len = GetLocaleInfoA(MAKELANGID(LANG_GERMAN, SUBLANG_DEFAULT), LOCALE_SLANGUAGE, expected, COUNTOF(expected));
157 SetLastError(0xdeadbeef);
158 memset(buffer, 0, COUNTOF(buffer));
159 ret = GetLocaleInfoA(LANG_GERMAN, LOCALE_SLANGUAGE, buffer, COUNTOF(buffer));
160 ok((ret == len) && !lstrcmpA(buffer, expected),
161 "got %d with '%s' (expected %d with '%s')\n",
162 ret, buffer, len, expected);
163
164
165 /* HTMLKit and "Font xplorer lite" expect GetLocaleInfoA to
166 * partially fill the buffer even if it is too short. See bug 637.
167 */
168 SetLastError(0xdeadbeef);
169 memset(buffer, 0, COUNTOF(buffer));
170 ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 0);
171 ok(ret == 7 && !buffer[0], "Expected len=7, got %d\n", ret);
172
173 SetLastError(0xdeadbeef);
174 memset(buffer, 0, COUNTOF(buffer));
175 ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 3);
176 ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
177 "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
178 ok(!strcmp(buffer, "Mon"), "Expected 'Mon', got '%s'\n", buffer);
179
180 SetLastError(0xdeadbeef);
181 memset(buffer, 0, COUNTOF(buffer));
182 ret = GetLocaleInfoA(lcid, NUO|LOCALE_SDAYNAME1, buffer, 10);
183 ok(ret == 7, "Expected ret == 7, got %d, error %d\n", ret, GetLastError());
184 ok(!strcmp(buffer, "Monday"), "Expected 'Monday', got '%s'\n", buffer);
185 }
186
187 static void test_GetLocaleInfoW(void)
188 {
189 LCID lcid_en = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
190 LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
191 WCHAR bufferW[80], buffer2W[80];
192 CHAR bufferA[80];
193 DWORD ret;
194 INT i;
195
196 ret = GetLocaleInfoW(lcid_en, LOCALE_SMONTHNAME1, bufferW, COUNTOF(bufferW));
197 if (!ret) {
198 win_skip("GetLocaleInfoW() isn't implemented\n");
199 return;
200 }
201 ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1, bufferW, COUNTOF(bufferW));
202 if (!ret) {
203 win_skip("LANG_RUSSIAN locale data unavailable\n");
204 return;
205 }
206 ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1|LOCALE_RETURN_GENITIVE_NAMES,
207 bufferW, COUNTOF(bufferW));
208 if (!ret) {
209 win_skip("LOCALE_RETURN_GENITIVE_NAMES isn't supported\n");
210 return;
211 }
212
213 /* LOCALE_RETURN_GENITIVE_NAMES isn't supported for GetLocaleInfoA */
214 bufferA[0] = 'a';
215 SetLastError(0xdeadbeef);
216 ret = GetLocaleInfoA(lcid_ru, LOCALE_SMONTHNAME1|LOCALE_RETURN_GENITIVE_NAMES,
217 bufferA, COUNTOF(bufferA));
218 ok(ret == 0, "LOCALE_RETURN_GENITIVE_NAMES should fail with GetLocaleInfoA\n");
219 ok(bufferA[0] == 'a', "Expected buffer to be untouched\n");
220 ok(GetLastError() == ERROR_INVALID_FLAGS,
221 "Expected ERROR_INVALID_FLAGS, got %x\n", GetLastError());
222
223 bufferW[0] = 'a';
224 SetLastError(0xdeadbeef);
225 ret = GetLocaleInfoW(lcid_ru, LOCALE_RETURN_GENITIVE_NAMES,
226 bufferW, COUNTOF(bufferW));
227 ok(ret == 0,
228 "LOCALE_RETURN_GENITIVE_NAMES itself doesn't return anything, got %d\n", ret);
229 ok(bufferW[0] == 'a', "Expected buffer to be untouched\n");
230 ok(GetLastError() == ERROR_INVALID_FLAGS,
231 "Expected ERROR_INVALID_FLAGS, got %x\n", GetLastError());
232
233 /* yes, test empty 13 month entry too */
234 for (i = 0; i < 12; i++) {
235 bufferW[0] = 0;
236 ret = GetLocaleInfoW(lcid_ru, (LOCALE_SMONTHNAME1+i)|LOCALE_RETURN_GENITIVE_NAMES,
237 bufferW, COUNTOF(bufferW));
238 ok(ret, "Expected non zero result\n");
239 ok(ret == lstrlenW(bufferW)+1, "Expected actual length, got %d, length %d\n",
240 ret, lstrlenW(bufferW));
241 buffer2W[0] = 0;
242 ret = GetLocaleInfoW(lcid_ru, LOCALE_SMONTHNAME1+i,
243 buffer2W, COUNTOF(buffer2W));
244 ok(ret, "Expected non zero result\n");
245 ok(ret == lstrlenW(buffer2W)+1, "Expected actual length, got %d, length %d\n",
246 ret, lstrlenW(buffer2W));
247
248 ok(lstrcmpW(bufferW, buffer2W) != 0,
249 "Expected genitive name to differ, got the same for month %d\n", i+1);
250
251 /* for locale without genitive names nominative returned in both cases */
252 bufferW[0] = 0;
253 ret = GetLocaleInfoW(lcid_en, (LOCALE_SMONTHNAME1+i)|LOCALE_RETURN_GENITIVE_NAMES,
254 bufferW, COUNTOF(bufferW));
255 ok(ret, "Expected non zero result\n");
256 ok(ret == lstrlenW(bufferW)+1, "Expected actual length, got %d, length %d\n",
257 ret, lstrlenW(bufferW));
258 buffer2W[0] = 0;
259 ret = GetLocaleInfoW(lcid_en, LOCALE_SMONTHNAME1+i,
260 buffer2W, COUNTOF(buffer2W));
261 ok(ret, "Expected non zero result\n");
262 ok(ret == lstrlenW(buffer2W)+1, "Expected actual length, got %d, length %d\n",
263 ret, lstrlenW(buffer2W));
264
265 ok(lstrcmpW(bufferW, buffer2W) == 0,
266 "Expected same names, got different for month %d\n", i+1);
267 }
268 }
269
270 static void test_GetTimeFormatA(void)
271 {
272 int ret;
273 SYSTEMTIME curtime;
274 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
275 char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
276
277 memset(&curtime, 2, sizeof(SYSTEMTIME));
278 STRINGSA("tt HH':'mm'@'ss", ""); /* Invalid time */
279 SetLastError(0xdeadbeef);
280 ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
281 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
282 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
283
284 curtime.wHour = 8;
285 curtime.wMinute = 56;
286 curtime.wSecond = 13;
287 curtime.wMilliseconds = 22;
288 STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Valid time */
289 SetLastError(0xdeadbeef);
290 ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
291 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
292 EXPECT_LENA; EXPECT_EQA;
293
294 /* MSDN: LOCALE_NOUSEROVERRIDE can't be specified with a format string */
295 SetLastError(0xdeadbeef);
296 ret = GetTimeFormatA(lcid, NUO|TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
297 ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
298 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
299
300 STRINGSA("tt HH':'mm'@'ss", "A"); /* Insufficient buffer */
301 SetLastError(0xdeadbeef);
302 ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, 2);
303 ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
304 "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
305
306 STRINGSA("tt HH':'mm'@'ss", "AM 08:56@13"); /* Calculate length only */
307 ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, NULL, 0);
308 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
309 EXPECT_LENA;
310
311 STRINGSA("", "8 AM"); /* TIME_NOMINUTESORSECONDS, default format */
312 ret = GetTimeFormatA(lcid, NUO|TIME_NOMINUTESORSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
313 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
314 EXPECT_LENA; EXPECT_EQA;
315
316 STRINGSA("m1s2m3s4", ""); /* TIME_NOMINUTESORSECONDS/complex format */
317 ret = GetTimeFormatA(lcid, TIME_NOMINUTESORSECONDS, &curtime, input, buffer, COUNTOF(buffer));
318 ok(ret == strlen(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
319 ok( !strcmp( buffer, "" ) || broken( !strcmp( buffer, "4" )), /* win9x */
320 "Expected '', got '%s'\n", buffer );
321
322 STRINGSA("", "8:56 AM"); /* TIME_NOSECONDS/Default format */
323 ret = GetTimeFormatA(lcid, NUO|TIME_NOSECONDS, &curtime, NULL, buffer, COUNTOF(buffer));
324 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
325 EXPECT_LENA; EXPECT_EQA;
326
327 STRINGSA("h:m:s tt", "8:56 AM"); /* TIME_NOSECONDS */
328 strcpy(Expected, "8:56 AM");
329 ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
330 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
331 EXPECT_LENA; EXPECT_EQA;
332
333 STRINGSA("h.@:m.@:s.@:tt", "8.@:56AM"); /* Multiple delimiters */
334 ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
335 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
336 ok( !strcmp( buffer, "8.@:56AM" ) || broken( !strcmp( buffer, "8.@:56.@:AM" )) /* win9x */,
337 "Expected '8.@:56AM', got '%s'\n", buffer );
338
339 STRINGSA("s1s2s3", ""); /* Duplicate tokens */
340 ret = GetTimeFormatA(lcid, TIME_NOSECONDS, &curtime, input, buffer, COUNTOF(buffer));
341 ok(ret == strlen(buffer)+1, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
342 ok( !strcmp( buffer, "" ) || broken( !strcmp( buffer, "3" )), /* win9x */
343 "Expected '', got '%s'\n", buffer );
344
345 STRINGSA("t/tt", "A/AM"); /* AM time marker */
346 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
347 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
348 EXPECT_LENA; EXPECT_EQA;
349
350 curtime.wHour = 13;
351 STRINGSA("t/tt", "P/PM"); /* PM time marker */
352 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
353 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
354 EXPECT_LENA; EXPECT_EQA;
355
356 STRINGSA("h1t2tt3m", "156"); /* TIME_NOTIMEMARKER: removes text around time marker token */
357 ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
358 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
359 EXPECT_LENA; EXPECT_EQA;
360
361 STRINGSA("h:m:s tt", "13:56:13 PM"); /* TIME_FORCE24HOURFORMAT */
362 ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
363 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
364 EXPECT_LENA; EXPECT_EQA;
365
366 STRINGSA("h:m:s", "13:56:13"); /* TIME_FORCE24HOURFORMAT doesn't add time marker */
367 ret = GetTimeFormatA(lcid, TIME_FORCE24HOURFORMAT, &curtime, input, buffer, COUNTOF(buffer));
368 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
369 EXPECT_LENA; EXPECT_EQA;
370
371 curtime.wHour = 14; /* change this to 14 or 2pm */
372 curtime.wMinute = 5;
373 curtime.wSecond = 3;
374 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 */
375 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
376 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
377 EXPECT_LENA; EXPECT_EQA;
378
379 curtime.wHour = 0;
380 STRINGSA("h/H/hh/HH", "12/0/12/00"); /* "hh" and "HH" */
381 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
382 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
383 EXPECT_LENA; EXPECT_EQA;
384
385 STRINGSA("h:m:s tt", "12:5:3 AM"); /* non-zero flags should fail with format, doesn't */
386 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
387 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
388 EXPECT_LENA; EXPECT_EQA;
389
390 /* try to convert formatting strings with more than two letters
391 * "h:hh:hhh:H:HH:HHH:m:mm:mmm:M:MM:MMM:s:ss:sss:S:SS:SSS"
392 * NOTE: We expect any letter for which there is an upper case value
393 * we should see a replacement. For letters that DO NOT have
394 * upper case values we should see NO REPLACEMENT.
395 */
396 curtime.wHour = 8;
397 curtime.wMinute = 56;
398 curtime.wSecond = 13;
399 curtime.wMilliseconds = 22;
400 STRINGSA("h:hh:hhh H:HH:HHH m:mm:mmm M:MM:MMM s:ss:sss S:SS:SSS",
401 "8:08:08 8:08:08 56:56:56 M:MM:MMM 13:13:13 S:SS:SSS");
402 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
403 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
404 EXPECT_LENA; EXPECT_EQA;
405
406 STRINGSA("h", "text"); /* Don't write to buffer if len is 0 */
407 strcpy(buffer, "text");
408 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, 0);
409 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
410 EXPECT_EQA;
411
412 STRINGSA("h 'h' H 'H' HH 'HH' m 'm' s 's' t 't' tt 'tt'",
413 "8 h 8 H 08 HH 56 m 13 s A t AM tt"); /* "'" preserves tokens */
414 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
415 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
416 EXPECT_LENA; EXPECT_EQA;
417
418 STRINGSA("'''", "'"); /* invalid quoted string */
419 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
420 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
421 EXPECT_LENA; EXPECT_EQA;
422
423 /* test that msdn suggested single quotation usage works as expected */
424 STRINGSA("''''", "'"); /* single quote mark */
425 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
426 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
427 EXPECT_LENA; EXPECT_EQA;
428
429 STRINGSA("''HHHHHH", "08"); /* Normal use */
430 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
431 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
432 EXPECT_LENA; EXPECT_EQA;
433
434 /* and test for normal use of the single quotation mark */
435 STRINGSA("'''HHHHHH'", "'HHHHHH"); /* Normal use */
436 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
437 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
438 EXPECT_LENA; EXPECT_EQA;
439
440 STRINGSA("'''HHHHHH", "'HHHHHH"); /* Odd use */
441 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
442 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
443 EXPECT_LENA; EXPECT_EQA;
444
445 STRINGSA("'123'tt", ""); /* TIME_NOTIMEMARKER drops literals too */
446 ret = GetTimeFormatA(lcid, TIME_NOTIMEMARKER, &curtime, input, buffer, COUNTOF(buffer));
447 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
448 EXPECT_LENA; EXPECT_EQA;
449
450 curtime.wHour = 25;
451 STRINGSA("'123'tt", ""); /* Invalid time */
452 SetLastError(0xdeadbeef);
453 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
454 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
455 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
456
457 curtime.wHour = 12;
458 curtime.wMonth = 60; /* Invalid */
459 STRINGSA("h:m:s", "12:56:13"); /* Invalid date */
460 ret = GetTimeFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
461 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
462 EXPECT_LENA; EXPECT_EQA;
463 }
464
465 static void test_GetDateFormatA(void)
466 {
467 int ret;
468 SYSTEMTIME curtime;
469 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
470 LCID lcid_ru = MAKELCID(MAKELANGID(LANG_RUSSIAN, SUBLANG_NEUTRAL), SORT_DEFAULT);
471 char buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
472 char short_day[10], month[10], genitive_month[10];
473
474 memset(&curtime, 2, sizeof(SYSTEMTIME)); /* Invalid time */
475 STRINGSA("ddd',' MMM dd yy","");
476 SetLastError(0xdeadbeef);
477 ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
478 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
479 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
480
481 curtime.wYear = 2002;
482 curtime.wMonth = 5;
483 curtime.wDay = 4;
484 curtime.wDayOfWeek = 3;
485 STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Simple case */
486 ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
487 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
488 EXPECT_LENA; EXPECT_EQA;
489
490 /* Same as above but with LOCALE_NOUSEROVERRIDE */
491 STRINGSA("ddd',' MMM dd yy",""); /* Simple case */
492 SetLastError(0xdeadbeef);
493 ret = GetDateFormatA(lcid, NUO, &curtime, input, buffer, COUNTOF(buffer));
494 ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
495 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
496 EXPECT_EQA;
497
498 STRINGSA("ddd',' MMM dd yy","Sat, May 04 02"); /* Format containing "'" */
499 ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
500 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
501 EXPECT_LENA; EXPECT_EQA;
502
503 curtime.wHour = 36; /* Invalid */
504 STRINGSA("ddd',' MMM dd ''''yy","Sat, May 04 '02"); /* Invalid time */
505 ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
506 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
507 EXPECT_LENA; EXPECT_EQA;
508
509 STRINGSA("ddd',' MMM dd ''''yy",""); /* Get size only */
510 ret = GetDateFormatA(lcid, 0, &curtime, input, NULL, 0);
511 ok(ret == 16, "Expected ret == 16, got %d, error %d\n", ret, GetLastError());
512 EXPECT_EQA;
513
514 STRINGSA("ddd',' MMM dd ''''yy",""); /* Buffer too small */
515 SetLastError(0xdeadbeef);
516 ret = GetDateFormatA(lcid, 0, &curtime, input, buffer, 2);
517 ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
518 "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
519
520 STRINGSA("ddd',' MMM dd ''''yy","5/4/2002"); /* Default to DATE_SHORTDATE */
521 ret = GetDateFormat(lcid, NUO, &curtime, NULL, buffer, COUNTOF(buffer));
522 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
523 if (strncmp(buffer, Expected, strlen(Expected)) && strncmp(buffer, "5/4/02", strlen(Expected)) != 0)
524 ok (0, "Expected '%s' or '5/4/02', got '%s'\n", Expected, buffer);
525
526 STRINGSA("ddd',' MMM dd ''''yy", "Saturday, May 04, 2002"); /* DATE_LONGDATE */
527 ret = GetDateFormat(lcid, NUO|DATE_LONGDATE, &curtime, NULL, buffer, COUNTOF(buffer));
528 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
529 EXPECT_LENA; EXPECT_EQA;
530
531 /* test for expected DATE_YEARMONTH behavior with null format */
532 /* NT4 returns ERROR_INVALID_FLAGS for DATE_YEARMONTH */
533 STRINGSA("ddd',' MMM dd ''''yy", ""); /* DATE_YEARMONTH */
534 SetLastError(0xdeadbeef);
535 ret = GetDateFormat(lcid, NUO|DATE_YEARMONTH, &curtime, input, buffer, COUNTOF(buffer));
536 ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
537 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
538 EXPECT_EQA;
539
540 /* Test that using invalid DATE_* flags results in the correct error */
541 /* and return values */
542 STRINGSA("m/d/y", ""); /* Invalid flags */
543 SetLastError(0xdeadbeef);
544 ret = GetDateFormat(lcid, DATE_YEARMONTH|DATE_SHORTDATE|DATE_LONGDATE,
545 &curtime, input, buffer, COUNTOF(buffer));
546 ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
547 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
548
549 ret = GetDateFormat(lcid_ru, 0, &curtime, "ddMMMM", buffer, COUNTOF(buffer));
550 if (!ret)
551 {
552 win_skip("LANG_RUSSIAN locale data unavailable\n");
553 return;
554 }
555
556 /* month part should be in genitive form */
557 strcpy(genitive_month, buffer + 2);
558 ret = GetDateFormat(lcid_ru, 0, &curtime, "MMMM", buffer, COUNTOF(buffer));
559 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
560 strcpy(month, buffer);
561 ok(strcmp(genitive_month, month) != 0, "Expected different month forms\n");
562
563 ret = GetDateFormat(lcid_ru, 0, &curtime, "ddd", buffer, COUNTOF(buffer));
564 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
565 strcpy(short_day, buffer);
566
567 STRINGSA("dd MMMMddd dd", "");
568 sprintf(Expected, "04 %s%s 04", genitive_month, short_day);
569 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
570 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
571 EXPECT_EQA;
572
573 STRINGSA("MMMMddd dd", "");
574 sprintf(Expected, "%s%s 04", month, short_day);
575 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
576 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
577 EXPECT_EQA;
578
579 STRINGSA("MMMMddd", "");
580 sprintf(Expected, "%s%s", month, short_day);
581 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
582 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
583 EXPECT_EQA;
584
585 STRINGSA("MMMMdd", "");
586 sprintf(Expected, "%s04", genitive_month);
587 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
588 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
589 EXPECT_EQA;
590
591 STRINGSA("MMMMdd ddd", "");
592 sprintf(Expected, "%s04 %s", genitive_month, short_day);
593 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
594 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
595 EXPECT_EQA;
596
597 STRINGSA("dd dddMMMM", "");
598 sprintf(Expected, "04 %s%s", short_day, month);
599 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
600 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
601 EXPECT_EQA;
602
603 STRINGSA("dd dddMMMM ddd MMMMdd", "");
604 sprintf(Expected, "04 %s%s %s %s04", short_day, month, short_day, genitive_month);
605 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
606 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
607 EXPECT_EQA;
608
609 /* with literal part */
610 STRINGSA("ddd',' MMMM dd", "");
611 sprintf(Expected, "%s, %s 04", short_day, genitive_month);
612 ret = GetDateFormat(lcid_ru, 0, &curtime, input, buffer, COUNTOF(buffer));
613 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
614 EXPECT_EQA;
615 }
616
617 static void test_GetDateFormatW(void)
618 {
619 int ret;
620 SYSTEMTIME curtime;
621 WCHAR buffer[BUFFER_SIZE], input[BUFFER_SIZE], Expected[BUFFER_SIZE];
622 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
623
624 STRINGSW("",""); /* If flags is not zero then format must be NULL */
625 ret = GetDateFormatW(LOCALE_SYSTEM_DEFAULT, DATE_LONGDATE, NULL,
626 input, buffer, COUNTOF(buffer));
627 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
628 {
629 win_skip("GetDateFormatW is not implemented\n");
630 return;
631 }
632 ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
633 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
634 EXPECT_EQW;
635
636 STRINGSW("",""); /* NULL buffer, len > 0 */
637 SetLastError(0xdeadbeef);
638 ret = GetDateFormatW (lcid, 0, NULL, input, NULL, COUNTOF(buffer));
639 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
640 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
641
642 STRINGSW("",""); /* NULL buffer, len == 0 */
643 ret = GetDateFormatW (lcid, 0, NULL, input, NULL, 0);
644 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
645 EXPECT_LENW; EXPECT_EQW;
646
647 curtime.wYear = 2002;
648 curtime.wMonth = 10;
649 curtime.wDay = 23;
650 curtime.wDayOfWeek = 45612; /* Should be 3 - Wednesday */
651 curtime.wHour = 65432; /* Invalid */
652 curtime.wMinute = 34512; /* Invalid */
653 curtime.wSecond = 65535; /* Invalid */
654 curtime.wMilliseconds = 12345;
655 STRINGSW("dddd d MMMM yyyy","Wednesday 23 October 2002"); /* Incorrect DOW and time */
656 ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
657 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
658 EXPECT_LENW; EXPECT_EQW;
659
660 /* Limit tests */
661
662 curtime.wYear = 1601;
663 curtime.wMonth = 1;
664 curtime.wDay = 1;
665 curtime.wDayOfWeek = 0; /* Irrelevant */
666 curtime.wHour = 0;
667 curtime.wMinute = 0;
668 curtime.wSecond = 0;
669 curtime.wMilliseconds = 0;
670 STRINGSW("dddd d MMMM yyyy","Monday 1 January 1601");
671 SetLastError(0xdeadbeef);
672 ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
673 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
674 EXPECT_LENW; EXPECT_EQW;
675
676 curtime.wYear = 1600;
677 curtime.wMonth = 12;
678 curtime.wDay = 31;
679 curtime.wDayOfWeek = 0; /* Irrelevant */
680 curtime.wHour = 23;
681 curtime.wMinute = 59;
682 curtime.wSecond = 59;
683 curtime.wMilliseconds = 999;
684 STRINGSW("dddd d MMMM yyyy","Friday 31 December 1600");
685 SetLastError(0xdeadbeef);
686 ret = GetDateFormatW (lcid, 0, &curtime, input, buffer, COUNTOF(buffer));
687 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
688 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
689 }
690
691
692 #define CY_POS_LEFT 0
693 #define CY_POS_RIGHT 1
694 #define CY_POS_LEFT_SPACE 2
695 #define CY_POS_RIGHT_SPACE 3
696
697 static void test_GetCurrencyFormatA(void)
698 {
699 static char szDot[] = { '.', '\0' };
700 static char szComma[] = { ',', '\0' };
701 static char szDollar[] = { '$', '\0' };
702 int ret;
703 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
704 char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
705 CURRENCYFMTA format;
706
707 memset(&format, 0, sizeof(format));
708
709 STRINGSA("23",""); /* NULL output, length > 0 --> Error */
710 SetLastError(0xdeadbeef);
711 ret = GetCurrencyFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
712 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
713 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
714
715 STRINGSA("23,53",""); /* Invalid character --> Error */
716 SetLastError(0xdeadbeef);
717 ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
718 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
719 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
720
721 STRINGSA("--",""); /* Double '-' --> Error */
722 SetLastError(0xdeadbeef);
723 ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
724 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
725 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
726
727 STRINGSA("0-",""); /* Trailing '-' --> Error */
728 SetLastError(0xdeadbeef);
729 ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
730 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
731 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
732
733 STRINGSA("0..",""); /* Double '.' --> Error */
734 SetLastError(0xdeadbeef);
735 ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
736 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
737 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
738
739 STRINGSA(" 0.1",""); /* Leading space --> Error */
740 SetLastError(0xdeadbeef);
741 ret = GetCurrencyFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
742 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
743 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
744
745 STRINGSA("1234","$"); /* Length too small --> Write up to length chars */
746 SetLastError(0xdeadbeef);
747 ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, 2);
748 ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
749 "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
750
751 STRINGSA("2353",""); /* Format and flags given --> Error */
752 SetLastError(0xdeadbeef);
753 ret = GetCurrencyFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
754 ok( !ret, "Expected ret == 0, got %d\n", ret);
755 ok( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER,
756 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
757
758 STRINGSA("2353",""); /* Invalid format --> Error */
759 SetLastError(0xdeadbeef);
760 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
761 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
762 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
763
764 STRINGSA("2353","$2,353.00"); /* Valid number */
765 ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
766 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
767 EXPECT_LENA; EXPECT_EQA;
768
769 STRINGSA("-2353","($2,353.00)"); /* Valid negative number */
770 ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
771 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
772 EXPECT_LENA; EXPECT_EQA;
773
774 STRINGSA("2353.1","$2,353.10"); /* Valid real number */
775 ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
776 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
777 EXPECT_LENA; EXPECT_EQA;
778
779 STRINGSA("2353.111","$2,353.11"); /* Too many DP --> Truncated */
780 ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
781 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
782 EXPECT_LENA; EXPECT_EQA;
783
784 STRINGSA("2353.119","$2,353.12"); /* Too many DP --> Rounded */
785 ret = GetCurrencyFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
786 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
787 EXPECT_LENA; EXPECT_EQA;
788
789 format.NumDigits = 0; /* No decimal separator */
790 format.LeadingZero = 0;
791 format.Grouping = 0; /* No grouping char */
792 format.NegativeOrder = 0;
793 format.PositiveOrder = CY_POS_LEFT;
794 format.lpDecimalSep = szDot;
795 format.lpThousandSep = szComma;
796 format.lpCurrencySymbol = szDollar;
797
798 STRINGSA("2353","$2353"); /* No decimal or grouping chars expected */
799 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
800 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
801 EXPECT_LENA; EXPECT_EQA;
802
803 format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
804 STRINGSA("2353","$2353.0");
805 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
806 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
807 EXPECT_LENA; EXPECT_EQA;
808
809 format.Grouping = 2; /* Group by 100's */
810 STRINGSA("2353","$23,53.0");
811 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
812 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
813 EXPECT_LENA; EXPECT_EQA;
814
815 STRINGSA("235","$235.0"); /* Grouping of a positive number */
816 format.Grouping = 3;
817 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
818 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
819 EXPECT_LENA; EXPECT_EQA;
820
821 STRINGSA("-235","$-235.0"); /* Grouping of a negative number */
822 format.NegativeOrder = 2;
823 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
824 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
825 EXPECT_LENA; EXPECT_EQA;
826
827 format.LeadingZero = 1; /* Always provide leading zero */
828 STRINGSA(".5","$0.5");
829 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
830 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
831 EXPECT_LENA; EXPECT_EQA;
832
833 format.PositiveOrder = CY_POS_RIGHT;
834 STRINGSA("1","1.0$");
835 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
836 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
837 EXPECT_LENA; EXPECT_EQA;
838
839 format.PositiveOrder = CY_POS_LEFT_SPACE;
840 STRINGSA("1","$ 1.0");
841 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
842 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
843 EXPECT_LENA; EXPECT_EQA;
844
845 format.PositiveOrder = CY_POS_RIGHT_SPACE;
846 STRINGSA("1","1.0 $");
847 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
848 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
849 EXPECT_LENA; EXPECT_EQA;
850
851 format.NegativeOrder = 0;
852 STRINGSA("-1","($1.0)");
853 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
854 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
855 EXPECT_LENA; EXPECT_EQA;
856
857 format.NegativeOrder = 1;
858 STRINGSA("-1","-$1.0");
859 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
860 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
861 EXPECT_LENA; EXPECT_EQA;
862
863 format.NegativeOrder = 2;
864 STRINGSA("-1","$-1.0");
865 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
866 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
867 EXPECT_LENA; EXPECT_EQA;
868
869 format.NegativeOrder = 3;
870 STRINGSA("-1","$1.0-");
871 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
872 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
873 EXPECT_LENA; EXPECT_EQA;
874
875 format.NegativeOrder = 4;
876 STRINGSA("-1","(1.0$)");
877 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
878 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
879 EXPECT_LENA; EXPECT_EQA;
880
881 format.NegativeOrder = 5;
882 STRINGSA("-1","-1.0$");
883 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
884 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
885 EXPECT_LENA; EXPECT_EQA;
886
887 format.NegativeOrder = 6;
888 STRINGSA("-1","1.0-$");
889 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
890 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
891 EXPECT_LENA; EXPECT_EQA;
892
893 format.NegativeOrder = 7;
894 STRINGSA("-1","1.0$-");
895 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
896 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
897 EXPECT_LENA; EXPECT_EQA;
898
899 format.NegativeOrder = 8;
900 STRINGSA("-1","-1.0 $");
901 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
902 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
903 EXPECT_LENA; EXPECT_EQA;
904
905 format.NegativeOrder = 9;
906 STRINGSA("-1","-$ 1.0");
907 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
908 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
909 EXPECT_LENA; EXPECT_EQA;
910
911 format.NegativeOrder = 10;
912 STRINGSA("-1","1.0 $-");
913 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
914 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
915 EXPECT_LENA; EXPECT_EQA;
916
917 format.NegativeOrder = 11;
918 STRINGSA("-1","$ 1.0-");
919 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
920 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
921 EXPECT_LENA; EXPECT_EQA;
922
923 format.NegativeOrder = 12;
924 STRINGSA("-1","$ -1.0");
925 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
926 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
927 EXPECT_LENA; EXPECT_EQA;
928
929 format.NegativeOrder = 13;
930 STRINGSA("-1","1.0- $");
931 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
932 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
933 EXPECT_LENA; EXPECT_EQA;
934
935 format.NegativeOrder = 14;
936 STRINGSA("-1","($ 1.0)");
937 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
938 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
939 EXPECT_LENA; EXPECT_EQA;
940
941 format.NegativeOrder = 15;
942 STRINGSA("-1","(1.0 $)");
943 ret = GetCurrencyFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
944 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
945 EXPECT_LENA; EXPECT_EQA;
946 }
947
948 #define NEG_PARENS 0 /* "(1.1)" */
949 #define NEG_LEFT 1 /* "-1.1" */
950 #define NEG_LEFT_SPACE 2 /* "- 1.1" */
951 #define NEG_RIGHT 3 /* "1.1-" */
952 #define NEG_RIGHT_SPACE 4 /* "1.1 -" */
953
954 static void test_GetNumberFormatA(void)
955 {
956 static char szDot[] = { '.', '\0' };
957 static char szComma[] = { ',', '\0' };
958 int ret;
959 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
960 char buffer[BUFFER_SIZE], Expected[BUFFER_SIZE], input[BUFFER_SIZE];
961 NUMBERFMTA format;
962
963 memset(&format, 0, sizeof(format));
964
965 STRINGSA("23",""); /* NULL output, length > 0 --> Error */
966 SetLastError(0xdeadbeef);
967 ret = GetNumberFormatA(lcid, 0, input, NULL, NULL, COUNTOF(buffer));
968 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
969 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
970
971 STRINGSA("23,53",""); /* Invalid character --> Error */
972 SetLastError(0xdeadbeef);
973 ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
974 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
975 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
976
977 STRINGSA("--",""); /* Double '-' --> Error */
978 SetLastError(0xdeadbeef);
979 ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
980 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
981 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
982
983 STRINGSA("0-",""); /* Trailing '-' --> Error */
984 SetLastError(0xdeadbeef);
985 ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
986 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
987 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
988
989 STRINGSA("0..",""); /* Double '.' --> Error */
990 SetLastError(0xdeadbeef);
991 ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
992 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
993 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
994
995 STRINGSA(" 0.1",""); /* Leading space --> Error */
996 SetLastError(0xdeadbeef);
997 ret = GetNumberFormatA(lcid, 0, input, NULL, buffer, COUNTOF(buffer));
998 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
999 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1000
1001 STRINGSA("1234","1"); /* Length too small --> Write up to length chars */
1002 SetLastError(0xdeadbeef);
1003 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, 2);
1004 ok( !ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1005 "Expected ERROR_INSUFFICIENT_BUFFER, got %d\n", GetLastError());
1006
1007 STRINGSA("2353",""); /* Format and flags given --> Error */
1008 SetLastError(0xdeadbeef);
1009 ret = GetNumberFormatA(lcid, NUO, input, &format, buffer, COUNTOF(buffer));
1010 ok( !ret, "Expected ret == 0, got %d\n", ret);
1011 ok( GetLastError() == ERROR_INVALID_FLAGS || GetLastError() == ERROR_INVALID_PARAMETER,
1012 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1013
1014 STRINGSA("2353",""); /* Invalid format --> Error */
1015 SetLastError(0xdeadbeef);
1016 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1017 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
1018 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
1019
1020 STRINGSA("2353","2,353.00"); /* Valid number */
1021 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1022 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1023 EXPECT_LENA; EXPECT_EQA;
1024
1025 STRINGSA("-2353","-2,353.00"); /* Valid negative number */
1026 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1027 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1028 EXPECT_LENA; EXPECT_EQA;
1029
1030 STRINGSA("-353","-353.00"); /* test for off by one error in grouping */
1031 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1032 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1033 EXPECT_LENA; EXPECT_EQA;
1034
1035 STRINGSA("2353.1","2,353.10"); /* Valid real number */
1036 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1037 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1038 EXPECT_LENA; EXPECT_EQA;
1039
1040 STRINGSA("2353.111","2,353.11"); /* Too many DP --> Truncated */
1041 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1042 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1043 EXPECT_LENA; EXPECT_EQA;
1044
1045 STRINGSA("2353.119","2,353.12"); /* Too many DP --> Rounded */
1046 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1047 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1048 EXPECT_LENA; EXPECT_EQA;
1049
1050 format.NumDigits = 0; /* No decimal separator */
1051 format.LeadingZero = 0;
1052 format.Grouping = 0; /* No grouping char */
1053 format.NegativeOrder = 0;
1054 format.lpDecimalSep = szDot;
1055 format.lpThousandSep = szComma;
1056
1057 STRINGSA("2353","2353"); /* No decimal or grouping chars expected */
1058 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1059 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1060 EXPECT_LENA; EXPECT_EQA;
1061
1062 format.NumDigits = 1; /* 1 DP --> Expect decimal separator */
1063 STRINGSA("2353","2353.0");
1064 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1065 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1066 EXPECT_LENA; EXPECT_EQA;
1067
1068 format.Grouping = 2; /* Group by 100's */
1069 STRINGSA("2353","23,53.0");
1070 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1071 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1072 EXPECT_LENA; EXPECT_EQA;
1073
1074 STRINGSA("235","235.0"); /* Grouping of a positive number */
1075 format.Grouping = 3;
1076 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1077 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1078 EXPECT_LENA; EXPECT_EQA;
1079
1080 STRINGSA("-235","-235.0"); /* Grouping of a negative number */
1081 format.NegativeOrder = NEG_LEFT;
1082 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1083 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1084 EXPECT_LENA; EXPECT_EQA;
1085
1086 format.LeadingZero = 1; /* Always provide leading zero */
1087 STRINGSA(".5","0.5");
1088 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1089 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1090 EXPECT_LENA; EXPECT_EQA;
1091
1092 format.NegativeOrder = NEG_PARENS;
1093 STRINGSA("-1","(1.0)");
1094 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1095 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1096 EXPECT_LENA; EXPECT_EQA;
1097
1098 format.NegativeOrder = NEG_LEFT;
1099 STRINGSA("-1","-1.0");
1100 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1101 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1102 EXPECT_LENA; EXPECT_EQA;
1103
1104 format.NegativeOrder = NEG_LEFT_SPACE;
1105 STRINGSA("-1","- 1.0");
1106 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1107 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1108 EXPECT_LENA; EXPECT_EQA;
1109
1110 format.NegativeOrder = NEG_RIGHT;
1111 STRINGSA("-1","1.0-");
1112 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1113 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1114 EXPECT_LENA; EXPECT_EQA;
1115
1116 format.NegativeOrder = NEG_RIGHT_SPACE;
1117 STRINGSA("-1","1.0 -");
1118 ret = GetNumberFormatA(lcid, 0, input, &format, buffer, COUNTOF(buffer));
1119 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1120 EXPECT_LENA; EXPECT_EQA;
1121
1122 lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
1123
1124 if (IsValidLocale(lcid, 0))
1125 {
1126 STRINGSA("-12345","-12 345,00"); /* Try French formatting */
1127 Expected[3] = 160; /* Non breaking space */
1128 ret = GetNumberFormatA(lcid, NUO, input, NULL, buffer, COUNTOF(buffer));
1129 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1130 EXPECT_LENA; EXPECT_EQA;
1131 }
1132 }
1133
1134
1135 static void test_CompareStringA(void)
1136 {
1137 int ret;
1138 LCID lcid = MAKELCID(MAKELANGID(LANG_FRENCH, SUBLANG_DEFAULT), SORT_DEFAULT);
1139
1140 ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "Salute", -1);
1141 ok (ret== 1, "(Salut/Salute) Expected 1, got %d\n", ret);
1142
1143 ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "SaLuT", -1);
1144 ok (ret== 2, "(Salut/SaLuT) Expected 2, got %d\n", ret);
1145
1146 ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", -1, "hola", -1);
1147 ok (ret== 3, "(Salut/hola) Expected 3, got %d\n", ret);
1148
1149 ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
1150 ok (ret== 1, "(haha/hoho) Expected 1, got %d\n", ret);
1151
1152 lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
1153
1154 ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", -1);
1155 ok (ret== 1, "(haha/hoho) Expected 1, got %d\n", ret);
1156
1157 ret = CompareStringA(lcid, NORM_IGNORECASE, "haha", -1, "hoho", 0);
1158 ok (ret== 3, "(haha/hoho) Expected 3, got %d\n", ret);
1159
1160 ret = CompareStringA(lcid, NORM_IGNORECASE, "Salut", 5, "saLuT", -1);
1161 ok (ret == 2, "(Salut/saLuT) Expected 2, got %d\n", ret);
1162
1163 /* test for CompareStringA flags */
1164 SetLastError(0xdeadbeef);
1165 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0x8, "NULL", -1, "NULL", -1);
1166 ok(GetLastError() == ERROR_INVALID_FLAGS,
1167 "unexpected error code %d\n", GetLastError());
1168 ok(!ret, "CompareStringA must fail with invalid flag\n");
1169
1170 SetLastError(0xdeadbeef);
1171 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, LOCALE_USE_CP_ACP, "NULL", -1, "NULL", -1);
1172 ok(GetLastError() == 0xdeadbeef, "unexpected error code %d\n", GetLastError());
1173 ok(ret == CSTR_EQUAL, "CompareStringA error: %d != CSTR_EQUAL\n", ret);
1174 /* end of test for CompareStringA flags */
1175
1176 ret = lstrcmpA("", "");
1177 ok (ret == 0, "lstrcmpA(\"\", \"\") should return 0, got %d\n", ret);
1178
1179 ret = lstrcmpA(NULL, NULL);
1180 ok (ret == 0 || broken(ret == -2) /* win9x */, "lstrcmpA(NULL, NULL) should return 0, got %d\n", ret);
1181
1182 ret = lstrcmpA("", NULL);
1183 ok (ret == 1 || broken(ret == -2) /* win9x */, "lstrcmpA(\"\", NULL) should return 1, got %d\n", ret);
1184
1185 ret = lstrcmpA(NULL, "");
1186 ok (ret == -1 || broken(ret == -2) /* win9x */, "lstrcmpA(NULL, \"\") should return -1, got %d\n", ret);
1187
1188 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"EndDialog",-1,"_Property",-1);
1189 ok( ret == 3, "EndDialog vs _Property ... expected 3, got %d\n", ret);
1190
1191 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"osp_vba.sreg0070",-1,"_IEWWBrowserComp",-1);
1192 ok( ret == 3, "osp_vba.sreg0070 vs _IEWWBrowserComp ... expected 3, got %d\n", ret);
1193
1194 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"r",-1,"\\",-1);
1195 ok( ret == 3, "r vs \\ ... expected 3, got %d\n", ret);
1196
1197 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT,0,"osp_vba.sreg0031", -1, "OriginalDatabase", -1 );
1198 ok( ret == 3, "osp_vba.sreg0031 vs OriginalDatabase ... expected 3, got %d\n", ret);
1199
1200 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aaa", -1 );
1201 ok( ret == 3, "AAA vs aaa expected 3, got %d\n", ret);
1202
1203 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "aab", -1 );
1204 ok( ret == 1, "AAA vs aab expected 1, got %d\n", ret);
1205
1206 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "AAA", -1, "Aab", -1 );
1207 ok( ret == 1, "AAA vs Aab expected 1, got %d\n", ret);
1208
1209 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "Aab", -1 );
1210 ok( ret == 1, ".AAA vs Aab expected 1, got %d\n", ret);
1211
1212 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, ".AAA", -1, "A.ab", -1 );
1213 ok( ret == 1, ".AAA vs A.ab expected 1, got %d\n", ret);
1214
1215 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "AB", -1 );
1216 ok( ret == 1, "aa vs AB expected 1, got %d\n", ret);
1217
1218 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "aa", -1, "Aab", -1 );
1219 ok( ret == 1, "aa vs Aab expected 1, got %d\n", ret);
1220
1221 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "aB", -1, "Aab", -1 );
1222 ok( ret == 3, "aB vs Aab expected 3, got %d\n", ret);
1223
1224 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "Ba", -1, "bab", -1 );
1225 ok( ret == 1, "Ba vs bab expected 1, got %d\n", ret);
1226
1227 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "{100}{83}{71}{71}{71}", -1, "Global_DataAccess_JRO", -1 );
1228 ok( ret == 1, "{100}{83}{71}{71}{71} vs Global_DataAccess_JRO expected 1, got %d\n", ret);
1229
1230 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "a", -1, "{", -1 );
1231 ok( ret == 3, "a vs { expected 3, got %d\n", ret);
1232
1233 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "A", -1, "{", -1 );
1234 ok( ret == 3, "A vs { expected 3, got %d\n", ret);
1235
1236 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "3.5", 0, "4.0", -1 );
1237 ok(ret == 1, "3.5/0 vs 4.0/-1 expected 1, got %d\n", ret);
1238
1239 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "3.5", -1, "4.0", -1 );
1240 ok(ret == 1, "3.5 vs 4.0 expected 1, got %d\n", ret);
1241
1242 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "3.520.4403.2", -1, "4.0.2927.10", -1 );
1243 ok(ret == 1, "3.520.4403.2 vs 4.0.2927.10 expected 1, got %d\n", ret);
1244
1245 /* hyphen and apostrophe are treated differently depending on
1246 * whether SORT_STRINGSORT specified or not
1247 */
1248 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "-o", -1, "/m", -1 );
1249 ok(ret == 3, "-o vs /m expected 3, got %d\n", ret);
1250
1251 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "-o", -1 );
1252 ok(ret == 1, "/m vs -o expected 1, got %d\n", ret);
1253
1254 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-o", -1, "/m", -1 );
1255 ok(ret == 1, "-o vs /m expected 1, got %d\n", ret);
1256
1257 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "-o", -1 );
1258 ok(ret == 3, "/m vs -o expected 3, got %d\n", ret);
1259
1260 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "/m", -1 );
1261 ok(ret == 3, "'o vs /m expected 3, got %d\n", ret);
1262
1263 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "'o", -1 );
1264 ok(ret == 1, "/m vs 'o expected 1, got %d\n", ret);
1265
1266 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "/m", -1 );
1267 ok(ret == 1, "'o vs /m expected 1, got %d\n", ret);
1268
1269 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "'o", -1 );
1270 ok(ret == 3, "/m vs 'o expected 3, got %d\n", ret);
1271
1272 if (0) { /* this requires collation table patch to make it MS compatible */
1273 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'o", -1, "-o", -1 );
1274 ok(ret == 1, "'o vs -o expected 1, got %d\n", ret);
1275
1276 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'o", -1, "-o", -1 );
1277 ok(ret == 1, "'o vs -o expected 1, got %d\n", ret);
1278
1279 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "'", -1, "-", -1 );
1280 ok(ret == 1, "' vs - expected 1, got %d\n", ret);
1281
1282 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "'", -1, "-", -1 );
1283 ok(ret == 1, "' vs - expected 1, got %d\n", ret);
1284
1285 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "/m", -1 );
1286 ok(ret == 3, "`o vs /m expected 3, got %d\n", ret);
1287
1288 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "/m", -1, "`o", -1 );
1289 ok(ret == 1, "/m vs `o expected 1, got %d\n", ret);
1290
1291 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "/m", -1 );
1292 ok(ret == 3, "`o vs /m expected 3, got %d\n", ret);
1293
1294 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "/m", -1, "`o", -1 );
1295 ok(ret == 1, "/m vs `o expected 1, got %d\n", ret);
1296
1297 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "`o", -1, "-m", -1 );
1298 ok(ret == 1, "`o vs -m expected 1, got %d\n", ret);
1299
1300 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, 0, "-m", -1, "`o", -1 );
1301 ok(ret == 3, "-m vs `o expected 3, got %d\n", ret);
1302
1303 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "`o", -1, "-m", -1 );
1304 ok(ret == 3, "`o vs -m expected 3, got %d\n", ret);
1305
1306 ret = CompareStringA(LOCALE_SYSTEM_DEFAULT, SORT_STRINGSORT, "-m", -1, "`o", -1 );
1307 ok(ret == 1, "-m vs `o expected 1, got %d\n", ret);
1308 }
1309
1310 ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ", 9);
1311 ok(ret == 2, "aLuZkUtZ vs aLuZkUtZ\\0 expected 2, got %d\n", ret);
1312
1313 ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 7, "aLuZkUtZ\0A", 10);
1314 ok(ret == 1, "aLuZkUtZ vs aLuZkUtZ\\0A expected 1, got %d\n", ret);
1315
1316 /* WinXP handles embedded NULLs differently than earlier versions */
1317 ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLuZkUtZ", 8, "aLuZkUtZ\0A", 10);
1318 ok(ret == 1 || ret == 2, "aLuZkUtZ vs aLuZkUtZ\\0A expected 1 or 2, got %d\n", ret);
1319
1320 ret = CompareStringA(LOCALE_USER_DEFAULT, 0, "aLu\0ZkUtZ", 8, "aLu\0ZkUtZ\0A", 10);
1321 ok(ret == 1 || ret == 2, "aLu\\0ZkUtZ vs aLu\\0ZkUtZ\\0A expected 1 or 2, got %d\n", ret);
1322
1323 ret = CompareStringA(lcid, 0, "a\0b", -1, "a", -1);
1324 ok(ret == 2, "a vs a expected 2, got %d\n", ret);
1325
1326 ret = CompareStringA(lcid, 0, "a\0b", 4, "a", 2);
1327 ok(ret == CSTR_EQUAL || /* win2k */
1328 ret == CSTR_GREATER_THAN,
1329 "a\\0b vs a expected CSTR_EQUAL or CSTR_GREATER_THAN, got %d\n", ret);
1330
1331 ret = CompareStringA(lcid, 0, "\2", 2, "\1", 2);
1332 todo_wine ok(ret != 2, "\\2 vs \\1 expected unequal\n");
1333
1334 ret = CompareStringA(lcid, NORM_IGNORECASE | LOCALE_USE_CP_ACP, "#", -1, ".", -1);
1335 todo_wine ok(ret == CSTR_LESS_THAN, "\"#\" vs \".\" expected CSTR_LESS_THAN, got %d\n", ret);
1336
1337 ret = lstrcmpi("#", ".");
1338 todo_wine ok(ret == -1, "\"#\" vs \".\" expected -1, got %d\n", ret);
1339 }
1340
1341 static void test_LCMapStringA(void)
1342 {
1343 int ret, ret2;
1344 char buf[256], buf2[256];
1345 static const char upper_case[] = "\tJUST! A, TEST; STRING 1/*+-.\r\n";
1346 static const char lower_case[] = "\tjust! a, test; string 1/*+-.\r\n";
1347 static const char symbols_stripped[] = "justateststring1";
1348
1349 SetLastError(0xdeadbeef);
1350 ret = LCMapStringA(LOCALE_USER_DEFAULT, LOCALE_USE_CP_ACP | LCMAP_LOWERCASE,
1351 lower_case, -1, buf, sizeof(buf));
1352 ok(ret == lstrlenA(lower_case) + 1,
1353 "ret %d, error %d, expected value %d\n",
1354 ret, GetLastError(), lstrlenA(lower_case) + 1);
1355 ok(!memcmp(buf, lower_case, ret), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1356
1357 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | LCMAP_UPPERCASE,
1358 upper_case, -1, buf, sizeof(buf));
1359 ok(!ret, "LCMAP_LOWERCASE and LCMAP_UPPERCASE are mutually exclusive\n");
1360 ok(GetLastError() == ERROR_INVALID_FLAGS,
1361 "unexpected error code %d\n", GetLastError());
1362
1363 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_HIRAGANA | LCMAP_KATAKANA,
1364 upper_case, -1, buf, sizeof(buf));
1365 ok(!ret, "LCMAP_HIRAGANA and LCMAP_KATAKANA are mutually exclusive\n");
1366 ok(GetLastError() == ERROR_INVALID_FLAGS,
1367 "unexpected error code %d\n", GetLastError());
1368
1369 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_HALFWIDTH | LCMAP_FULLWIDTH,
1370 upper_case, -1, buf, sizeof(buf));
1371 ok(!ret, "LCMAP_HALFWIDTH | LCMAP_FULLWIDTH are mutually exclusive\n");
1372 ok(GetLastError() == ERROR_INVALID_FLAGS,
1373 "unexpected error code %d\n", GetLastError());
1374
1375 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE,
1376 upper_case, -1, buf, sizeof(buf));
1377 ok(!ret, "LCMAP_TRADITIONAL_CHINESE and LCMAP_SIMPLIFIED_CHINESE are mutually exclusive\n");
1378 ok(GetLastError() == ERROR_INVALID_FLAGS,
1379 "unexpected error code %d\n", GetLastError());
1380
1381 /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
1382 SetLastError(0xdeadbeef);
1383 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | SORT_STRINGSORT,
1384 upper_case, -1, buf, sizeof(buf));
1385 ok(GetLastError() == ERROR_INVALID_FLAGS, "expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1386 ok(!ret, "SORT_STRINGSORT without LCMAP_SORTKEY must fail\n");
1387
1388 /* test LCMAP_LOWERCASE */
1389 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1390 upper_case, -1, buf, sizeof(buf));
1391 ok(ret == lstrlenA(upper_case) + 1,
1392 "ret %d, error %d, expected value %d\n",
1393 ret, GetLastError(), lstrlenA(upper_case) + 1);
1394 ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1395
1396 /* test LCMAP_UPPERCASE */
1397 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1398 lower_case, -1, buf, sizeof(buf));
1399 ok(ret == lstrlenA(lower_case) + 1,
1400 "ret %d, error %d, expected value %d\n",
1401 ret, GetLastError(), lstrlenA(lower_case) + 1);
1402 ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
1403
1404 /* test buffer overflow */
1405 SetLastError(0xdeadbeef);
1406 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1407 lower_case, -1, buf, 4);
1408 ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1409 "should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", ret);
1410
1411 /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
1412 lstrcpyA(buf, lower_case);
1413 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1414 buf, -1, buf, sizeof(buf));
1415 if (!ret) /* Win9x */
1416 trace("Ignoring LCMapStringA(LCMAP_UPPERCASE, buf, buf) error on Win9x\n");
1417 else
1418 {
1419 ok(ret == lstrlenA(lower_case) + 1,
1420 "ret %d, error %d, expected value %d\n",
1421 ret, GetLastError(), lstrlenA(lower_case) + 1);
1422 ok(!lstrcmpA(buf, upper_case), "LCMapStringA should return %s, but not %s\n", upper_case, buf);
1423 }
1424 lstrcpyA(buf, upper_case);
1425 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1426 buf, -1, buf, sizeof(buf));
1427 if (!ret) /* Win9x */
1428 trace("Ignoring LCMapStringA(LCMAP_LOWERCASE, buf, buf) error on Win9x\n");
1429 else
1430 {
1431 ok(ret == lstrlenA(upper_case) + 1,
1432 "ret %d, error %d, expected value %d\n",
1433 ret, GetLastError(), lstrlenA(lower_case) + 1);
1434 ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1435 }
1436
1437 /* otherwise src == dst should fail */
1438 SetLastError(0xdeadbeef);
1439 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | LCMAP_UPPERCASE,
1440 buf, 10, buf, sizeof(buf));
1441 ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
1442 GetLastError() == ERROR_INVALID_PARAMETER /* Win9x */,
1443 "unexpected error code %d\n", GetLastError());
1444 ok(!ret, "src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n");
1445
1446 /* test whether '\0' is always appended */
1447 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1448 upper_case, -1, buf, sizeof(buf));
1449 ok(ret, "LCMapStringA must succeed\n");
1450 ok(buf[ret-1] == 0, "LCMapStringA not null-terminated\n");
1451 ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1452 upper_case, lstrlenA(upper_case), buf2, sizeof(buf2));
1453 ok(ret2, "LCMapStringA must succeed\n");
1454 ok(buf2[ret2-1] == 0, "LCMapStringA not null-terminated\n" );
1455 ok(ret == ret2, "lengths of sort keys must be equal\n");
1456 ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1457
1458 /* test LCMAP_SORTKEY | NORM_IGNORECASE */
1459 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORECASE,
1460 upper_case, -1, buf, sizeof(buf));
1461 ok(ret, "LCMapStringA must succeed\n");
1462 ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1463 lower_case, -1, buf2, sizeof(buf2));
1464 ok(ret2, "LCMapStringA must succeed\n");
1465 ok(ret == ret2, "lengths of sort keys must be equal\n");
1466 ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1467
1468 /* Don't test LCMAP_SORTKEY | NORM_IGNORENONSPACE, produces different
1469 results from plain LCMAP_SORTKEY on Vista */
1470
1471 /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
1472 ret = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
1473 lower_case, -1, buf, sizeof(buf));
1474 ok(ret, "LCMapStringA must succeed\n");
1475 ret2 = LCMapStringA(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1476 symbols_stripped, -1, buf2, sizeof(buf2));
1477 ok(ret2, "LCMapStringA must succeed\n");
1478 ok(ret == ret2, "lengths of sort keys must be equal\n");
1479 ok(!lstrcmpA(buf, buf2), "sort keys must be equal\n");
1480
1481 /* test NORM_IGNORENONSPACE */
1482 lstrcpyA(buf, "foo");
1483 ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORENONSPACE,
1484 lower_case, -1, buf, sizeof(buf));
1485 ok(ret == lstrlenA(lower_case) + 1, "LCMapStringA should return %d, ret = %d\n",
1486 lstrlenA(lower_case) + 1, ret);
1487 ok(!lstrcmpA(buf, lower_case), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1488
1489 /* test NORM_IGNORESYMBOLS */
1490 lstrcpyA(buf, "foo");
1491 ret = LCMapStringA(LOCALE_USER_DEFAULT, NORM_IGNORESYMBOLS,
1492 lower_case, -1, buf, sizeof(buf));
1493 ok(ret == lstrlenA(symbols_stripped) + 1, "LCMapStringA should return %d, ret = %d\n",
1494 lstrlenA(symbols_stripped) + 1, ret);
1495 ok(!lstrcmpA(buf, symbols_stripped), "LCMapStringA should return %s, but not %s\n", lower_case, buf);
1496
1497 /* test srclen = 0 */
1498 SetLastError(0xdeadbeef);
1499 ret = LCMapStringA(LOCALE_USER_DEFAULT, 0, upper_case, 0, buf, sizeof(buf));
1500 ok(!ret, "LCMapStringA should fail with srclen = 0\n");
1501 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1502 "unexpected error code %d\n", GetLastError());
1503 }
1504
1505 static void test_LCMapStringW(void)
1506 {
1507 int ret, ret2;
1508 WCHAR buf[256], buf2[256];
1509 char *p_buf = (char *)buf, *p_buf2 = (char *)buf2;
1510 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};
1511 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};
1512 static const WCHAR symbols_stripped[] = {'j','u','s','t','a','t','e','s','t','s','t','r','i','n','g','1',0};
1513 static const WCHAR fooW[] = {'f','o','o',0};
1514
1515 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | LCMAP_UPPERCASE,
1516 upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1517 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1518 {
1519 win_skip("LCMapStringW is not implemented\n");
1520 return;
1521 }
1522 if (broken(ret))
1523 ok(lstrcmpW(buf, upper_case) == 0, "Expected upper case string\n");
1524 else
1525 {
1526 ok(!ret, "LCMAP_LOWERCASE and LCMAP_UPPERCASE are mutually exclusive\n");
1527 ok(GetLastError() == ERROR_INVALID_FLAGS,
1528 "unexpected error code %d\n", GetLastError());
1529 }
1530
1531 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_HIRAGANA | LCMAP_KATAKANA,
1532 upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1533 ok(!ret, "LCMAP_HIRAGANA and LCMAP_KATAKANA are mutually exclusive\n");
1534 ok(GetLastError() == ERROR_INVALID_FLAGS,
1535 "unexpected error code %d\n", GetLastError());
1536
1537 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_HALFWIDTH | LCMAP_FULLWIDTH,
1538 upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1539 ok(!ret, "LCMAP_HALFWIDTH | LCMAP_FULLWIDTH are mutually exclusive\n");
1540 ok(GetLastError() == ERROR_INVALID_FLAGS,
1541 "unexpected error code %d\n", GetLastError());
1542
1543 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_TRADITIONAL_CHINESE | LCMAP_SIMPLIFIED_CHINESE,
1544 upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1545 ok(!ret, "LCMAP_TRADITIONAL_CHINESE and LCMAP_SIMPLIFIED_CHINESE are mutually exclusive\n");
1546 ok(GetLastError() == ERROR_INVALID_FLAGS,
1547 "unexpected error code %d\n", GetLastError());
1548
1549 /* SORT_STRINGSORT must be used exclusively with LCMAP_SORTKEY */
1550 SetLastError(0xdeadbeef);
1551 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE | SORT_STRINGSORT,
1552 upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1553 ok(GetLastError() == ERROR_INVALID_FLAGS, "expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
1554 ok(!ret, "SORT_STRINGSORT without LCMAP_SORTKEY must fail\n");
1555
1556 /* test LCMAP_LOWERCASE */
1557 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1558 upper_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1559 ok(ret == lstrlenW(upper_case) + 1,
1560 "ret %d, error %d, expected value %d\n",
1561 ret, GetLastError(), lstrlenW(upper_case) + 1);
1562 ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
1563
1564 /* test LCMAP_UPPERCASE */
1565 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1566 lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1567 ok(ret == lstrlenW(lower_case) + 1,
1568 "ret %d, error %d, expected value %d\n",
1569 ret, GetLastError(), lstrlenW(lower_case) + 1);
1570 ok(!lstrcmpW(buf, upper_case), "string compare mismatch\n");
1571
1572 /* test buffer overflow */
1573 SetLastError(0xdeadbeef);
1574 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1575 lower_case, -1, buf, 4);
1576 ok(!ret && GetLastError() == ERROR_INSUFFICIENT_BUFFER,
1577 "should return 0 and ERROR_INSUFFICIENT_BUFFER, got %d\n", ret);
1578
1579 /* LCMAP_UPPERCASE or LCMAP_LOWERCASE should accept src == dst */
1580 lstrcpyW(buf, lower_case);
1581 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_UPPERCASE,
1582 buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
1583 ok(ret == lstrlenW(lower_case) + 1,
1584 "ret %d, error %d, expected value %d\n",
1585 ret, GetLastError(), lstrlenW(lower_case) + 1);
1586 ok(!lstrcmpW(buf, upper_case), "string compare mismatch\n");
1587
1588 lstrcpyW(buf, upper_case);
1589 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_LOWERCASE,
1590 buf, -1, buf, sizeof(buf)/sizeof(WCHAR));
1591 ok(ret == lstrlenW(upper_case) + 1,
1592 "ret %d, error %d, expected value %d\n",
1593 ret, GetLastError(), lstrlenW(lower_case) + 1);
1594 ok(!lstrcmpW(buf, lower_case), "string compare mismatch\n");
1595
1596 /* otherwise src == dst should fail */
1597 SetLastError(0xdeadbeef);
1598 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | LCMAP_UPPERCASE,
1599 buf, 10, buf, sizeof(buf));
1600 ok(GetLastError() == ERROR_INVALID_FLAGS /* NT */ ||
1601 GetLastError() == ERROR_INVALID_PARAMETER /* Win9x */,
1602 "unexpected error code %d\n", GetLastError());
1603 ok(!ret, "src == dst without LCMAP_UPPERCASE or LCMAP_LOWERCASE must fail\n");
1604
1605 /* test whether '\0' is always appended */
1606 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1607 upper_case, -1, buf, sizeof(buf));
1608 ok(ret, "LCMapStringW must succeed\n");
1609 ret2 = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1610 upper_case, lstrlenW(upper_case), buf2, sizeof(buf2));
1611 ok(ret, "LCMapStringW must succeed\n");
1612 ok(ret == ret2, "lengths of sort keys must be equal\n");
1613 ok(!lstrcmpA(p_buf, p_buf2), "sort keys must be equal\n");
1614
1615 /* test LCMAP_SORTKEY | NORM_IGNORECASE */
1616 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORECASE,
1617 upper_case, -1, buf, sizeof(buf));
1618 ok(ret, "LCMapStringW must succeed\n");
1619 ret2 = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1620 lower_case, -1, buf2, sizeof(buf2));
1621 ok(ret2, "LCMapStringW must succeed\n");
1622 ok(ret == ret2, "lengths of sort keys must be equal\n");
1623 ok(!lstrcmpA(p_buf, p_buf2), "sort keys must be equal\n");
1624
1625 /* Don't test LCMAP_SORTKEY | NORM_IGNORENONSPACE, produces different
1626 results from plain LCMAP_SORTKEY on Vista */
1627
1628 /* test LCMAP_SORTKEY | NORM_IGNORESYMBOLS */
1629 ret = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY | NORM_IGNORESYMBOLS,
1630 lower_case, -1, buf, sizeof(buf));
1631 ok(ret, "LCMapStringW must succeed\n");
1632 ret2 = LCMapStringW(LOCALE_USER_DEFAULT, LCMAP_SORTKEY,
1633 symbols_stripped, -1, buf2, sizeof(buf2));
1634 ok(ret2, "LCMapStringW must succeed\n");
1635 ok(ret == ret2, "lengths of sort keys must be equal\n");
1636 ok(!lstrcmpA(p_buf, p_buf2), "sort keys must be equal\n");
1637
1638 /* test NORM_IGNORENONSPACE */
1639 lstrcpyW(buf, fooW);
1640 ret = LCMapStringW(LOCALE_USER_DEFAULT, NORM_IGNORENONSPACE,
1641 lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1642 ok(ret == lstrlenW(lower_case) + 1, "LCMapStringW should return %d, ret = %d\n",
1643 lstrlenW(lower_case) + 1, ret);
1644 ok(!lstrcmpW(buf, lower_case), "string comparison mismatch\n");
1645
1646 /* test NORM_IGNORESYMBOLS */
1647 lstrcpyW(buf, fooW);
1648 ret = LCMapStringW(LOCALE_USER_DEFAULT, NORM_IGNORESYMBOLS,
1649 lower_case, -1, buf, sizeof(buf)/sizeof(WCHAR));
1650 ok(ret == lstrlenW(symbols_stripped) + 1, "LCMapStringW should return %d, ret = %d\n",
1651 lstrlenW(symbols_stripped) + 1, ret);
1652 ok(!lstrcmpW(buf, symbols_stripped), "string comparison mismatch\n");
1653
1654 /* test srclen = 0 */
1655 SetLastError(0xdeadbeef);
1656 ret = LCMapStringW(LOCALE_USER_DEFAULT, 0, upper_case, 0, buf, sizeof(buf)/sizeof(WCHAR));
1657 ok(!ret, "LCMapStringW should fail with srclen = 0\n");
1658 ok(GetLastError() == ERROR_INVALID_PARAMETER,
1659 "unexpected error code %d\n", GetLastError());
1660 }
1661
1662 /* this requires collation table patch to make it MS compatible */
1663 static const char * const strings_sorted[] =
1664 {
1665 "'",
1666 "-",
1667 "!",
1668 "\"",
1669 ".",
1670 ":",
1671 "\\",
1672 "_",
1673 "`",
1674 "{",
1675 "}",
1676 "+",
1677 "0",
1678 "1",
1679 "2",
1680 "3",
1681 "4",
1682 "5",
1683 "6",
1684 "7",
1685 "8",
1686 "9",
1687 "a",
1688 "A",
1689 "b",
1690 "B",
1691 "c",
1692 "C"
1693 };
1694
1695 static const char * const strings[] =
1696 {
1697 "C",
1698 "\"",
1699 "9",
1700 "'",
1701 "}",
1702 "-",
1703 "7",
1704 "+",
1705 "`",
1706 "1",
1707 "a",
1708 "5",
1709 "\\",
1710 "8",
1711 "B",
1712 "3",
1713 "_",
1714 "6",
1715 "{",
1716 "2",
1717 "c",
1718 "4",
1719 "!",
1720 "0",
1721 "A",
1722 ":",
1723 "b",
1724 "."
1725 };
1726
1727 static int compare_string1(const void *e1, const void *e2)
1728 {
1729 const char *s1 = *(const char *const *)e1;
1730 const char *s2 = *(const char *const *)e2;
1731
1732 return lstrcmpA(s1, s2);
1733 }
1734
1735 static int compare_string2(const void *e1, const void *e2)
1736 {
1737 const char *s1 = *(const char *const *)e1;
1738 const char *s2 = *(const char *const *)e2;
1739
1740 return CompareStringA(0, 0, s1, -1, s2, -1) - 2;
1741 }
1742
1743 static int compare_string3(const void *e1, const void *e2)
1744 {
1745 const char *s1 = *(const char *const *)e1;
1746 const char *s2 = *(const char *const *)e2;
1747 char key1[256], key2[256];
1748
1749 LCMapStringA(0, LCMAP_SORTKEY, s1, -1, key1, sizeof(key1));
1750 LCMapStringA(0, LCMAP_SORTKEY, s2, -1, key2, sizeof(key2));
1751 return strcmp(key1, key2);
1752 }
1753
1754 static void test_sorting(void)
1755 {
1756 char buf[256];
1757 char **str_buf = (char **)buf;
1758 int i;
1759
1760 assert(sizeof(buf) >= sizeof(strings));
1761
1762 /* 1. sort using lstrcmpA */
1763 memcpy(buf, strings, sizeof(strings));
1764 qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string1);
1765 for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1766 {
1767 ok(!strcmp(strings_sorted[i], str_buf[i]),
1768 "qsort using lstrcmpA failed for element %d\n", i);
1769 }
1770 /* 2. sort using CompareStringA */
1771 memcpy(buf, strings, sizeof(strings));
1772 qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string2);
1773 for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1774 {
1775 ok(!strcmp(strings_sorted[i], str_buf[i]),
1776 "qsort using CompareStringA failed for element %d\n", i);
1777 }
1778 /* 3. sort using sort keys */
1779 memcpy(buf, strings, sizeof(strings));
1780 qsort(buf, sizeof(strings)/sizeof(strings[0]), sizeof(strings[0]), compare_string3);
1781 for (i = 0; i < sizeof(strings)/sizeof(strings[0]); i++)
1782 {
1783 ok(!strcmp(strings_sorted[i], str_buf[i]),
1784 "qsort using sort keys failed for element %d\n", i);
1785 }
1786 }
1787
1788 static void test_FoldStringA(void)
1789 {
1790 int ret, i, j;
1791 BOOL is_special;
1792 char src[256], dst[256];
1793 static const char digits_src[] = { 0xB9,0xB2,0xB3,'\0' };
1794 static const char digits_dst[] = { '1','2','3','\0' };
1795 static const char composite_src[] =
1796 {
1797 0x8a,0x8e,0x9a,0x9e,0x9f,0xc0,0xc1,0xc2,
1798 0xc3,0xc4,0xc5,0xc7,0xc8,0xc9,0xca,0xcb,
1799 0xcc,0xcd,0xce,0xcf,0xd1,0xd2,0xd3,0xd4,
1800 0xd5,0xd6,0xd8,0xd9,0xda,0xdb,0xdc,0xdd,
1801 0xe0,0xe1,0xe2,0xe3,0xe4,0xe5,0xe7,0xe8,
1802 0xe9,0xea,0xeb,0xec,0xed,0xee,0xef,0xf1,
1803 0xf2,0xf3,0xf4,0xf5,0xf6,0xf8,0xf9,0xfa,
1804 0xfb,0xfc,0xfd,0xff,'\0'
1805 };
1806 static const char composite_dst[] =
1807 {
1808 0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
1809 0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
1810 0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
1811 0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
1812 0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
1813 0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
1814 0x4f,0x7e,0x4f,0xa8,0x4f,0x3f,0x55,0x60,
1815 0x55,0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,
1816 0x61,0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,
1817 0x61,0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,
1818 0x65,0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,
1819 0x69,0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,
1820 0x6f,0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,
1821 0x6f,0xa8,0x6f,0x3f,0x75,0x60,0x75,0xb4,
1822 0x75,0x5e,0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
1823 };
1824 static const char composite_dst_alt[] =
1825 {
1826 0x53,0x3f,0x5a,0x3f,0x73,0x3f,0x7a,0x3f,
1827 0x59,0xa8,0x41,0x60,0x41,0xb4,0x41,0x5e,
1828 0x41,0x7e,0x41,0xa8,0x41,0xb0,0x43,0xb8,
1829 0x45,0x60,0x45,0xb4,0x45,0x5e,0x45,0xa8,
1830 0x49,0x60,0x49,0xb4,0x49,0x5e,0x49,0xa8,
1831 0x4e,0x7e,0x4f,0x60,0x4f,0xb4,0x4f,0x5e,
1832 0x4f,0x7e,0x4f,0xa8,0xd8,0x55,0x60,0x55,
1833 0xb4,0x55,0x5e,0x55,0xa8,0x59,0xb4,0x61,
1834 0x60,0x61,0xb4,0x61,0x5e,0x61,0x7e,0x61,
1835 0xa8,0x61,0xb0,0x63,0xb8,0x65,0x60,0x65,
1836 0xb4,0x65,0x5e,0x65,0xa8,0x69,0x60,0x69,
1837 0xb4,0x69,0x5e,0x69,0xa8,0x6e,0x7e,0x6f,
1838 0x60,0x6f,0xb4,0x6f,0x5e,0x6f,0x7e,0x6f,
1839 0xa8,0xf8,0x75,0x60,0x75,0xb4,0x75,0x5e,
1840 0x75,0xa8,0x79,0xb4,0x79,0xa8,'\0'
1841 };
1842 static const char ligatures_src[] =
1843 {
1844 0x8C,0x9C,0xC6,0xDE,0xDF,0xE6,0xFE,'\0'
1845 };
1846 static const char ligatures_dst[] =
1847 {
1848 'O','E','o','e','A','E','T','H','s','s','a','e','t','h','\0'
1849 };
1850 static const struct special
1851 {
1852 char src;
1853 char dst[4];
1854 } foldczone_special[] =
1855 {
1856 /* src dst */
1857 { 0x85, { 0x2e, 0x2e, 0x2e, 0x00 } },
1858 { 0x98, { 0x20, 0x7e, 0x00 } },
1859 { 0x99, { 0x54, 0x4d, 0x00 } },
1860 { 0xa0, { 0x20, 0x00 } },
1861 { 0xa8, { 0x20, 0xa8, 0x00 } },
1862 { 0xaa, { 0x61, 0x00 } },
1863 { 0xaf, { 0x20, 0xaf, 0x00 } },
1864 { 0xb2, { 0x32, 0x00 } },
1865 { 0xb3, { 0x33, 0x00 } },
1866 { 0xb4, { 0x20, 0xb4, 0x00 } },
1867 { 0xb8, { 0x20, 0xb8, 0x00 } },
1868 { 0xb9, { 0x31, 0x00 } },
1869 { 0xba, { 0x6f, 0x00 } },
1870 { 0xbc, { 0x31, 0x2f, 0x34, 0x00 } },
1871 { 0xbd, { 0x31, 0x2f, 0x32, 0x00 } },
1872 { 0xbe, { 0x33, 0x2f, 0x34, 0x00 } },
1873 { 0x00 }
1874 };
1875
1876 if (!pFoldStringA)
1877 return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
1878
1879 /* these tests are locale specific */
1880 if (GetACP() != 1252)
1881 {
1882 trace("Skipping FoldStringA tests for a not Latin 1 locale\n");
1883 return;
1884 }
1885
1886 /* MAP_FOLDDIGITS */
1887 SetLastError(0);
1888 ret = pFoldStringA(MAP_FOLDDIGITS, digits_src, -1, dst, 256);
1889 if (GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
1890 {
1891 win_skip("FoldStringA is not implemented\n");
1892 return;
1893 }
1894 ok(ret == 4, "Expected ret == 4, got %d, error %d\n", ret, GetLastError());
1895 ok(strcmp(dst, digits_dst) == 0,
1896 "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", digits_dst, dst);
1897 for (i = 1; i < 256; i++)
1898 {
1899 if (!strchr(digits_src, i))
1900 {
1901 src[0] = i;
1902 src[1] = '\0';
1903 SetLastError(0);
1904 ret = pFoldStringA(MAP_FOLDDIGITS, src, -1, dst, 256);
1905 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
1906 ok(dst[0] == src[0],
1907 "MAP_FOLDDIGITS: Expected '%s', got '%s'\n", src, dst);
1908 }
1909 }
1910
1911 /* MAP_EXPAND_LIGATURES */
1912 SetLastError(0);
1913 ret = pFoldStringA(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
1914 /* NT 4.0 doesn't support MAP_EXPAND_LIGATURES */
1915 if (!(ret == 0 && GetLastError() == ERROR_INVALID_FLAGS)) {
1916 ok(ret == sizeof(ligatures_dst), "Got %d, error %d\n", ret, GetLastError());
1917 ok(strcmp(dst, ligatures_dst) == 0,
1918 "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", ligatures_dst, dst);
1919 for (i = 1; i < 256; i++)
1920 {
1921 if (!strchr(ligatures_src, i))
1922 {
1923 src[0] = i;
1924 src[1] = '\0';
1925 SetLastError(0);
1926 ret = pFoldStringA(MAP_EXPAND_LIGATURES, src, -1, dst, 256);
1927 if (ret == 3)
1928 {
1929 /* Vista */
1930 ok((i == 0xDC && lstrcmpA(dst, "UE") == 0) ||
1931 (i == 0xFC && lstrcmpA(dst, "ue") == 0),
1932 "Got %s for %d\n", dst, i);
1933 }
1934 else
1935 {
1936 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
1937 ok(dst[0] == src[0],
1938 "MAP_EXPAND_LIGATURES: Expected '%s', got '%s'\n", src, dst);
1939 }
1940 }
1941 }
1942 }
1943
1944 /* MAP_COMPOSITE */
1945 SetLastError(0);
1946 ret = pFoldStringA(MAP_COMPOSITE, composite_src, -1, dst, 256);
1947 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
1948 ok(ret == 121 || ret == 119, "Expected 121 or 119, got %d\n", ret);
1949 ok(strcmp(dst, composite_dst) == 0 || strcmp(dst, composite_dst_alt) == 0,
1950 "MAP_COMPOSITE: Mismatch, got '%s'\n", dst);
1951
1952 for (i = 1; i < 256; i++)
1953 {
1954 if (!strchr(composite_src, i))
1955 {
1956 src[0] = i;
1957 src[1] = '\0';
1958 SetLastError(0);
1959 ret = pFoldStringA(MAP_COMPOSITE, src, -1, dst, 256);
1960 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
1961 ok(dst[0] == src[0],
1962 "0x%02x, 0x%02x,0x%02x,0x%02x,\n", (unsigned char)src[0],
1963 (unsigned char)dst[0],(unsigned char)dst[1],(unsigned char)dst[2]);
1964 }
1965 }
1966
1967 /* MAP_FOLDCZONE */
1968 for (i = 1; i < 256; i++)
1969 {
1970 src[0] = i;
1971 src[1] = '\0';
1972 SetLastError(0);
1973 ret = pFoldStringA(MAP_FOLDCZONE, src, -1, dst, 256);
1974 is_special = FALSE;
1975 for (j = 0; foldczone_special[j].src != 0 && ! is_special; j++)
1976 {
1977 if (foldczone_special[j].src == src[0])
1978 {
1979 ok(ret == 2 || ret == lstrlenA(foldczone_special[j].dst) + 1,
1980 "Expected ret == 2 or %d, got %d, error %d\n",
1981 lstrlenA(foldczone_special[j].dst) + 1, ret, GetLastError());
1982 ok(src[0] == dst[0] || lstrcmpA(foldczone_special[j].dst, dst) == 0,
1983 "MAP_FOLDCZONE: string mismatch for 0x%02x\n",
1984 (unsigned char)src[0]);
1985 is_special = TRUE;
1986 }
1987 }
1988 if (! is_special)
1989 {
1990 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
1991 ok(src[0] == dst[0],
1992 "MAP_FOLDCZONE: Expected 0x%02x, got 0x%02x\n",
1993 (unsigned char)src[0], (unsigned char)dst[0]);
1994 }
1995 }
1996
1997 /* MAP_PRECOMPOSED */
1998 for (i = 1; i < 256; i++)
1999 {
2000 src[0] = i;
2001 src[1] = '\0';
2002 SetLastError(0);
2003 ret = pFoldStringA(MAP_PRECOMPOSED, src, -1, dst, 256);
2004 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2005 ok(src[0] == dst[0],
2006 "MAP_PRECOMPOSED: Expected 0x%02x, got 0x%02x\n",
2007 (unsigned char)src[0], (unsigned char)dst[0]);
2008 }
2009 }
2010
2011 static void test_FoldStringW(void)
2012 {
2013 int ret;
2014 unsigned int i, j;
2015 WCHAR src[256], dst[256], ch, prev_ch = 1;
2016 static const DWORD badFlags[] =
2017 {
2018 0,
2019 MAP_PRECOMPOSED|MAP_COMPOSITE,
2020 MAP_PRECOMPOSED|MAP_EXPAND_LIGATURES,
2021 MAP_COMPOSITE|MAP_EXPAND_LIGATURES
2022 };
2023 /* Ranges of digits 0-9 : Must be sorted! */
2024 static const WCHAR digitRanges[] =
2025 {
2026 0x0030, /* '0'-'9' */
2027 0x0660, /* Eastern Arabic */
2028 0x06F0, /* Arabic - Hindu */
2029 0x0966, /* Devengari */
2030 0x09E6, /* Bengalii */
2031 0x0A66, /* Gurmukhi */
2032 0x0AE6, /* Gujarati */
2033 0x0B66, /* Oriya */
2034 0x0BE6, /* Tamil - No 0 */
2035 0x0C66, /* Telugu */
2036 0x0CE6, /* Kannada */
2037 0x0D66, /* Maylayalam */
2038 0x0E50, /* Thai */
2039 0x0ED0, /* Laos */
2040 0x0F29, /* Tibet - 0 is out of sequence */
2041 0x2070, /* Superscript - 1, 2, 3 are out of sequence */
2042 0x2080, /* Subscript */
2043 0x245F, /* Circled - 0 is out of sequence */
2044 0x2473, /* Bracketed */
2045 0x2487, /* Full stop */
2046 0x2775, /* Inverted circled - No 0 */
2047 0x277F, /* Patterned circled - No 0 */
2048 0x2789, /* Inverted Patterned circled - No 0 */
2049 0x3020, /* Hangzhou */
2050 0xff10, /* Pliene chasse (?) */
2051 0xffff /* Terminator */
2052 };
2053 /* Digits which are represented, but out of sequence */
2054 static const WCHAR outOfSequenceDigits[] =
2055 {
2056 0xB9, /* Superscript 1 */
2057 0xB2, /* Superscript 2 */
2058 0xB3, /* Superscript 3 */
2059 0x0F33, /* Tibetan half zero */
2060 0x24EA, /* Circled 0 */
2061 0x3007, /* Ideographic number zero */
2062 '\0' /* Terminator */
2063 };
2064 /* Digits in digitRanges for which no representation is available */
2065 static const WCHAR noDigitAvailable[] =
2066 {
2067 0x0BE6, /* No Tamil 0 */
2068 0x0F29, /* No Tibetan half zero (out of sequence) */
2069 0x2473, /* No Bracketed 0 */
2070 0x2487, /* No 0 Full stop */
2071 0x2775, /* No inverted circled 0 */
2072 0x277F, /* No patterned circled */
2073 0x2789, /* No inverted Patterned circled */
2074 0x3020, /* No Hangzhou 0 */
2075 '\0' /* Terminator */
2076 };
2077 static const WCHAR foldczone_src[] =
2078 {
2079 'W', 'i', 'n', 'e', 0x0348, 0x0551, 0x1323, 0x280d,
2080 0xff37, 0xff49, 0xff4e, 0xff45, '\0'
2081 };
2082 static const WCHAR foldczone_dst[] =
2083 {
2084 'W','i','n','e',0x0348,0x0551,0x1323,0x280d,'W','i','n','e','\0'
2085 };
2086 static const WCHAR ligatures_src[] =
2087 {
2088 'W', 'i', 'n', 'e', 0x03a6, 0x03b9, 0x03bd, 0x03b5,
2089 0x00c6, 0x00de, 0x00df, 0x00e6, 0x00fe, 0x0132, 0x0133, 0x0152,
2090 0x0153, 0x01c4, 0x01c5, 0x01c6, 0x01c7, 0x01c8, 0x01c9, 0x01ca,
2091 0x01cb, 0x01cc, 0x01e2, 0x01e3, 0x01f1, 0x01f2, 0x01f3, 0x01fc,
2092 0x01fd, 0x05f0, 0x05f1, 0x05f2, 0xfb00, 0xfb01, 0xfb02, 0xfb03,
2093 0xfb04, 0xfb05, 0xfb06, '\0'
2094 };
2095 static const WCHAR ligatures_dst[] =
2096 {
2097 'W','i','n','e',0x03a6,0x03b9,0x03bd,0x03b5,
2098 'A','E','T','H','s','s','a','e','t','h','I','J','i','j','O','E','o','e',
2099 'D',0x017d,'D',0x017e,'d',0x017e,'L','J','L','j','l','j','N','J','N','j',
2100 'n','j',0x0100,0x0112,0x0101,0x0113,'D','Z','D','z','d','z',0x00c1,0x00c9,
2101 0x00e1,0x00e9,0x05d5,0x05d5,0x05d5,0x05d9,0x05d9,0x05d9,'f','f','f','i',
2102 'f','l','f','f','i','f','f','l',0x017f,'t','s','t','\0'
2103 };
2104
2105 if (!pFoldStringW)
2106 {
2107 win_skip("FoldStringW is not available\n");
2108 return; /* FoldString is present in NT v3.1+, but not 95/98/Me */
2109 }
2110
2111 /* Invalid flag combinations */
2112 for (i = 0; i < sizeof(badFlags)/sizeof(badFlags[0]); i++)
2113 {
2114 src[0] = dst[0] = '\0';
2115 SetLastError(0);
2116 ret = pFoldStringW(badFlags[i], src, 256, dst, 256);
2117 if (GetLastError()==ERROR_CALL_NOT_IMPLEMENTED)
2118 {
2119 win_skip("FoldStringW is not implemented\n");
2120 return;
2121 }
2122 ok(!ret && GetLastError() == ERROR_INVALID_FLAGS,
2123 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2124 }
2125
2126 /* src & dst cannot be the same */
2127 SetLastError(0);
2128 ret = pFoldStringW(MAP_FOLDCZONE, src, -1, src, 256);
2129 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2130 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2131
2132 /* src can't be NULL */
2133 SetLastError(0);
2134 ret = pFoldStringW(MAP_FOLDCZONE, NULL, -1, dst, 256);
2135 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2136 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2137
2138 /* srclen can't be 0 */
2139 SetLastError(0);
2140 ret = pFoldStringW(MAP_FOLDCZONE, src, 0, dst, 256);
2141 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2142 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2143
2144 /* dstlen can't be < 0 */
2145 SetLastError(0);
2146 ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, -1);
2147 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2148 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2149
2150 /* Ret includes terminating NUL which is appended if srclen = -1 */
2151 SetLastError(0);
2152 src[0] = 'A';
2153 src[1] = '\0';
2154 dst[0] = '\0';
2155 ret = pFoldStringW(MAP_FOLDCZONE, src, -1, dst, 256);
2156 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2157 ok(dst[0] == 'A' && dst[1] == '\0',
2158 "srclen=-1: Expected ret=2 [%d,%d], got ret=%d [%d,%d], err=%d\n",
2159 'A', '\0', ret, dst[0], dst[1], GetLastError());
2160
2161 /* If size is given, result is not NUL terminated */
2162 SetLastError(0);
2163 src[0] = 'A';
2164 src[1] = 'A';
2165 dst[0] = 'X';
2166 dst[1] = 'X';
2167 ret = pFoldStringW(MAP_FOLDCZONE, src, 1, dst, 256);
2168 ok(ret == 1, "Expected ret == 1, got %d, error %d\n", ret, GetLastError());
2169 ok(dst[0] == 'A' && dst[1] == 'X',
2170 "srclen=1: Expected ret=1, [%d,%d], got ret=%d,[%d,%d], err=%d\n",
2171 'A','X', ret, dst[0], dst[1], GetLastError());
2172
2173 /* MAP_FOLDDIGITS */
2174 for (j = 0; j < sizeof(digitRanges)/sizeof(digitRanges[0]); j++)
2175 {
2176 /* Check everything before this range */
2177 for (ch = prev_ch; ch < digitRanges[j]; ch++)
2178 {
2179 SetLastError(0);
2180 src[0] = ch;
2181 src[1] = dst[0] = '\0';
2182 ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
2183 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2184
2185 ok(dst[0] == ch || strchrW(outOfSequenceDigits, ch) ||
2186 /* Wine (correctly) maps all Unicode 4.0+ digits */
2187 isdigitW(ch) || (ch >= 0x24F5 && ch <= 0x24FD) || ch == 0x24FF ||
2188 (ch >= 0x1369 && ch <= 0x1371),
2189 "MAP_FOLDDIGITS: ch %d 0x%04x Expected unchanged got %d\n", ch, ch, dst[0]);
2190 }
2191
2192 if (digitRanges[j] == 0xffff)
2193 break; /* Finished the whole code point space */
2194
2195 for (ch = digitRanges[j]; ch < digitRanges[j] + 10; ch++)
2196 {
2197 WCHAR c;
2198
2199 /* Map out of sequence characters */
2200 if (ch == 0x2071) c = 0x00B9; /* Superscript 1 */
2201 else if (ch == 0x2072) c = 0x00B2; /* Superscript 2 */
2202 else if (ch == 0x2073) c = 0x00B3; /* Superscript 3 */
2203 else if (ch == 0x245F) c = 0x24EA; /* Circled 0 */
2204 else c = ch;
2205 SetLastError(0);
2206 src[0] = c;
2207 src[1] = dst[0] = '\0';
2208 ret = pFoldStringW(MAP_FOLDDIGITS, src, -1, dst, 256);
2209 ok(ret == 2, "Expected ret == 2, got %d, error %d\n", ret, GetLastError());
2210
2211 ok((dst[0] == '0' + ch - digitRanges[j] && dst[1] == '\0') ||
2212 broken( dst[0] == ch ) || /* old Windows versions don't have all mappings */
2213 (digitRanges[j] == 0x3020 && dst[0] == ch) || /* Hangzhou not present in all Windows versions */
2214 (digitRanges[j] == 0x0F29 && dst[0] == ch) || /* Tibetan not present in all Windows versions */
2215 strchrW(noDigitAvailable, c),
2216 "MAP_FOLDDIGITS: ch %d Expected %d got %d\n",
2217 ch, '0' + digitRanges[j] - ch, dst[0]);
2218 }
2219 prev_ch = ch;
2220 }
2221
2222 /* MAP_FOLDCZONE */
2223 SetLastError(0);
2224 ret = pFoldStringW(MAP_FOLDCZONE, foldczone_src, -1, dst, 256);
2225 ok(ret == sizeof(foldczone_dst)/sizeof(foldczone_dst[0]),
2226 "Got %d, error %d\n", ret, GetLastError());
2227 ok(!memcmp(dst, foldczone_dst, sizeof(foldczone_dst)),
2228 "MAP_FOLDCZONE: Expanded incorrectly\n");
2229
2230 /* MAP_EXPAND_LIGATURES */
2231 SetLastError(0);
2232 ret = pFoldStringW(MAP_EXPAND_LIGATURES, ligatures_src, -1, dst, 256);
2233 /* NT 4.0 doesn't support MAP_EXPAND_LIGATURES */
2234 if (!(ret == 0 && GetLastError() == ERROR_INVALID_FLAGS)) {
2235 ok(ret == sizeof(ligatures_dst)/sizeof(ligatures_dst[0]),
2236 "Got %d, error %d\n", ret, GetLastError());
2237 ok(!memcmp(dst, ligatures_dst, sizeof(ligatures_dst)),
2238 "MAP_EXPAND_LIGATURES: Expanded incorrectly\n");
2239 }
2240
2241 /* FIXME: MAP_PRECOMPOSED : MAP_COMPOSITE */
2242 }
2243
2244
2245
2246 #define LCID_OK(l) \
2247 ok(lcid == l, "Expected lcid = %08x, got %08x\n", l, lcid)
2248 #define MKLCID(x,y,z) MAKELCID(MAKELANGID(x, y), z)
2249 #define LCID_RES(src, res) lcid = ConvertDefaultLocale(src); LCID_OK(res)
2250 #define TEST_LCIDLANG(a,b) LCID_RES(MAKELCID(a,b), MAKELCID(a,b))
2251 #define TEST_LCID(a,b,c) LCID_RES(MKLCID(a,b,c), MKLCID(a,b,c))
2252
2253 static void test_ConvertDefaultLocale(void)
2254 {
2255 LCID lcid;
2256
2257 /* Doesn't change lcid, even if non default sublang/sort used */
2258 TEST_LCID(LANG_ENGLISH, SUBLANG_ENGLISH_US, SORT_DEFAULT);
2259 TEST_LCID(LANG_ENGLISH, SUBLANG_ENGLISH_UK, SORT_DEFAULT);
2260 TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT, SORT_DEFAULT);
2261 TEST_LCID(LANG_JAPANESE, SUBLANG_DEFAULT, SORT_JAPANESE_UNICODE);
2262
2263 /* SUBLANG_NEUTRAL -> SUBLANG_DEFAULT */
2264 LCID_RES(MKLCID(LANG_ENGLISH, SUBLANG_NEUTRAL, SORT_DEFAULT),
2265 MKLCID(LANG_ENGLISH, SUBLANG_DEFAULT, SORT_DEFAULT));
2266 LCID_RES(MKLCID(LANG_JAPANESE, SUBLANG_NEUTRAL, SORT_DEFAULT),
2267 MKLCID(LANG_JAPANESE, SUBLANG_DEFAULT, SORT_DEFAULT));
2268
2269 /* Invariant language is not treated specially */
2270 TEST_LCID(LANG_INVARIANT, SUBLANG_DEFAULT, SORT_DEFAULT);
2271
2272 /* User/system default languages alone are not mapped */
2273 TEST_LCIDLANG(LANG_SYSTEM_DEFAULT, SORT_JAPANESE_UNICODE);
2274 TEST_LCIDLANG(LANG_USER_DEFAULT, SORT_JAPANESE_UNICODE);
2275
2276 /* Default lcids */
2277 LCID_RES(LOCALE_SYSTEM_DEFAULT, GetSystemDefaultLCID());
2278 LCID_RES(LOCALE_USER_DEFAULT, GetUserDefaultLCID());
2279 LCID_RES(LOCALE_NEUTRAL, GetUserDefaultLCID());
2280 }
2281
2282 static BOOL CALLBACK langgrp_procA(LGRPID lgrpid, LPSTR lpszNum, LPSTR lpszName,
2283 DWORD dwFlags, LONG_PTR lParam)
2284 {
2285 trace("%08x, %s, %s, %08x, %08lx\n",
2286 lgrpid, lpszNum, lpszName, dwFlags, lParam);
2287
2288 ok(pIsValidLanguageGroup(lgrpid, dwFlags) == TRUE,
2289 "Enumerated grp %d not valid (flags %d)\n", lgrpid, dwFlags);
2290
2291 /* If lParam is one, we are calling with flags defaulted from 0 */
2292 ok(!lParam || (dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED),
2293 "Expected dwFlags == LGRPID_INSTALLED || dwFlags == LGRPID_SUPPORTED, got %d\n", dwFlags);
2294
2295 return TRUE;
2296 }
2297
2298 static void test_EnumSystemLanguageGroupsA(void)
2299 {
2300 BOOL ret;
2301
2302 if (!pEnumSystemLanguageGroupsA || !pIsValidLanguageGroup)
2303 {
2304 win_skip("EnumSystemLanguageGroupsA and/or IsValidLanguageGroup are not available\n");
2305 return;
2306 }
2307
2308 /* No enumeration proc */
2309 SetLastError(0);
2310 ret = pEnumSystemLanguageGroupsA(0, LGRPID_INSTALLED, 0);
2311 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2312 {
2313 win_skip("EnumSystemLanguageGroupsA is not implemented\n");
2314 return;
2315 }
2316 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2317 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2318
2319 /* Invalid flags */
2320 SetLastError(0);
2321 pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED|LGRPID_SUPPORTED, 0);
2322 ok(GetLastError() == ERROR_INVALID_FLAGS, "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2323
2324 /* No flags - defaults to LGRPID_INSTALLED */
2325 SetLastError(0xdeadbeef);
2326 pEnumSystemLanguageGroupsA(langgrp_procA, 0, 1);
2327 ok(GetLastError() == 0xdeadbeef, "got error %d\n", GetLastError());
2328
2329 pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_INSTALLED, 0);
2330 pEnumSystemLanguageGroupsA(langgrp_procA, LGRPID_SUPPORTED, 0);
2331 }
2332
2333
2334 static BOOL CALLBACK lgrplocale_procA(LGRPID lgrpid, LCID lcid, LPSTR lpszNum,
2335 LONG_PTR lParam)
2336 {
2337 trace("%08x, %08x, %s, %08lx\n", lgrpid, lcid, lpszNum, lParam);
2338
2339 /* invalid locale enumerated on some platforms */
2340 if (lcid == 0)
2341 return TRUE;
2342
2343 ok(pIsValidLanguageGroup(lgrpid, LGRPID_SUPPORTED) == TRUE,
2344 "Enumerated grp %d not valid\n", lgrpid);
2345 ok(IsValidLocale(lcid, LCID_SUPPORTED) == TRUE,
2346 "Enumerated grp locale %d not valid\n", lcid);
2347 return TRUE;
2348 }
2349
2350 static void test_EnumLanguageGroupLocalesA(void)
2351 {
2352 BOOL ret;
2353
2354 if (!pEnumLanguageGroupLocalesA || !pIsValidLanguageGroup)
2355 {
2356 win_skip("EnumLanguageGroupLocalesA and/or IsValidLanguageGroup are not available\n");
2357 return;
2358 }
2359
2360 /* No enumeration proc */
2361 SetLastError(0);
2362 ret = pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0, 0);
2363 if (!ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2364 {
2365 win_skip("EnumLanguageGroupLocalesA is not implemented\n");
2366 return;
2367 }
2368 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2369 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2370
2371 /* lgrpid too small */
2372 SetLastError(0);
2373 ret = pEnumLanguageGroupLocalesA(lgrplocale_procA, 0, 0, 0);
2374 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2375 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2376
2377 /* lgrpid too big */
2378 SetLastError(0);
2379 ret = pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_ARMENIAN + 1, 0, 0);
2380 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2381 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2382
2383 /* dwFlags is reserved */
2384 SetLastError(0);
2385 ret = pEnumLanguageGroupLocalesA(0, LGRPID_WESTERN_EUROPE, 0x1, 0);
2386 ok( !ret && GetLastError() == ERROR_INVALID_PARAMETER,
2387 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2388
2389 pEnumLanguageGroupLocalesA(lgrplocale_procA, LGRPID_WESTERN_EUROPE, 0, 0);
2390 }
2391
2392 static void test_SetLocaleInfoA(void)
2393 {
2394 BOOL bRet;
2395 LCID lcid = GetUserDefaultLCID();
2396
2397 /* Null data */
2398 SetLastError(0);
2399 bRet = SetLocaleInfoA(lcid, LOCALE_SDATE, 0);
2400 ok( !bRet && GetLastError() == ERROR_INVALID_PARAMETER,
2401 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2402
2403 /* IDATE */
2404 SetLastError(0);
2405 bRet = SetLocaleInfoA(lcid, LOCALE_IDATE, (LPSTR)test_SetLocaleInfoA);
2406 ok(!bRet && GetLastError() == ERROR_INVALID_FLAGS,
2407 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2408
2409 /* ILDATE */
2410 SetLastError(0);
2411 bRet = SetLocaleInfoA(lcid, LOCALE_ILDATE, (LPSTR)test_SetLocaleInfoA);
2412 ok(!bRet && GetLastError() == ERROR_INVALID_FLAGS,
2413 "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2414 }
2415
2416 static BOOL CALLBACK luilocale_proc1A(LPSTR value, LONG_PTR lParam)
2417 {
2418 trace("%s %08lx\n", value, lParam);
2419 return(TRUE);
2420 }
2421
2422 static BOOL CALLBACK luilocale_proc2A(LPSTR value, LONG_PTR lParam)
2423 {
2424 ok(!enumCount, "callback called again unexpected\n");
2425 enumCount++;
2426 return(FALSE);
2427 }
2428
2429 static BOOL CALLBACK luilocale_proc3A(LPSTR value, LONG_PTR lParam)
2430 {
2431 ok(0,"callback called unexpected\n");
2432 return(FALSE);
2433 }
2434
2435 static void test_EnumUILanguageA(void)
2436 {
2437 BOOL ret;
2438 if (!pEnumUILanguagesA) {
2439 win_skip("EnumUILanguagesA is not available on Win9x or NT4\n");
2440 return;
2441 }
2442
2443 SetLastError(ERROR_SUCCESS);
2444 ret = pEnumUILanguagesA(luilocale_proc1A, 0, 0);
2445 if (ret && GetLastError() == ERROR_CALL_NOT_IMPLEMENTED)
2446 {
2447 win_skip("EnumUILanguagesA is not implemented\n");
2448 return;
2449 }
2450 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
2451
2452 enumCount = 0;
2453 SetLastError(ERROR_SUCCESS);
2454 ret = pEnumUILanguagesA(luilocale_proc2A, 0, 0);
2455 ok(ret, "Expected ret != 0, got %d, error %d\n", ret, GetLastError());
2456
2457 SetLastError(ERROR_SUCCESS);
2458 ret = pEnumUILanguagesA(NULL, 0, 0);
2459 ok(!ret, "Expected return value FALSE, got %u\n", ret);
2460 ok(GetLastError() == ERROR_INVALID_PARAMETER,
2461 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2462
2463 SetLastError(ERROR_SUCCESS);
2464 ret = pEnumUILanguagesA(luilocale_proc3A, 0x5a5a5a5a, 0);
2465 ok(!ret, "Expected return value FALSE, got %u\n", ret);
2466 ok(GetLastError() == ERROR_INVALID_FLAGS, "Expected ERROR_INVALID_FLAGS, got %d\n", GetLastError());
2467
2468 SetLastError(ERROR_SUCCESS);
2469 ret = pEnumUILanguagesA(NULL, 0x5a5a5a5a, 0);
2470 ok(!ret, "Expected return value FALSE, got %u\n", ret);
2471 ok(GetLastError() == ERROR_INVALID_PARAMETER,
2472 "Expected ERROR_INVALID_PARAMETER, got %d\n", GetLastError());
2473 }
2474
2475 static char date_fmt_buf[1024];
2476
2477 static BOOL CALLBACK enum_datetime_procA(LPSTR fmt)
2478 {
2479 lstrcatA(date_fmt_buf, fmt);
2480 lstrcatA(date_fmt_buf, "\n");
2481 return TRUE;
2482 }
2483
2484 static void test_EnumDateFormatsA(void)
2485 {
2486 char *p, buf[256];
2487 BOOL ret;
2488 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
2489
2490 trace("EnumDateFormatsA 0\n");
2491 date_fmt_buf[0] = 0;
2492 SetLastError(0xdeadbeef);
2493 ret = EnumDateFormatsA(enum_datetime_procA, lcid, 0);
2494 if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
2495 {
2496 win_skip("0 for dwFlags is not supported\n");
2497 }
2498 else
2499 {
2500 ok(ret, "EnumDateFormatsA(0) error %d\n", GetLastError());
2501 trace("%s\n", date_fmt_buf);
2502 /* test the 1st enumerated format */
2503 if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2504 ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
2505 ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
2506 ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2507 }
2508
2509 trace("EnumDateFormatsA LOCALE_USE_CP_ACP\n");
2510 date_fmt_buf[0] = 0;
2511 SetLastError(0xdeadbeef);
2512 ret = EnumDateFormatsA(enum_datetime_procA, lcid, LOCALE_USE_CP_ACP);
2513 if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
2514 {
2515 win_skip("LOCALE_USE_CP_ACP is not supported\n");
2516 }
2517 else
2518 {
2519 ok(ret, "EnumDateFormatsA(LOCALE_USE_CP_ACP) error %d\n", GetLastError());
2520 trace("%s\n", date_fmt_buf);
2521 /* test the 1st enumerated format */
2522 if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2523 ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
2524 ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
2525 ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2526 }
2527
2528 trace("EnumDateFormatsA DATE_SHORTDATE\n");
2529 date_fmt_buf[0] = 0;
2530 ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_SHORTDATE);
2531 ok(ret, "EnumDateFormatsA(DATE_SHORTDATE) error %d\n", GetLastError());
2532 trace("%s\n", date_fmt_buf);
2533 /* test the 1st enumerated format */
2534 if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2535 ret = GetLocaleInfoA(lcid, LOCALE_SSHORTDATE, buf, sizeof(buf));
2536 ok(ret, "GetLocaleInfoA(LOCALE_SSHORTDATE) error %d\n", GetLastError());
2537 ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2538
2539 trace("EnumDateFormatsA DATE_LONGDATE\n");
2540 date_fmt_buf[0] = 0;
2541 ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_LONGDATE);
2542 ok(ret, "EnumDateFormatsA(DATE_LONGDATE) error %d\n", GetLastError());
2543 trace("%s\n", date_fmt_buf);
2544 /* test the 1st enumerated format */
2545 if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2546 ret = GetLocaleInfoA(lcid, LOCALE_SLONGDATE, buf, sizeof(buf));
2547 ok(ret, "GetLocaleInfoA(LOCALE_SLONGDATE) error %d\n", GetLastError());
2548 ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2549
2550 trace("EnumDateFormatsA DATE_YEARMONTH\n");
2551 date_fmt_buf[0] = 0;
2552 SetLastError(0xdeadbeef);
2553 ret = EnumDateFormatsA(enum_datetime_procA, lcid, DATE_YEARMONTH);
2554 if (!ret && (GetLastError() == ERROR_INVALID_FLAGS))
2555 {
2556 skip("DATE_YEARMONTH is only present on W2K and later\n");
2557 return;
2558 }
2559 ok(ret, "EnumDateFormatsA(DATE_YEARMONTH) error %d\n", GetLastError());
2560 trace("%s\n", date_fmt_buf);
2561 /* test the 1st enumerated format */
2562 if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2563 ret = GetLocaleInfoA(lcid, LOCALE_SYEARMONTH, buf, sizeof(buf));
2564 ok(ret, "GetLocaleInfoA(LOCALE_SYEARMONTH) error %d\n", GetLastError());
2565 ok(!lstrcmpA(date_fmt_buf, buf) || broken(!buf[0]) /* win9x */,
2566 "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2567 }
2568
2569 static void test_EnumTimeFormatsA(void)
2570 {
2571 char *p, buf[256];
2572 BOOL ret;
2573 LCID lcid = MAKELCID(MAKELANGID(LANG_ENGLISH, SUBLANG_ENGLISH_US), SORT_DEFAULT);
2574
2575 trace("EnumTimeFormatsA 0\n");
2576 date_fmt_buf[0] = 0;
2577 ret = EnumTimeFormatsA(enum_datetime_procA, lcid, 0);
2578 ok(ret, "EnumTimeFormatsA(0) error %d\n", GetLastError());
2579 trace("%s\n", date_fmt_buf);
2580 /* test the 1st enumerated format */
2581 if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2582 ret = GetLocaleInfoA(lcid, LOCALE_STIMEFORMAT, buf, sizeof(buf));
2583 ok(ret, "GetLocaleInfoA(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
2584 ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2585
2586 trace("EnumTimeFormatsA LOCALE_USE_CP_ACP\n");
2587 date_fmt_buf[0] = 0;
2588 ret = EnumTimeFormatsA(enum_datetime_procA, lcid, LOCALE_USE_CP_ACP);
2589 ok(ret, "EnumTimeFormatsA(LOCALE_USE_CP_ACP) error %d\n", GetLastError());
2590 trace("%s\n", date_fmt_buf);
2591 /* test the 1st enumerated format */
2592 if ((p = strchr(date_fmt_buf, '\n'))) *p = 0;
2593 ret = GetLocaleInfoA(lcid, LOCALE_STIMEFORMAT, buf, sizeof(buf));
2594 ok(ret, "GetLocaleInfoA(LOCALE_STIMEFORMAT) error %d\n", GetLastError());
2595 ok(!lstrcmpA(date_fmt_buf, buf), "expected \"%s\" got \"%s\"\n", date_fmt_buf, buf);
2596 }
2597
2598 static void test_GetCPInfo(void)
2599 {
2600 BOOL ret;
2601 CPINFO cpinfo;
2602
2603 SetLastError(0xdeadbeef);
2604 ret = GetCPInfo(CP_SYMBOL, &cpinfo);
2605 ok(!ret, "GetCPInfo(CP_SYMBOL) should fail\n");
2606 ok(GetLastError() == ERROR_INVALID_PARAMETER,
2607 "expected ERROR_INVALID_PARAMETER, got %u\n", GetLastError());
2608
2609 SetLastError(0xdeadbeef);
2610 ret = GetCPInfo(CP_UTF7, &cpinfo);
2611 if (!ret && GetLastError() == ERROR_INVALID_PARAMETER)
2612 {
2613 skip("Codepage CP_UTF7 is not installed/available\n");
2614 }
2615 else
2616 {
2617 ok(ret, "GetCPInfo(CP_UTF7) error %u\n", GetLastError());
2618 ok(cpinfo.DefaultChar[0] == 0x3f, "expected 0x3f, got 0x%x\n", cpinfo.DefaultChar[0]);
2619 ok(cpinfo.DefaultChar[1] == 0, "expected 0, got 0x%x\n", cpinfo.DefaultChar[1]);
2620 ok(cpinfo.LeadByte[0] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[0]);
2621 ok(cpinfo.LeadByte[1] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[1]);
2622 ok(cpinfo.MaxCharSize == 5, "expected 5, got 0x%x\n", cpinfo.MaxCharSize);
2623 }
2624
2625 SetLastError(0xdeadbeef);
2626 ret = GetCPInfo(CP_UTF8, &cpinfo);
2627 if (!ret && GetLastError() == ERROR_INVALID_PARAMETER)
2628 {
2629 skip("Codepage CP_UTF8 is not installed/available\n");
2630 }
2631 else
2632 {
2633 ok(ret, "GetCPInfo(CP_UTF8) error %u\n", GetLastError());
2634 ok(cpinfo.DefaultChar[0] == 0x3f, "expected 0x3f, got 0x%x\n", cpinfo.DefaultChar[0]);
2635 ok(cpinfo.DefaultChar[1] == 0, "expected 0, got 0x%x\n", cpinfo.DefaultChar[1]);
2636 ok(cpinfo.LeadByte[0] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[0]);
2637 ok(cpinfo.LeadByte[1] == 0, "expected 0, got 0x%x\n", cpinfo.LeadByte[1]);
2638 ok(cpinfo.MaxCharSize == 4 || broken(cpinfo.MaxCharSize == 3) /* win9x */,
2639 "expected 4, got %u\n", cpinfo.MaxCharSize);
2640 }
2641 }
2642
2643 START_TEST(locale)
2644 {
2645 InitFunctionPointers();
2646
2647 test_EnumTimeFormatsA();
2648 test_EnumDateFormatsA();
2649 test_GetLocaleInfoA();
2650 test_GetLocaleInfoW();
2651 test_GetTimeFormatA();
2652 test_GetDateFormatA();
2653 test_GetDateFormatW();
2654 test_GetCurrencyFormatA(); /* Also tests the W version */
2655 test_GetNumberFormatA(); /* Also tests the W version */
2656 test_CompareStringA();
2657 test_LCMapStringA();
2658 test_LCMapStringW();
2659 test_FoldStringA();
2660 test_FoldStringW();
2661 test_ConvertDefaultLocale();
2662 test_EnumSystemLanguageGroupsA();
2663 test_EnumLanguageGroupLocalesA();
2664 test_SetLocaleInfoA();
2665 test_EnumUILanguageA();
2666 test_GetCPInfo();
2667 /* this requires collation table patch to make it MS compatible */
2668 if (0) test_sorting();
2669 }
useful hacks and other patches not (yet) suitable for mainline