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