1 /*
2 * Copyright (c) Huawei Technologies Co., Ltd. 2020-2020. All rights reserved.
3 */
4 /*
5 * Copyright (c) 2021 Huawei Device Co., Ltd.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
9 *
10 * http://www.apache.org/licenses/LICENSE-2.0
11 *
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
17 */
18
19 #include <stdarg.h>
20
21 #include <wchar.h>
22
23 #include "IoTest.h"
24 #include <securec.h>
25
26 using namespace testing::ext;
27
28
FormatVfwscanf(FILE * fp,const wchar_t * format,...)29 int FormatVfwscanf(FILE *fp, const wchar_t *format, ...)
30 {
31 va_list args;
32 va_start(args, format);
33 int ret = vfwscanf(fp, format, args);
34 va_end(args);
35 return ret;
36 }
37
FormatVfwprintf(FILE * fp,const wchar_t * format,...)38 int FormatVfwprintf(FILE *fp, const wchar_t *format, ...)
39 {
40 va_list args;
41 va_start(args, format);
42 int ret = vfwprintf(fp, format, args);
43 va_end(args);
44 return ret;
45 }
46
47 /**
48 * @tc.number SUB_KERNEL_IO_WCHAR_0100
49 * @tc.name vfwprintf basic function test
50 * @tc.desc [C- SOFTWARE -0200]
51 */
52 HWTEST_F(IoTest, testVfwprintf, Function | MediumTest | Level1)
53 {
54 FILE *fp = nullptr;
55 FOPEN_WRITE(fp);
56 int ret = FormatVfwprintf(fp, L"%s has %d words ", "helloworld", 10);
57 EXPECT_EQ(ret, 24);
58 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
59
60 FOPEN_READ(fp);
61 wchar_t wStr[50] = {0};
62 int i;
63 ret = FormatVfwscanf(fp, L"%ls has %d words ", wStr, &i);
64 EXPECT_EQ(ret, 2) << "> vfwscanf return fail, errno = " << errno;
65 EXPECT_STREQ(wStr, L"helloworld");
66 EXPECT_EQ(i, 10);
67
68 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
69 }
70
71 /**
72 * @tc.number SUB_KERNEL_IO_WCHAR_0200
73 * @tc.name fwprintf basic function test
74 * @tc.desc [C- SOFTWARE -0200]
75 */
76 HWTEST_F(IoTest, testFwprintf, Function | MediumTest | Level1)
77 {
78 FILE *fp = nullptr;
79 FOPEN_WRITE(fp);
80 int ret = fwprintf(fp, L"%s has %d words ", "helloworld", 10);
81 EXPECT_EQ(ret, 24);
82 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
83
84 FOPEN_READ(fp);
85 wchar_t wStr[50] = {0};
86 int i;
87 ret = fwscanf(fp, L"%ls has %d words ", wStr, &i);
88 EXPECT_EQ(ret, 2) << "> vfwscanf return fail, errno = " << errno;
89 EXPECT_STREQ(wStr, L"helloworld");
90 EXPECT_EQ(i, 10);
91
92 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
93 }
94
95 /**
96 * @tc.number SUB_KERNEL_IO_WCHAR_0300
97 * @tc.name fwide basic function test
98 * @tc.desc [C- SOFTWARE -0200]
99 */
100 HWTEST_F(IoTest, testFwide, Function | MediumTest | Level1)
101 {
102 FILE *fp = nullptr;
103 INIT_TEST_FILE(fp);
104 FOPEN_READ(fp);
105 int ret = fwide(fp, -6);
106 EXPECT_EQ(ret, -1);
107 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
108
109 FOPEN_READ(fp);
110 ret = fwide(fp, 0);
111 EXPECT_EQ(ret, 0);
112 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
113
114 FOPEN_READ(fp);
115 ret = fwide(fp, 8);
116 EXPECT_EQ(ret, 1);
117 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
118 }
119
120 /**
121 * @tc.number SUB_KERNEL_IO_WCHAR_0400
122 * @tc.name fgetws basic function test
123 * @tc.desc [C- SOFTWARE -0200]
124 */
125 HWTEST_F(IoTest, testFgetws, Function | MediumTest | Level1)
126 {
127 FILE *fp = nullptr;
128 FOPEN_WRITE(fp);
129 wchar_t wStr[50] = {0};
130 wchar_t wStrT[50] = L"hello world";
131 int ret = fputws(wStrT, fp);
132 ASSERT_NE(ret, -1) << "> fputws fail, errno = " << errno;
133 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
134
135 FOPEN_READ(fp);
136 wchar_t *retW = fgetws(wStr, sizeof(wStr)/sizeof(wStr[0]), fp);
137 EXPECT_STREQ(retW, wStrT);
138 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
139 }
140
141 /**
142 * @tc.number SUB_KERNEL_IO_WCHAR_0500
143 * @tc.name putwc basic function test
144 * @tc.desc [C- SOFTWARE -0200]
145 */
146 HWTEST_F(IoTest, testPutwc, Function | MediumTest | Level1)
147 {
148 FILE *fp = nullptr;
149 FOPEN_WRITE(fp);
150 wint_t ret = putwc(L'A', fp);
151 EXPECT_EQ(ret, L'A');
152 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
153
154 FOPEN_READ(fp);
155 ret = getwc(fp);
156 EXPECT_EQ(ret, L'A');
157 EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
158 }
159
160 /**
161 * @tc.number SUB_KERNEL_IO_WCHAR_0600
162 * @tc.name ungetwc basic function test
163 * @tc.desc [C- SOFTWAret -0200]
164 */
165 HWTEST_F(IoTest, testUngetwc, Function | MediumTest | Level1)
166 {
167 FILE *fp = nullptr;
168 INIT_TEST_FILE(fp);
169 FOPEN_READ(fp);
170 wint_t ret = getwc(fp);
171 EXPECT_EQ(ret, 104U);
172 ret = ungetc(ret, fp);
173 EXPECT_EQ(ret, 104U);
174 wchar_t str[50] = {0};
175 wchar_t *retS = fgetws(str, sizeof(str)/sizeof(str[0]), fp);
176 EXPECT_STREQ(retS, str);
177 EXPECT_STREQ(str, L"hello world");
178 EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
179 }
180
181 /**
182 * @tc.number SUB_KERNEL_IO_WCHAR_0700
183 * @tc.name fputwc basic function test
184 * @tc.desc [C- SOFTWARE -0200]
185 */
186 HWTEST_F(IoTest, testFputwc, Function | MediumTest | Level1)
187 {
188 FILE *fp = nullptr;
189 FOPEN_WRITE(fp);
190 wint_t ret = fputwc(L'A', fp);
191 EXPECT_EQ(ret, L'A');
192 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
193
194 FOPEN_READ(fp);
195 ret = fgetwc(fp);
196 EXPECT_EQ(ret, L'A');
197 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
198 }
199
200 /**
201 * @tc.number SUB_KERNEL_IO_WCHAR_0800
202 * @tc.name fwscanf basic function test
203 * @tc.desc [C- SOFTWARE -0200]
204 */
205 HWTEST_F(IoTest, testFwscanf, Function | MediumTest | Level1)
206 {
207 FILE *fp = nullptr;
208 FOPEN_WRITE(fp);
209 int ret = fwprintf(fp, L"%ls has %d words", L"helloworld", 10);
210 EXPECT_EQ(ret, 23);
211 EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
212
213 FOPEN_READ(fp);
214 wchar_t wStr[50] = {0};
215 int i;
216 ret = fwscanf(fp, L"%ls has %d words", wStr, &i);
217 EXPECT_EQ(ret, 2);
218 EXPECT_EQ(i, 10);
219 EXPECT_STREQ(wStr, L"helloworld");
220 ASSERT_NE(fclose(fp), -1) << "> fclose fail, errno = "<< errno;
221 }
222
223 /**
224 * @tc.number SUB_KERNEL_IO_WCHAR_0900
225 * @tc.name wmemset basic function test
226 * @tc.desc [C- SOFTWARE -0200]
227 */
228 HWTEST_F(IoTest, testWmemset, Function | MediumTest | Level1)
229 {
230 wchar_t dest[50] = {0};
231 wchar_t *ret = wmemset(dest, L'=', 8);
232 EXPECT_STREQ(ret, dest);
233 EXPECT_STREQ(dest, L"========");
234
235 ret = wmemset(dest, L' ', 8);
236 EXPECT_STREQ(ret, dest);
237 EXPECT_STREQ(dest, L" ");
238
239 ret = wmemset(dest, L'!', 0);
240 EXPECT_STREQ(ret, dest);
241 EXPECT_STREQ(dest, L" ");
242 }
243
244 /**
245 * @tc.number SUB_KERNEL_IO_WCHAR_1000
246 * @tc.name wmemchr basic function test
247 * @tc.desc [C- SOFTWARE -0200]
248 */
249 HWTEST_F(IoTest, testWmemchr, Function | MediumTest | Level1)
250 {
251 wchar_t src[] = L"hello world";
252 wchar_t *ret = wmemchr(src, L' ', sizeof(src)/sizeof(src[0]) - 1);
253 EXPECT_STREQ(ret, L" world");
254
255 wchar_t srcT[] = L"this is string";
256 ret = wmemchr(srcT, L'?', sizeof(srcT)/sizeof(srcT[0]) - 1);
257 EXPECT_STREQ(ret, nullptr);
258 }
259
260 /**
261 * @tc.number SUB_KERNEL_IO_WCHAR_1100
262 * @tc.name wmemcpy basic function test
263 * @tc.desc [C- SOFTWARE -0200]
264 */
265 HWTEST_F(IoTest, testWmemcpy, Function | MediumTest | Level1)
266 {
267 wchar_t src[] = L"hello";
268 wchar_t dest[] = L"world ! ! !";
269 wchar_t *ret = wmemcpy(dest, src, 5);
270 EXPECT_STREQ(ret, L"hello ! ! !");
271
272 wchar_t srcT[] = L"this is";
273 wchar_t destT[] = L"string";
274 ret = wmemcpy(destT, srcT, 0);
275 EXPECT_STREQ(ret, destT);
276 }
277
278 /**
279 * @tc.number SUB_KERNEL_IO_WCHAR_1200
280 * @tc.name wmemmove basic function test
281 * @tc.desc [C- SOFTWARE -0200]
282 */
283 HWTEST_F(IoTest, testWmemmove, Function | MediumTest | Level1)
284 {
285 wchar_t src[] = L"hello";
286 wchar_t dest[] = L"world ! ! !";
287 wchar_t *ret = wmemmove(dest, src, 5);
288 EXPECT_STREQ(ret, L"hello ! ! !");
289
290 wchar_t srcT[] = L"this is";
291 wchar_t destT[] = L"string";
292 ret = wmemmove(destT, srcT, 0);
293 EXPECT_STREQ(ret, destT);
294 }
295
296 /**
297 * @tc.number SUB_KERNEL_IO_WCHAR_1300
298 * @tc.name putwchar basic function test
299 * @tc.desc [C- SOFTWARE -0200]
300 */
301 HWTEST_F(IoTest, testPutwchar, Function | MediumTest | Level1)
302 {
303 for (wchar_t wc = L'A'; wc <= L'Z'; ++wc) {
304 wint_t ret = putwchar(wc);
305 EXPECT_EQ(ret, wc);
306 }
307 }
308
309 /**
310 * @tc.number SUB_KERNEL_IO_WCHAR_1400
311 * @tc.name wmemcmp basic function test
312 * @tc.desc [C- SOFTWARE -0200]
313 */
314 HWTEST_F(IoTest, testWmemcmp, Function | MediumTest | Level1)
315 {
316 wchar_t dest[] = L"BBCDEFG";
317 wchar_t src[] = L"CBCDEFF";
318 int ret = wmemcmp(dest, src, 7);
319 EXPECT_LT(ret, 0);
320
321 ret = wmemcmp(L"abcdefg", L"ABCDEFG", 2);
322 EXPECT_GT(ret, 0);
323
324 ret = wmemcmp(L"ABCDEFG", L"ABCDEFG", 6);
325 EXPECT_EQ(ret, 0);
326 }
327
328 /**
329 * @tc.number SUB_KERNEL_IO_WCHAR_1500
330 * @tc.name mbsinit basic function test
331 * @tc.desc [C- SOFTWARE -0200]
332 */
333 HWTEST_F(IoTest, testMbsinit, Function | MediumTest | Level1)
334 {
335 mbstate_t *ps = nullptr;
336 int ret = mbsinit(ps);
337 EXPECT_NE(ret, 0);
338
339 mbstate_t psF;
340 memset_s(&psF, sizeof(psF), 0, sizeof(psF));
341 ret = mbsinit(&psF);
342 EXPECT_NE(ret, 0);
343 }
344
FormatVswscanf(const wchar_t * str,const wchar_t * format,...)345 int FormatVswscanf(const wchar_t *str, const wchar_t *format, ...)
346 {
347 va_list args;
348 va_start(args, format);
349 int ret = vswscanf(str, format, args);
350 va_end(args);
351 return ret;
352 }
353
FormatVswprintf(const wchar_t * format,...)354 int FormatVswprintf(const wchar_t *format, ...)
355 {
356 va_list args;
357 va_start(args, format);
358 wchar_t str[50] = {0};
359 int ret = vswprintf(str, sizeof(str)/sizeof(str[0]), format, args);
360 fputws(str, stdout);
361 va_end(args);
362 return ret;
363 }
364
365 /**
366 * @tc.number SUB_KERNEL_IO_WCHAR_1600
367 * @tc.name vswprintf basic function test
368 * @tc.desc [C- SOFTWARE -0200]
369 */
370 HWTEST_F(IoTest, testVswprintf, Function | MediumTest | Level1)
371 {
372 int ret = FormatVswprintf(L"%ls has %d words", L"helloworld", 10);
373 EXPECT_EQ(ret, 23);
374
375 int i;
376 wchar_t wBuf[50] = {0};
377 wchar_t str[] = L"helloworld has 10 words";
378 ret = FormatVswscanf(str, L"%ls has %d words", wBuf, &i);
379 EXPECT_EQ(ret, 2) << "> vswcanf return fail, errno = " << errno;
380 EXPECT_STREQ(wBuf, L"helloworld");
381 EXPECT_EQ(i, 10);
382 }
383
384 /**
385 * @tc.number SUB_KERNEL_IO_WCHAR_1700
386 * @tc.name swprintf basic function test
387 * @tc.desc [C- SOFTWARE -0200]
388 */
389 HWTEST_F(IoTest, testSwprintf, Function | MediumTest | Level1)
390 {
391 wchar_t wBuf[50] = {0};
392 int ret = swprintf(wBuf, sizeof(wBuf)/sizeof(wBuf[0]), L"%ls has %d words", L"helloworld", 10);
393 EXPECT_EQ(ret, 23);
394 EXPECT_STREQ(wBuf, L"helloworld has 10 words");
395
396 wchar_t wStr[50] = {0};
397 int i;
398 ret = swscanf(wBuf, L"%ls has %d words", wStr, &i);
399 EXPECT_EQ(ret, 2) << "> swscanf return fail, errno = " << errno;
400 EXPECT_EQ(i, 10);
401 EXPECT_STREQ(wStr, L"helloworld");
402 }
403
404 /**
405 * @tc.number SUB_KERNEL_IO_WCHAR_1800
406 * @tc.name wprintf basic function test
407 * @tc.desc [C- SOFTWARE -0200]
408 */
409 HWTEST_F(IoTest, testWprintf, Function | MediumTest | Level1)
410 {
411 pid_t pid = fork();
412 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
413 if (pid == 0) { // child
414 int rt = 0;
415 FILE *fp = freopen(IOTEST_TEMPFILE, "w", stdout);
416 if (fp == nullptr) {
417 LOG("freopen fail, errno = %d", errno);
418 rt = 1;
419 }
420 if (wprintf(L"%ls %d", L"helloworld", 10) != 13) {
421 LOG("wprintf fail, errno = %d", errno);
422 rt = 1;
423 }
424 if (fclose(fp) == -1) {
425 LOG("fclose fail, errno = %d", errno);
426 rt = 1;
427 }
428 exit(rt);
429 } else { // parent
430 WaitProcExitedOK(pid);
431
432 FILE *fp1 = fopen(IOTEST_TEMPFILE, "r");
433 ASSERT_NE(fp1, nullptr) << "fopen fail, errno = " << errno;
434 wchar_t str[50] = {0};
435 wchar_t *gStr = fgetws(str, sizeof(str)/sizeof(str[0]), fp1);
436 EXPECT_STREQ(gStr, str) << "fgetws fail, errno = " << errno;
437 EXPECT_STREQ(str, L"helloworld 10") << "fgetws fail, errno = " << errno;
438 EXPECT_NE(fclose(fp1), -1) << "> fclose fail, errno = " << errno;
439 }
440 }
441
442 /**
443 * @tc.number SUB_KERNEL_IO_WCHAR_1900
444 * @tc.name wscanf basic function test
445 * @tc.desc [C- SOFTWARE -0200]
446 */
447 HWTEST_F(IoTest, testWscanf, Function | MediumTest | Level1)
448 {
449 FILE *fp = nullptr;
450 INIT_TEST_FILE(fp);
451 pid_t pid = fork();
452 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
453 if (pid == 0) { // child
454 int rt = 0;
455 FILE *fp1 = freopen(IOTEST_TEMPFILE, "r", stdin);
456 if (fp1 == nullptr) {
457 LOG("freopen fail, errno = %d", errno);
458 rt = 1;
459 }
460 wchar_t str[50] = {0};
461 if (wscanf(L"%ls", str) != 1) {
462 LOG("wscanf fail, errno = %d", errno);
463 rt = 1;
464 if (wcscmp(str, L"hello world") != 0) {
465 LOG("wscanf fail, errno = %d", errno);
466 rt = 1;
467 }
468 }
469 if (fclose(fp1) == -1) {
470 LOG("fclose fail, errno = %d", errno);
471 }
472 exit(rt);
473 } else { // parent
474 WaitProcExitedOK(pid);
475 }
476 }
477
FormatVwprintf(const wchar_t * format,...)478 int FormatVwprintf(const wchar_t *format, ...)
479 {
480 va_list argPtr;
481 va_start(argPtr, format);
482 int ret = vwprintf(format, argPtr);
483 va_end(argPtr);
484 return ret;
485 }
486
487 /**
488 * @tc.number SUB_KERNEL_IO_WCHAR_2000
489 * @tc.name vwprintf basic function test
490 * @tc.desc [C- SOFTWARE -0200]
491 */
492 HWTEST_F(IoTest, testVwprintf, Function | MediumTest | Level1)
493 {
494 pid_t pid = fork();
495 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
496 if (pid == 0) { // child
497 int rt = 0;
498 FILE *fp = freopen(IOTEST_TEMPFILE, "w", stdout);
499 if (fp == nullptr) {
500 LOG("freopen fail, errno = %d", errno);
501 rt = 1;
502 }
503 if (FormatVwprintf(L"%ls %d", L"helloworld", 10) != 13) {
504 LOG("vwprintf fail, errno = %d", errno);
505 rt = 1;
506 }
507 if (fclose(fp) == -1) {
508 LOG("fclose fail, errno = %d", errno);
509 rt = 1;
510 }
511 exit(rt);
512 } else { // parent
513 WaitProcExitedOK(pid);
514
515 FILE *fp1 = fopen(IOTEST_TEMPFILE, "r");
516 ASSERT_NE(fp1, nullptr) << "fopen fail, errno = " << errno;
517 wchar_t str[50] = {0};
518 wchar_t *gStr = fgetws(str, sizeof(str)/sizeof(str[0]), fp1);
519 EXPECT_STREQ(gStr, str) << "fgetws fail, errno = " << errno;
520 EXPECT_STREQ(str, L"helloworld 10") << "fgetws fail, errno = " << errno;
521 EXPECT_NE(fclose(fp1), -1) << "> fclose fail, errno = " << errno;
522 }
523 }
524
FormatVwscanf(const wchar_t * format,...)525 int FormatVwscanf(const wchar_t *format, ...)
526 {
527 va_list argPtr;
528 va_start(argPtr, format);
529 int ret = vwscanf(format, argPtr);
530 va_end(argPtr);
531 return ret;
532 }
533
534 /**
535 * @tc.number SUB_KERNEL_IO_WCHAR_2100
536 * @tc.name vwscanf basic function test
537 * @tc.desc [C- SOFTWARE -0200]
538 */
539 HWTEST_F(IoTest, testVwscanf, Function | MediumTest | Level1)
540 {
541 FILE *fp = nullptr;
542 INIT_TEST_FILE(fp);
543 pid_t pid = fork();
544 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
545 if (pid == 0) { // child
546 int rt = 0;
547 FILE *fp1 = freopen(IOTEST_TEMPFILE, "r", stdin);
548 if (fp1 == nullptr) {
549 LOG("freopen fail, errno = %d", errno);
550 rt = 1;
551 }
552 wchar_t str[50] = {0};
553 if (FormatVwscanf(L"%ls", str) != 1) {
554 LOG("vwscanf fail, errno = %d", errno);
555 rt = 1;
556 if (wcscmp(str, L"hello world") != 0) {
557 LOG("vwscanf fail, errno = %d", errno);
558 rt = 1;
559 }
560 }
561 if (fclose(fp1) == -1) {
562 LOG("fclose fail, errno = %d", errno);
563 }
564 exit(rt);
565 } else { // parent
566 WaitProcExitedOK(pid);
567 }
568 }
569
570 /**
571 * @tc.number SUB_KERNEL_IO_WCHAR_2200
572 * @tc.name getwchar basic function test
573 * @tc.desc [C- SOFTWARE -0200]
574 */
575 HWTEST_F(IoTest, testGetwchar, Function | MediumTest | Level1)
576 {
577 FILE *fp = nullptr;
578 INIT_TEST_FILE(fp);
579 pid_t pid = fork();
580 ASSERT_TRUE(pid >= 0) << "======== Fork Error! =========";
581 if (pid == 0) { // child
582 int rt = 0;
583 FILE *fp1 = freopen(IOTEST_TEMPFILE, "r", stdin);
584 if (fp1 == nullptr) {
585 LOG("freopen fail, errno = %d", errno);
586 rt = 1;
587 }
588 if (getwchar() != 104) {
589 LOG("getwchar fail, errno = %d", errno);
590 rt = 1;
591 }
592 if (fclose(fp1) == -1) {
593 LOG("fclose fail, errno = %d", errno);
594 rt = 1;
595 }
596 exit(rt);
597 } else { // parent
598 WaitProcExitedOK(pid);
599 }
600 }
601
602 /**
603 * @tc.number SUB_KERNEL_IO_WCHAR_2300
604 * @tc.name btowc basic function test
605 * @tc.desc [C- SOFTWARE -0200]
606 */
607 HWTEST_F(IoTest, testBtowc, Function | MediumTest | Level1)
608 {
609 EXPECT_EQ(btowc('6'), L'6');
610
611 EXPECT_EQ(btowc('A'), L'A');
612
613 EXPECT_EQ(btowc('&'), L'&');
614
615 EXPECT_EQ(btowc(EOF), WEOF);
616 }