1 /*
2 * Copyright (C) 2022-2023 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 "buffer_test.h"
17
18 #include "buffer.h"
19 #include "securec.h"
20
21 namespace OHOS {
22 namespace UserIam {
23 namespace UserAuth {
24 using namespace testing;
25 using namespace testing::ext;
26 namespace {
27 constexpr uint32_t MAX_BUFFER_SIZE = 512000 + 1;
28 constexpr uint32_t BUFFER_LEN_1 = 1;
29 constexpr uint32_t BUFFER_LEN_2 = 2;
30 constexpr uint32_t BUFFER_LEN_4 = 4;
31 constexpr uint32_t BUFFER_LEN_5 = 5;
32 constexpr uint32_t BUFFER_LEN_6 = 6;
33 } // namespace
34
SetUpTestCase()35 void BufferTest::SetUpTestCase()
36 {
37 }
38
TearDownTestCase()39 void BufferTest::TearDownTestCase()
40 {
41 }
42
SetUp()43 void BufferTest::SetUp()
44 {
45 }
46
TearDown()47 void BufferTest::TearDown()
48 {
49 }
50
51 /**
52 * @tc.name: CreateBufferBySize test
53 * @tc.desc: verify CreateBufferBySize
54 * @tc.type: FUNC
55 * @tc.require: #I64XCB
56 */
57 HWTEST_F(BufferTest, CreateBufferBySize_test, TestSize.Level0)
58 {
59 Buffer *buffer1 = CreateBufferBySize(0);
60 EXPECT_EQ(buffer1, nullptr);
61 bool result = IsBufferValid(buffer1);
62 EXPECT_EQ(result, false);
63
64 Buffer *buffer2 = CreateBufferBySize(MAX_BUFFER_SIZE);
65 EXPECT_EQ(buffer2, nullptr);
66 result = IsBufferValid(buffer2);
67 EXPECT_EQ(result, false);
68
69 Buffer *buffer3 = CreateBufferBySize(5);
70 EXPECT_NE(buffer3, nullptr);
71 result = IsBufferValid(buffer3);
72 EXPECT_EQ(result, true);
73 DestoryBuffer(buffer3);
74 }
75
76 HWTEST_F(BufferTest, GetTmpBuffer_test, TestSize.Level0)
77 {
78 Buffer buffer1 = GetTmpBuffer(nullptr, 0, 0);
79 Buffer buffer2 = {
80 .buf = nullptr,
81 .contentSize = 0,
82 .maxSize = 0,
83 };
84 EXPECT_EQ(memcmp(&buffer1, &buffer2, sizeof(Buffer)), 0);
85 }
86
87 /**
88 * @tc.name: CreateBufferByData test
89 * @tc.desc: verify CreateBufferByData
90 * @tc.type: FUNC
91 * @tc.require: #I64XCB
92 */
93 HWTEST_F(BufferTest, CreateBufferByData_test, TestSize.Level0)
94 {
95 Buffer *buffer1 = CreateBufferByData(nullptr, 0);
96 EXPECT_EQ(buffer1, nullptr);
97 bool result = IsBufferValid(buffer1);
98 EXPECT_EQ(result, false);
99
100 Buffer *buffer2 = CreateBufferByData(nullptr, MAX_BUFFER_SIZE);
101 EXPECT_EQ(buffer2, nullptr);
102 result = IsBufferValid(buffer2);
103 EXPECT_EQ(result, false);
104
105 Buffer *data = CreateBufferBySize(BUFFER_LEN_5);
106 EXPECT_NE(data, nullptr);
107 (void)memset_s(data->buf, data->maxSize, BUFFER_LEN_1, data->maxSize);
108 data->contentSize = data->maxSize;
109
110 Buffer *buffer3 = CreateBufferByData(data->buf, 0);
111 EXPECT_EQ(buffer3, nullptr);
112 result = IsBufferValid(buffer3);
113 EXPECT_EQ(result, false);
114
115 Buffer *buffer4 = CreateBufferByData(data->buf, MAX_BUFFER_SIZE);
116 EXPECT_EQ(buffer4, nullptr);
117 result = IsBufferValid(buffer4);
118 EXPECT_EQ(result, false);
119
120 Buffer *buffer5 = CreateBufferByData(data->buf, data->contentSize);
121 EXPECT_NE(buffer5, nullptr);
122 result = IsBufferValid(buffer5);
123 EXPECT_EQ(result, true);
124
125 DestoryBuffer(buffer5);
126 DestoryBuffer(data);
127 }
128
129 /**
130 * @tc.name: CheckBufferWithSize test
131 * @tc.desc: verify CheckBufferWithSize
132 * @tc.type: FUNC
133 * @tc.require: #I64XCB
134 */
135 HWTEST_F(BufferTest, CheckBufferWithSize_test, TestSize.Level0)
136 {
137 Buffer *buffer1 = CreateBufferByData(nullptr, 0);
138 EXPECT_EQ(buffer1, nullptr);
139
140 bool result = CheckBufferWithSize(buffer1, BUFFER_LEN_5);
141 EXPECT_EQ(result, false);
142
143 Buffer *data = CreateBufferBySize(BUFFER_LEN_5);
144 EXPECT_NE(data, nullptr);
145 (void)memset_s(data->buf, data->maxSize, BUFFER_LEN_1, data->maxSize);
146 data->contentSize = data->maxSize;
147
148 result = CheckBufferWithSize(data, BUFFER_LEN_4);
149 EXPECT_EQ(result, false);
150
151 result = CheckBufferWithSize(data, BUFFER_LEN_5);
152 EXPECT_EQ(result, true);
153
154 DestoryBuffer(data);
155 }
156
157 /**
158 * @tc.name: CopyBuffer test
159 * @tc.desc: verify CopyBuffer
160 * @tc.type: FUNC
161 * @tc.require: #I64XCB
162 */
163 HWTEST_F(BufferTest, CopyBuffer_test, TestSize.Level0)
164 {
165 Buffer *buffer0 = CreateBufferBySize(0);
166 EXPECT_EQ(buffer0, nullptr);
167 Buffer *result = CopyBuffer(buffer0);
168 EXPECT_EQ(result, nullptr);
169
170 Buffer *buffer2 = CreateBufferBySize(BUFFER_LEN_5);
171 EXPECT_NE(buffer2, nullptr);
172 result = CopyBuffer(buffer2);
173 EXPECT_NE(result, nullptr);
174 DestoryBuffer(buffer2);
175 DestoryBuffer(result);
176 }
177
178 /**
179 * @tc.name: CompareBuffer test
180 * @tc.desc: verify CompareBuffer
181 * @tc.type: FUNC
182 * @tc.require: #I64XCB
183 */
184 HWTEST_F(BufferTest, CompareBuffer_test, TestSize.Level0)
185 {
186 bool result = CompareBuffer(nullptr, nullptr);
187 EXPECT_EQ(result, false);
188
189 Buffer *buffer1 = CreateBufferBySize(BUFFER_LEN_5);
190 EXPECT_NE(buffer1, nullptr);
191 buffer1->contentSize = buffer1->maxSize;
192 Buffer *buffer2 = CreateBufferBySize(BUFFER_LEN_6);
193 EXPECT_NE(buffer2, nullptr);
194 buffer2->contentSize = buffer2->maxSize;
195 result = CompareBuffer(buffer1, buffer2);
196 EXPECT_EQ(result, false);
197 DestoryBuffer(buffer1);
198 DestoryBuffer(buffer2);
199
200 Buffer *buffer3 = CreateBufferBySize(BUFFER_LEN_5);
201 EXPECT_NE(buffer3, nullptr);
202 (void)memset_s(buffer3->buf, buffer3->maxSize, BUFFER_LEN_1, buffer3->maxSize);
203 buffer3->contentSize = buffer3->maxSize;
204
205 Buffer *buffer4 = CreateBufferBySize(BUFFER_LEN_6);
206 EXPECT_NE(buffer4, nullptr);
207 (void)memset_s(buffer4->buf, buffer4->maxSize, BUFFER_LEN_2, buffer4->maxSize);
208 buffer4->contentSize = buffer4->maxSize;
209 result = CompareBuffer(buffer3, buffer4);
210 EXPECT_EQ(result, false);
211 DestoryBuffer(buffer3);
212 DestoryBuffer(buffer4);
213
214 Buffer *buffer5 = CreateBufferBySize(5);
215 EXPECT_NE(buffer5, nullptr);
216 (void)memset_s(buffer5->buf, buffer5->maxSize, BUFFER_LEN_1, buffer5->maxSize);
217 buffer5->contentSize = buffer5->maxSize;
218 result = CompareBuffer(buffer5, buffer5);
219 EXPECT_EQ(result, true);
220 DestoryBuffer(buffer5);
221 }
222
223 /**
224 * @tc.name: GetBufferData test
225 * @tc.desc: verify GetBufferData
226 * @tc.type: FUNC
227 * @tc.require: #I64XCB
228 */
229 HWTEST_F(BufferTest, GetBufferData_test, TestSize.Level0)
230 {
231 Buffer *buffer1 = CreateBufferBySize(BUFFER_LEN_5);
232 EXPECT_NE(buffer1, nullptr);
233 (void)memset_s(buffer1->buf, buffer1->maxSize, BUFFER_LEN_1, buffer1->maxSize);
234 buffer1->contentSize = buffer1->maxSize;
235
236 uint32_t result = GetBufferData(nullptr, nullptr, nullptr);
237 EXPECT_EQ(result, RESULT_BAD_PARAM);
238
239 result = GetBufferData(buffer1, nullptr, nullptr);
240 EXPECT_EQ(result, RESULT_BAD_PARAM);
241
242 Buffer *res = CreateBufferBySize(BUFFER_LEN_4);
243 EXPECT_NE(res, nullptr);
244 res->contentSize = res->maxSize;
245
246 result = GetBufferData(buffer1, res->buf, &(res->contentSize));
247 EXPECT_EQ(result, RESULT_BAD_COPY);
248 DestoryBuffer(res);
249
250 Buffer *res1 = CreateBufferBySize(BUFFER_LEN_5);
251 EXPECT_NE(res1, nullptr);
252 res1->contentSize = res1->maxSize;
253
254 result = GetBufferData(buffer1, res1->buf, &(res1->contentSize));
255 EXPECT_EQ(result, RESULT_SUCCESS);
256 DestoryBuffer(res1);
257
258 DestoryBuffer(buffer1);
259 }
260 } // namespace UserAuth
261 } // namespace UserIam
262 } // namespace OHOS
263