1 /*
2 * Copyright (c) 2025 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
18 #include "mc_data_buffer_test.h"
19
20 #include "mechbody_controller_log.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace MechBodyController {
SetUpTestCase()27 void MechDataBufferTest::SetUpTestCase()
28 {
29 }
30
TearDownTestCase()31 void MechDataBufferTest::TearDownTestCase()
32 {
33 }
34
SetUp()35 void MechDataBufferTest::SetUp()
36 {
37 }
38
TearDown()39 void MechDataBufferTest::TearDown()
40 {
41 }
42
43 /**
44 * @tc.name : Constructor_ShouldAllocateMemory_WhenCapacityIsValid
45 * @tc.number: MechDataBuffer_Test_001
46 * @tc.desc : Test constructor to ensure memory is allocated when capacity is valid
47 */
48 HWTEST_F(MechDataBufferTest, Constructor_ShouldAllocateMemory_WhenCapacityIsValid, TestSize.Level1)
49 {
50 size_t capacity = 100;
51 MechDataBuffer buffer(capacity);
52 EXPECT_NE(buffer.Data(), nullptr);
53 EXPECT_EQ(buffer.Capacity(), capacity);
54 }
55
56 /**
57 * @tc.name : Constructor_ShouldNotAllocateMemory_WhenCapacityIsZero
58 * @tc.number: MechDataBuffer_Test_002
59 * @tc.desc : Test constructor to ensure memory is not allocated when capacity is zero
60 */
61 HWTEST_F(MechDataBufferTest, Constructor_ShouldNotAllocateMemory_WhenCapacityIsZero, TestSize.Level1)
62 {
63 size_t capacity = 0;
64 MechDataBuffer buffer(capacity);
65 EXPECT_EQ(buffer.Data(), nullptr);
66 EXPECT_EQ(buffer.Capacity(), 0);
67 }
68
69 /**
70 * @tc.name : Constructor_ShouldNotAllocateMemory_WhenCapacityIsGreaterThanMax
71 * @tc.number: MechDataBuffer_Test_003
72 * @tc.desc : Test constructor to ensure memory is not allocated when capacity is greater than MECH_MAX_BUFFER_SIZE
73 */
74 HWTEST_F(MechDataBufferTest, Constructor_ShouldNotAllocateMemory_WhenCapacityIsGreaterThanMax, TestSize.Level1)
75 {
76 size_t capacity = MechDataBuffer::MECH_MAX_BUFFER_SIZE + 1;
77 MechDataBuffer buffer(capacity);
78 EXPECT_EQ(buffer.Data(), nullptr);
79 EXPECT_EQ(buffer.Capacity(), 0);
80 }
81
82 /**
83 * @tc.name : Destructor_ShouldFreeMemory_WhenBufferIsNotNull
84 * @tc.number: MechDataBuffer_Test_004
85 * @tc.desc : Test destructor to ensure memory is freed when buffer is not null
86 */
87 HWTEST_F(MechDataBufferTest, Destructor_ShouldFreeMemory_WhenBufferIsNotNull, TestSize.Level1)
88 {
89 size_t capacity = 100;
90 MechDataBuffer* buffer = new MechDataBuffer(capacity);
91 delete buffer;
92 EXPECT_EQ(buffer->Data(), nullptr);
93 }
94
95 /**
96 * @tc.name : SetRange_ShouldSetRange_WhenParametersAreValid
97 * @tc.number: MechDataBuffer_Test_005
98 * @tc.desc : Test SetRange to ensure range is set when parameters are valid
99 */
100 HWTEST_F(MechDataBufferTest, SetRange_ShouldSetRange_WhenParametersAreValid, TestSize.Level1)
101 {
102 size_t capacity = 100;
103 MechDataBuffer buffer(capacity);
104 size_t offset = 10;
105 size_t size = 20;
106 EXPECT_EQ(buffer.SetRange(offset, size), ERR_OK);
107 EXPECT_EQ(buffer.Offset(), offset);
108 EXPECT_EQ(buffer.Size(), size);
109 }
110
111 /**
112 * @tc.name : SetRange_ShouldReturnError_WhenParametersAreInvalid
113 * @tc.number: MechDataBuffer_Test_006
114 * @tc.desc : Test SetRange to ensure error is returned when parameters are invalid
115 */
116 HWTEST_F(MechDataBufferTest, SetRange_ShouldReturnError_WhenParametersAreInvalid, TestSize.Level1)
117 {
118 size_t capacity = 100;
119 MechDataBuffer buffer(capacity);
120 size_t offset = 110;
121 size_t size = 20;
122 EXPECT_EQ(buffer.SetRange(offset, size), INVALID_PARAMETERS_ERR);
123
124 size_t offsetInvaild = 90;
125 size_t sizeInvaild = 20;
126 EXPECT_EQ(buffer.SetRange(offsetInvaild, sizeInvaild), INVALID_PARAMETERS_ERR);
127 }
128
129 /**
130 * @tc.name : AppendUint8_ShouldAppendData_WhenBufferHasEnoughSpace
131 * @tc.number: MechDataBuffer_Test_007
132 * @tc.desc : Test AppendUint8 to ensure data is appended when buffer has enough space
133 */
134 HWTEST_F(MechDataBufferTest, AppendUint8_ShouldAppendData_WhenBufferHasEnoughSpace, TestSize.Level1)
135 {
136 size_t capacity = 100;
137 MechDataBuffer buffer(capacity);
138 uint8_t value = 0x55;
139 EXPECT_EQ(buffer.AppendUint8(value), ERR_OK);
140 EXPECT_EQ(buffer.Size(), sizeof(value));
141 }
142
143 /**
144 * @tc.name : AppendUint8_ShouldReturnError_WhenBufferDoesNotHaveEnoughSpace
145 * @tc.number: MechDataBuffer_Test_008
146 * @tc.desc : Test AppendUint8 to ensure error is returned when buffer does not have enough space
147 */
148 HWTEST_F(MechDataBufferTest, AppendUint8_ShouldReturnError_WhenBufferDoesNotHaveEnoughSpace, TestSize.Level1)
149 {
150 size_t capacity = 0;
151 MechDataBuffer buffer(capacity);
152 uint8_t value = 0x55;
153 EXPECT_EQ(buffer.AppendUint8(value), INVALID_PARAMETERS_ERR);
154 }
155
156 /**
157 * @tc.name : ReadUint8_ShouldReadData_WhenParametersAreValid
158 * @tc.number: MechDataBuffer_Test_009
159 * @tc.desc : Test ReadUint8 to ensure data is read when parameters are valid
160 */
161 HWTEST_F(MechDataBufferTest, ReadUint8_ShouldReadData_WhenParametersAreValid, TestSize.Level1)
162 {
163 size_t capacity = 100;
164 MechDataBuffer buffer(capacity);
165 uint8_t value = 0x55;
166 buffer.AppendUint8(value);
167 uint8_t readValue = 0;
168 EXPECT_EQ(buffer.ReadUint8(0, readValue), ERR_OK);
169 EXPECT_EQ(readValue, value);
170 }
171
172 /**
173 * @tc.name : ReadUint8_ShouldReturnError_WhenParametersAreInvalid
174 * @tc.number: MechDataBuffer_Test_010
175 * @tc.desc : Test ReadUint8 to ensure error is returned when parameters are invalid
176 */
177 HWTEST_F(MechDataBufferTest, ReadUint8_ShouldReturnError_WhenParametersAreInvalid, TestSize.Level1)
178 {
179 size_t capacity = 100;
180 MechDataBuffer buffer(capacity);
181 uint8_t readValue = 0;
182 EXPECT_EQ(buffer.ReadUint8(100, readValue), INVALID_PARAMETERS_ERR);
183 }
184
185 /**
186 * @tc.name : ReadUint32_ShouldReadData_WhenParametersAreValid
187 * @tc.number: MechDataBuffer_Test_011
188 * @tc.desc : Test ReadUint32 to ensure data is read when parameters are valid
189 */
190 HWTEST_F(MechDataBufferTest, ReadUint32_ShouldReadData_WhenParametersAreValid, TestSize.Level1)
191 {
192 size_t capacity = 100;
193 MechDataBuffer buffer(capacity);
194 uint32_t value = 0x55001232;
195 buffer.AppendUint32(value);
196 uint32_t readValue = 0;
197 EXPECT_EQ(buffer.ReadUint32(0, readValue), ERR_OK);
198 EXPECT_EQ(readValue, value);
199 }
200
201 /**
202 * @tc.name : ReadUint32_ShouldReturnError_WhenParametersAreInvalid
203 * @tc.number: MechDataBuffer_Test_012
204 * @tc.desc : Test ReadUint32 to ensure error is returned when parameters are invalid
205 */
206 HWTEST_F(MechDataBufferTest, ReadUint32_ShouldReturnError_WhenParametersAreInvalid, TestSize.Level1)
207 {
208 size_t capacity = 100;
209 MechDataBuffer buffer(capacity);
210 uint32_t readValue = 0;
211 EXPECT_EQ(buffer.ReadUint32(100, readValue), INVALID_PARAMETERS_ERR);
212 }
213
214 /**
215 * @tc.name : ReadUint64_ShouldReadData_WhenParametersAreValid
216 * @tc.number: MechDataBuffer_Test_013
217 * @tc.desc : Test ReadUint64 to ensure data is read when parameters are valid
218 */
219 HWTEST_F(MechDataBufferTest, ReadUint64_ShouldReadData_WhenParametersAreValid, TestSize.Level1)
220 {
221 size_t capacity = 100;
222 MechDataBuffer buffer(capacity);
223 uint64_t value = 0x5500123255001232;
224 buffer.AppendUint64(value);
225 uint64_t readValue = 0;
226 EXPECT_EQ(buffer.ReadUint64(0, readValue), ERR_OK);
227 EXPECT_EQ(readValue, value);
228 }
229
230 /**
231 * @tc.name : ReadUint64_ShouldReturnError_WhenParametersAreInvalid
232 * @tc.number: MechDataBuffer_Test_014
233 * @tc.desc : Test ReadUint64 to ensure error is returned when parameters are invalid
234 */
235 HWTEST_F(MechDataBufferTest, ReadUint64_ShouldReturnError_WhenParametersAreInvalid, TestSize.Level1)
236 {
237 size_t capacity = 100;
238 MechDataBuffer buffer(capacity);
239 uint64_t readValue = 0;
240 EXPECT_EQ(buffer.ReadUint64(100, readValue), INVALID_PARAMETERS_ERR);
241 }
242 } // namespace MechBodyController
243 } // namespace OHOS
244