1 /*
2 * Copyright (C) 2022 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 <gtest/gtest.h>
17 #include <gmock/gmock.h>
18
19 #define private public
20 #include "buffer_object.h"
21 #include "ipc_types.h"
22 #undef private
23
24 using namespace testing::ext;
25 using namespace OHOS;
26
27 namespace {
28 constexpr uint32_t BUFF_SIZE_TEST = 128;
29 constexpr ssize_t BUFFER_WRITE_CURSOR_TEST = 8;
30 constexpr ssize_t BUFFER_READ_CURSOR_TEST = 6;
31 }
32
33 class BufferObjectUnitTest : public testing::Test {
34 public:
35 static void SetUpTestCase(void);
36 static void TearDownTestCase(void);
37 void SetUp();
38 void TearDown();
39 };
40
SetUpTestCase()41 void BufferObjectUnitTest::SetUpTestCase()
42 {
43 }
44
TearDownTestCase()45 void BufferObjectUnitTest::TearDownTestCase()
46 {
47 }
48
SetUp()49 void BufferObjectUnitTest::SetUp() {}
50
TearDown()51 void BufferObjectUnitTest::TearDown() {}
52
53 /**
54 * @tc.name: UpdateSendBufferTest001
55 * @tc.desc: Verify the UpdateSendBuffer function
56 * @tc.type: FUNC
57 */
58 HWTEST_F(BufferObjectUnitTest, UpdateSendBufferTest001, TestSize.Level1)
59 {
60 BufferObject object;
61 object.SetSendBufferWriteCursor(1);
62 object.SetSendBufferReadCursor(1);
63 object.UpdateSendBuffer(0);
64 EXPECT_EQ(object.GetSendBufferReadCursor(), 0);
65 EXPECT_EQ(object.GetSendBufferWriteCursor(), 0);
66 }
67
68 /**
69 * @tc.name: UpdateSendBufferTest002
70 * @tc.desc: Verify the UpdateSendBuffer function
71 * @tc.type: FUNC
72 */
73 HWTEST_F(BufferObjectUnitTest, UpdateSendBufferTest002, TestSize.Level1)
74 {
75 BufferObject object;
76 object.sendBuffSize_ = BUFF_SIZE_TEST;
77 object.SetSendBufferWriteCursor(BUFFER_WRITE_CURSOR_TEST);
78 object.SetSendBufferReadCursor(BUFFER_READ_CURSOR_TEST);
79 object.sendBuffer_ = new (std::nothrow) char[BUFF_SIZE_TEST]();
80 object.UpdateSendBuffer(0);
81 EXPECT_EQ(object.GetSendBufferWriteCursor(),
82 BUFFER_WRITE_CURSOR_TEST - BUFFER_READ_CURSOR_TEST);
83 }
84
85 /**
86 * @tc.name: UpdateSendBufferTest003
87 * @tc.desc: Verify the UpdateSendBuffer function
88 * @tc.type: FUNC
89 */
90 HWTEST_F(BufferObjectUnitTest, UpdateSendBufferTest003, TestSize.Level1)
91 {
92 BufferObject object;
93 object.sendBuffSize_ = BUFF_SIZE_TEST;
94 object.SetSendBufferWriteCursor(BUFFER_WRITE_CURSOR_TEST);
95 object.SetSendBufferReadCursor(BUFFER_READ_CURSOR_TEST);
96 object.UpdateSendBuffer(0);
97 EXPECT_EQ(object.GetSendBufferReadCursor(), 0);
98 EXPECT_EQ(object.GetSendBufferWriteCursor(), 0);
99 }
100
101 /**
102 * @tc.name: UpdateReceiveBufferTest001
103 * @tc.desc: Verify the UpdateReceiveBuffer function
104 * @tc.type: FUNC
105 */
106 HWTEST_F(BufferObjectUnitTest, UpdateReceiveBufferTest001, TestSize.Level1)
107 {
108 BufferObject object;
109 object.SetReceiveBufferWriteCursor(1);
110 object.SetReceiveBufferReadCursor(1);
111 object.UpdateReceiveBuffer();
112 EXPECT_EQ(object.GetReceiveBufferReadCursor(), 0);
113 EXPECT_EQ(object.GetReceiveBufferWriteCursor(), 0);
114 }
115
116 /**
117 * @tc.name: UpdateReceiveBufferTest002
118 * @tc.desc: Verify the UpdateReceiveBuffer function
119 * @tc.type: FUNC
120 */
121 HWTEST_F(BufferObjectUnitTest, UpdateReceiveBufferTest002, TestSize.Level1)
122 {
123 BufferObject object;
124 object.recvBuffSize_ = BUFF_SIZE_TEST;
125 object.SetReceiveBufferWriteCursor(BUFFER_WRITE_CURSOR_TEST);
126 object.SetReceiveBufferReadCursor(BUFFER_READ_CURSOR_TEST);
127 object.receiveBuffer_ = new (std::nothrow)char[BUFF_SIZE_TEST]();
128 object.UpdateReceiveBuffer();
129 EXPECT_EQ(object.GetReceiveBufferWriteCursor(),
130 BUFFER_WRITE_CURSOR_TEST - BUFFER_READ_CURSOR_TEST);
131 }
132
133 /**
134 * @tc.name: UpdateReceiveBufferTest003
135 * @tc.desc: Verify the UpdateReceiveBuffer function
136 * @tc.type: FUNC
137 */
138 HWTEST_F(BufferObjectUnitTest, UpdateReceiveBufferTest003, TestSize.Level1)
139 {
140 BufferObject object;
141 object.recvBuffSize_ = BUFF_SIZE_TEST;
142 object.SetReceiveBufferWriteCursor(BUFFER_WRITE_CURSOR_TEST);
143 object.SetReceiveBufferReadCursor(BUFFER_READ_CURSOR_TEST);
144 object.UpdateReceiveBuffer();
145 EXPECT_EQ(object.GetReceiveBufferReadCursor(), 0);
146 EXPECT_EQ(object.GetReceiveBufferWriteCursor(), 0);
147 }
148
149 /**
150 * @tc.name: GetSendBufferAndLockTest001
151 * @tc.desc: Verify the GetSendBufferAndLock function
152 * @tc.type: FUNC
153 */
154 HWTEST_F(BufferObjectUnitTest, GetSendBufferAndLockTest001, TestSize.Level1)
155 {
156 BufferObject object;
157 object.sendBuffSize_ = BUFF_SIZE_TEST;
158
159 char * buffer = object.GetSendBufferAndLock(SOCKET_BUFF_SIZE_USER_HUGE + 1);
160 EXPECT_EQ(buffer, nullptr);
161 }
162
163 /**
164 * @tc.name: GetSendBufferAndLockTest002
165 * @tc.desc: Verify the GetSendBufferAndLock function
166 * @tc.type: FUNC
167 */
168 HWTEST_F(BufferObjectUnitTest, GetSendBufferAndLockTest002, TestSize.Level1)
169 {
170 BufferObject object;
171 object.sendBuffSize_ = BUFF_SIZE_TEST;
172 object.sendBuffer_ = new (std::nothrow) char[BUFF_SIZE_TEST]();
173 char * buffer = object.GetSendBufferAndLock(SOCKET_BUFF_SIZE_USER_S);
174 EXPECT_NE(buffer, nullptr);
175 EXPECT_EQ(object.GetSendBufferSize(), SOCKET_BUFF_SIZE_USER_S);
176 }
177
178 /**
179 * @tc.name: GetSendBufferAndLockTest003
180 * @tc.desc: Verify the GetSendBufferAndLock function
181 * @tc.type: FUNC
182 */
183 HWTEST_F(BufferObjectUnitTest, GetSendBufferAndLockTest003, TestSize.Level1)
184 {
185 BufferObject object;
186 object.sendBuffSize_ = 0;
187 object.sendBuffer_ = new (std::nothrow) char[BUFF_SIZE_TEST]();
188 char * buffer = object.GetSendBufferAndLock(SOCKET_BUFF_SIZE_USER_S);
189 EXPECT_NE(buffer, nullptr);
190 }
191
192
193 /**
194 * @tc.name: GetReceiveBufferAndLockTest001
195 * @tc.desc: Verify the GetReceiveBufferAndLock function
196 * @tc.type: FUNC
197 */
198 HWTEST_F(BufferObjectUnitTest, GetReceiveBufferAndLockTest001, TestSize.Level1)
199 {
200 BufferObject object;
201 object.recvBuffSize_ = BUFF_SIZE_TEST;
202
203 char * buffer = object.GetReceiveBufferAndLock(SOCKET_BUFF_SIZE_USER_HUGE + 1);
204 EXPECT_EQ(buffer, nullptr);
205 }
206
207 /**
208 * @tc.name: GetReceiveBufferAndLockTest002
209 * @tc.desc: Verify the GetReceiveBufferAndLock function
210 * @tc.type: FUNC
211 */
212 HWTEST_F(BufferObjectUnitTest, GetReceiveBufferAndLockTest002, TestSize.Level1)
213 {
214 BufferObject object;
215 object.recvBuffSize_ = BUFF_SIZE_TEST;
216 object.receiveBuffer_ = new (std::nothrow) char[BUFF_SIZE_TEST]();
217 char * buffer = object.GetReceiveBufferAndLock(SOCKET_BUFF_SIZE_USER_S);
218 EXPECT_NE(buffer, nullptr);
219 EXPECT_EQ(object.GetRecvBufferSize(), SOCKET_BUFF_SIZE_USER_S);
220 }
221
222 /**
223 * @tc.name: GetReceiveBufferAndLockTest003
224 * @tc.desc: Verify the GetReceiveBufferAndLock function
225 * @tc.type: FUNC
226 */
227 HWTEST_F(BufferObjectUnitTest, GetReceiveBufferAndLockTest003, TestSize.Level1)
228 {
229 BufferObject object;
230 object.recvBuffSize_ = 0;
231 object.receiveBuffer_ = new (std::nothrow) char[BUFF_SIZE_TEST]();
232 char * buffer = object.GetReceiveBufferAndLock(SOCKET_BUFF_SIZE_USER_S);
233 EXPECT_NE(buffer, nullptr);
234 }
235
236 /**
237 * @tc.name: SetSendBufferWriteCursorTest001
238 * @tc.desc: Verify the SetSendBufferWriteCursor function
239 * @tc.type: FUNC
240 */
241 HWTEST_F(BufferObjectUnitTest, SetSendBufferWriteCursorTest001, TestSize.Level1)
242 {
243 BufferObject object;
244 object.SetSendBufferWriteCursor(1);
245 EXPECT_EQ(object.GetSendBufferWriteCursor(), 1);
246 }
247
248 /**
249 * @tc.name: SetSendBufferReadTest001
250 * @tc.desc: Verify the SetSendBufferRead function
251 * @tc.type: FUNC
252 */
253 HWTEST_F(BufferObjectUnitTest, SetSendBufferReadTest001, TestSize.Level1)
254 {
255 BufferObject object;
256 object.SetSendBufferReadCursor(1);
257 EXPECT_EQ(object.GetSendBufferReadCursor(), 1);
258 }
259
260 /**
261 * @tc.name: SetReceiveBufferWriteCursorTest001
262 * @tc.desc: Verify the SetReceiveBufferWriteCursor function
263 * @tc.type: FUNC
264 */
265 HWTEST_F(BufferObjectUnitTest, SetReceiveBufferWriteCursorTest001, TestSize.Level1)
266 {
267 BufferObject object;
268 object.SetReceiveBufferWriteCursor(1);
269 EXPECT_EQ(object.GetReceiveBufferWriteCursor(), 1);
270 }
271
272 /**
273 * @tc.name: SetReceiveBufferReadCursorTest001
274 * @tc.desc: Verify the SetReceiveBufferReadCursor function
275 * @tc.type: FUNC
276 */
277 HWTEST_F(BufferObjectUnitTest, SetReceiveBufferReadCursorTest001, TestSize.Level1)
278 {
279 BufferObject object;
280 object.SetReceiveBufferReadCursor(1);
281 EXPECT_EQ(object.GetReceiveBufferReadCursor(), 1);
282 }
283
284 /**
285 * @tc.name: GetNeedBufferSizeTest001
286 * @tc.desc: Verify the GetNeedBufferSize function
287 * @tc.type: FUNC
288 */
289 HWTEST_F(BufferObjectUnitTest, GetNeedBufferSizeTest001, TestSize.Level1)
290 {
291 BufferObject object;
292 EXPECT_EQ(object.GetNeedBufferSize(SOCKET_BUFF_SIZE_USER_S), SOCKET_BUFF_SIZE_USER_S);
293 }
294
295 /**
296 * @tc.name: GetNeedBufferSizeTest002
297 * @tc.desc: Verify the GetNeedBufferSize function
298 * @tc.type: FUNC
299 */
300 HWTEST_F(BufferObjectUnitTest, GetNeedBufferSizeTest002, TestSize.Level1)
301 {
302 BufferObject object;
303 EXPECT_EQ(object.GetNeedBufferSize(SOCKET_BUFF_SIZE_USER_M), SOCKET_BUFF_SIZE_USER_M);
304 }
305
306 /**
307 * @tc.name: GetNeedBufferSizeTest003
308 * @tc.desc: Verify the GetNeedBufferSize function
309 * @tc.type: FUNC
310 */
311 HWTEST_F(BufferObjectUnitTest, GetNeedBufferSizeTest003, TestSize.Level1)
312 {
313 BufferObject object;
314 EXPECT_EQ(object.GetNeedBufferSize(SOCKET_BUFF_SIZE_USER_L), SOCKET_BUFF_SIZE_USER_L);
315 }
316
317 /**
318 * @tc.name: GetNeedBufferSizeTest004
319 * @tc.desc: Verify the GetNeedBufferSize function
320 * @tc.type: FUNC
321 */
322 HWTEST_F(BufferObjectUnitTest, GetNeedBufferSizeTest004, TestSize.Level1)
323 {
324 BufferObject object;
325 EXPECT_EQ(object.GetNeedBufferSize(SOCKET_BUFF_SIZE_USER_HUGE), SOCKET_BUFF_SIZE_USER_HUGE);
326 }
327
328 /**
329 * @tc.name: GetNeedBufferSizeTest005
330 * @tc.desc: Verify the GetNeedBufferSize function
331 * @tc.type: FUNC
332 */
333 HWTEST_F(BufferObjectUnitTest, GetNeedBufferSizeTest005, TestSize.Level1)
334 {
335 BufferObject object;
336 uint32_t ret = 0;
337 EXPECT_EQ(object.GetNeedBufferSize(SOCKET_BUFF_SIZE_USER_HUGE + 1), ret);
338 }
339
340 /**
341 * @tc.name: deleteTest005
342 * @tc.desc: Verify the delete function
343 * @tc.type: FUNC
344 */
345 HWTEST_F(BufferObjectUnitTest, deleteTest005, TestSize.Level1)
346 {
347 BufferObject object;
348 object.sendBuffer_ = nullptr;
349 object.receiveBuffer_ = nullptr;
350
351 ASSERT_TRUE(object.sendBuffSize_ == 0);
352 }
353