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 <sys/uio.h>
17
18#include <grp.h>
19#include <shadow.h>
20#include <pwd.h>
21#include <inttypes.h>
22#include <iconv.h>
23
24#include "IoTest.h"
25#include <securec.h>
26
27using namespace testing::ext;
28
29/**
30 * @tc.number SUB_KERNEL_IO_OTHER_0400
31 * @tc.name   toupper basic function test
32 * @tc.desc   [C- SOFTWARE -0200]
33 */
34HWTEST_F(IoTest, testToupper, Function | MediumTest | Level1)
35{
36    for (int i = 0; i < 26; i++) {
37        int ret = _toupper('a' + i);
38        EXPECT_EQ(ret, 'A' + i);
39    }
40}
41
42/**
43 * @tc.number SUB_KERNEL_IO_OTHER_0500
44 * @tc.name   strtoimax basic function test
45 * @tc.desc   [C- SOFTWARE -0200]
46 */
47HWTEST_F(IoTest, testStrtuimax, Function | MediumTest | Level1)
48{
49    char nPtr[] = "12 0110 0XDEFE 0666 -1.6";
50    char *endPtr = nullptr;
51    intmax_t ret = strtoimax(nPtr, &endPtr, 10);
52    EXPECT_EQ(ret, 12) << "> strtoimax fail, errno = " << errno;
53    EXPECT_STREQ(endPtr, " 0110 0XDEFE 0666 -1.6");
54
55    ret = strtoimax(endPtr, &endPtr, 2);
56    EXPECT_EQ(ret, 6) << "> strtoimax fail, errno = " << errno;
57    EXPECT_STREQ(endPtr, " 0XDEFE 0666 -1.6");
58
59    ret = strtoimax(endPtr, &endPtr, 16);
60    EXPECT_EQ(ret, 0XDEFE) << "> strtoimax fail, errno = " << errno;
61    EXPECT_STREQ(endPtr, " 0666 -1.6");
62
63
64    ret = strtoimax(endPtr, &endPtr, 8);
65    EXPECT_EQ(ret, 0666) << "> strtoimax fail, errno = " << errno;
66    EXPECT_STREQ(endPtr, " -1.6");
67
68    ret = strtoimax(endPtr, &endPtr, 65);
69    EXPECT_EQ(ret, 0) << "> strtoimax fail, errno = " << errno;
70    EXPECT_STREQ(endPtr, " -1.6");
71
72    ret = strtoimax(endPtr, &endPtr, 10);
73    EXPECT_EQ(ret, -1) << "> strtoimax fail, errno = " << errno;
74    EXPECT_STREQ(endPtr, ".6");
75
76    ret = strtoimax(endPtr, &endPtr, 10);
77    EXPECT_EQ(ret, 0) << "> strtoimax fail, errno = " << errno;
78    EXPECT_STREQ(endPtr, ".6");
79
80    char nPtr1[] = "9223372036854775807 9223372036854775808 -9223372036854775807"; // 2^63-1
81    ret = strtoimax(nPtr1, &endPtr, 10);
82    EXPECT_EQ(ret, 9223372036854775807) << "> strtoimax fail, errno = " << errno;
83    EXPECT_STREQ(endPtr, " 9223372036854775808 -9223372036854775807");
84
85    ret = strtoimax(endPtr, &endPtr, 10);
86    EXPECT_EQ(ret, 9223372036854775807) << "> strtoimax fail, errno = " << errno;
87    EXPECT_STREQ(endPtr, " -9223372036854775807");
88
89    ret = strtoimax(endPtr, &endPtr, 10);
90    EXPECT_EQ(ret, -9223372036854775807) << "> strtoimax fail, errno = " << errno;
91    EXPECT_STREQ(endPtr, "");
92}
93
94/**
95 * @tc.number SUB_KERNEL_IO_OTHER_0600
96 * @tc.name   strtoumax basic function test
97 * @tc.desc   [C- SOFTWARE -0200]
98 */
99HWTEST_F(IoTest, testStrtoumax, Function | MediumTest | Level1)
100{
101    char nPtr[] = "12 0110 0XDEFE 0666 1.6";
102    char *endPtr = nullptr;
103    uintmax_t ret = strtoumax(nPtr, &endPtr, 10);
104    EXPECT_EQ(ret, 12ULL) << "> strtoumax fail, errno = " << errno;
105    EXPECT_STREQ(endPtr, " 0110 0XDEFE 0666 1.6");
106
107    ret = strtoumax(endPtr, &endPtr, 2);
108    EXPECT_EQ(ret, 6ULL) << "> strtoumax fail, errno = " << errno;
109    EXPECT_STREQ(endPtr, " 0XDEFE 0666 1.6");
110
111    ret = strtoumax(endPtr, &endPtr, 16);
112    EXPECT_EQ(ret, 57086ULL) << "> strtoumax fail, errno = " << errno;
113    EXPECT_STREQ(endPtr, " 0666 1.6");
114
115
116    ret = strtoumax(endPtr, &endPtr, 8);
117    EXPECT_EQ(ret, 438ULL) << "> strtoumax fail, errno = " << errno;
118    EXPECT_STREQ(endPtr, " 1.6");
119
120    ret = strtoumax(endPtr, &endPtr, 65);
121    EXPECT_EQ(ret, 0ULL) << "> strtoumax fail, errno = " << errno;
122    EXPECT_STREQ(endPtr, " 1.6");
123
124    ret = strtoumax(endPtr, &endPtr, 10);
125    EXPECT_EQ(ret, 1ULL) << "> strtoumax fail, errno = " << errno;
126    EXPECT_STREQ(endPtr, ".6");
127
128    ret = strtoumax(endPtr, &endPtr, 10);
129    EXPECT_EQ(ret, 0ULL) << "> strtoumax fail, errno = " << errno;
130    EXPECT_STREQ(endPtr, ".6");
131
132    char nPtr1[] = "18446744073709551615 18446744073709551616"; // 2^64-1
133    ret = strtoumax(nPtr1, &endPtr, 10);
134    EXPECT_EQ(ret, 18446744073709551615ULL) << "> strtoumax fail, errno = " << errno;
135    EXPECT_STREQ(endPtr, " 18446744073709551616");
136
137    ret = strtoumax(endPtr, &endPtr, 10);
138    EXPECT_EQ(ret, 18446744073709551615ULL) << "> strtoumax fail, errno = " << errno;
139    EXPECT_STREQ(endPtr, "");
140}
141
142/**
143 * @tc.number SUB_KERNEL_IO_OTHER_0700
144 * @tc.name   writev basic function test
145 * @tc.desc   [C- SOFTWARE -0200]
146 */
147HWTEST_F(IoTest, testWritev, Function | MediumTest | Level1)
148{
149    struct iovec iov[2];
150    char buf1[6] = {0};
151    iov[0].iov_base = buf1;
152    iov[0].iov_len = sizeof(buf1) - 1;
153
154    char buf2[6] = {0};
155    iov[1].iov_base = buf2;
156    iov[1].iov_len = sizeof(buf2) - 1;
157
158    FILE *fp = nullptr;
159    INIT_TEST_FILE(fp);
160    FOPEN_READ(fp);
161    int fd = 0;
162    FILENO(fp);
163    ssize_t ret = readv(fd, iov, 2);
164    EXPECT_EQ(ret, 10);
165    EXPECT_STREQ(buf1, "hello");
166    EXPECT_STREQ(buf2, " worl");
167    EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
168
169    FOPEN_WRITE(fp);
170    FILENO(fp);
171    ret = writev(fd, iov, 2);
172    EXPECT_EQ(ret, 10);
173    EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
174
175    FOPEN_READ(fp);
176    char str[50] = {0};
177    char *gStr = fgets(str, sizeof(str), fp);
178    EXPECT_STREQ(gStr, str);
179    EXPECT_STREQ(str, "hello worl");
180    EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
181}
182
183/**
184 * @tc.number SUB_KERNEL_IO_OTHER_0800
185 * @tc.name   pread basic function test
186 * @tc.desc   [C- SOFTWARE -0200]
187 */
188HWTEST_F(IoTest, testPread, Function | MediumTest | Level1)
189{
190    FILE *fp = nullptr;
191    FOPEN_WRITE(fp);
192    int fd = 0;
193    FILENO(fp);
194    char str[50] = "hello world";
195    ssize_t retR = pwrite(fd, str, strlen(str), 6);
196    EXPECT_EQ(retR, 11);
197    EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
198
199    FOPEN_READ(fp);
200    FILENO(fp);
201    char buf[50] = {0};
202    retR = pread(fd, buf, strlen(str), 6);
203    EXPECT_EQ(retR, 11);
204    EXPECT_STREQ(buf, "hello world");
205    EXPECT_NE(fclose(fp), -1) << "> fclose fail, errno = " << errno;
206}
207
208/**
209 * @tc.number SUB_KERNEL_IO_OTHER_0900
210 * @tc.name   strptime basic function test
211 * @tc.desc   [C- SOFTWARE -0200]
212 */
213HWTEST_F(IoTest, testStrptime, Function | MediumTest | Level1)
214{
215    struct tm tm;
216    int memRet = -1;
217    memRet = memset_s(&tm, sizeof(struct tm), 0, sizeof(struct tm));
218    EXPECT_EQ(0, memRet);
219    char *ret = strptime("2020-10-29 21:24:00abc", "%Y-%m-%d %H:%M:%S", &tm);
220    EXPECT_STREQ(ret, "abc");
221    EXPECT_EQ(tm.tm_year, 120);
222    EXPECT_EQ(tm.tm_mon, 9);
223    EXPECT_EQ(tm.tm_mday, 29);
224    EXPECT_EQ(tm.tm_hour, 21);
225    EXPECT_EQ(tm.tm_min, 24);
226
227    ret = strptime("14 Oct October 20 09:24:00 Sat Saturday 363", "%d %b %B %y %I:%M:%S %a %A %j", &tm);
228    EXPECT_STREQ(ret, "");
229    EXPECT_EQ(tm.tm_year, 120);
230    EXPECT_EQ(tm.tm_mon, 9);
231    EXPECT_EQ(tm.tm_mday, 14);
232    EXPECT_EQ(tm.tm_hour, 9);
233    EXPECT_EQ(tm.tm_wday, 6);
234    EXPECT_EQ(tm.tm_yday, 362);
235}
236
237/**
238 * @tc.number SUB_KERNEL_IO_OTHER_1000
239 * @tc.name   iconv basic function test
240 * @tc.desc   [C- SOFTWARE -0200]
241 */
242HWTEST_F(IoTest, testIconv, Function | MediumTest | Level1)
243{
244    char inBuf[50] = "hello";
245    size_t inLen = strlen(inBuf);
246    char outBuf[50] = {0};
247    size_t outLen = sizeof(outBuf);
248    char *inSrc = inBuf;
249    char *outSrc = outBuf;
250    iconv_t cd = iconv_open("UTF_32", "UTF_16");
251    size_t ret = iconv(cd, &inSrc, &inLen, &outSrc, &outLen);
252    EXPECT_EQ(ret, 4294967295U) << "iconv fail, errno = " << errno;
253    EXPECT_STREQ(inSrc, "o") << "iconv fail, errno = " << errno;
254    EXPECT_EQ(inLen, 1U) << "iconv fail, errno = " << errno;
255    EXPECT_STREQ(outSrc, "") << "iconv fail, errno = " << errno;
256    EXPECT_EQ(outLen, 42U) << "iconv fail, errno = " << errno;
257    EXPECT_STREQ(outBuf, "") << "iconv fail, errno = " << errno;
258    EXPECT_EQ(iconv_close(cd), 0) << "iconv_close fail, errn = " << errno;
259}