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