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 "mc_send_manager_test.h"
17 #include "mc_command_base.h"
18 #include "mc_command_factory.h"
19
20 #include "../test_log.h"
21
22 using namespace testing;
23 using namespace testing::ext;
24
25 namespace OHOS {
26 namespace MechBodyController {
27 namespace {
28 const std::string BASEDIR = "/data/service/el1/public/database/MechBodyController";
29 const int32_t WAITTIME = 2000;
30 }
31
SetUpTestCase()32 void MechSendManagerTest::SetUpTestCase()
33 {
34 DTEST_LOG << "MechSendManagerTest::SetUpTestCase" << std::endl;
35 mkdir(BASEDIR.c_str(), (S_IRWXU | S_IRWXG | S_IROTH | S_IXOTH));
36 }
37
TearDownTestCase()38 void MechSendManagerTest::TearDownTestCase()
39 {
40 DTEST_LOG << "MechSendManagerTest::TearDownTestCase" << std::endl;
41 (void)remove(BASEDIR.c_str());
42 }
43
TearDown()44 void MechSendManagerTest::TearDown()
45 {
46 DTEST_LOG << "MechSendManagerTest::TearDown" << std::endl;
47 usleep(WAITTIME);
48 }
49
SetUp()50 void MechSendManagerTest::SetUp()
51 {
52 usleep(WAITTIME);
53 DTEST_LOG << "MechSendManagerTest::SetUp" << std::endl;
54 }
55
56 /**
57 * @tc.name: SendCommand_001
58 * @tc.desc: test SendCommand func
59 * @tc.type: FUNC
60 */
61 HWTEST_F(MechSendManagerTest, SendCommand_001, TestSize.Level3)
62 {
63 DTEST_LOG << "MechSendManagerTest SendCommand_001 begin" << std::endl;
64 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
65 std::shared_ptr<CommandBase> cmd = nullptr;
66 int32_t ret = transportSendAdapterTest->SendCommand(cmd);
67 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
68 DTEST_LOG << "MechSendManagerTest SendCommand_001 end" << std::endl;
69 }
70
71 /**
72 * @tc.name: RegisterBluetoothListener_001
73 * @tc.desc: test RegisterBluetoothListener func
74 * @tc.type: FUNC
75 */
76 HWTEST_F(MechSendManagerTest, RegisterBluetoothListener_001, TestSize.Level3)
77 {
78 DTEST_LOG << "MechSendManagerTest RegisterBluetoothListener_001 begin" << std::endl;
79 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
80 int32_t ret = transportSendAdapterTest->RegisterBluetoothListener();
81 EXPECT_EQ(ret, ERR_OK);
82 DTEST_LOG << "MechSendManagerTest RegisterBluetoothListener_001 end" << std::endl;
83 }
84
85 /**
86 * @tc.name: UnRegisterBluetoothListener_001
87 * @tc.desc: test UnRegisterBluetoothListener func
88 * @tc.type: FUNC
89 */
90 HWTEST_F(MechSendManagerTest, UnRegisterBluetoothListener_001, TestSize.Level3)
91 {
92 DTEST_LOG << "MechSendManagerTest UnRegisterBluetoothListener_001 begin" << std::endl;
93 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
94 int32_t ret = transportSendAdapterTest->UnRegisterBluetoothListener();
95 EXPECT_EQ(ret, ERR_OK);
96 DTEST_LOG << "MechSendManagerTest UnRegisterBluetoothListener_001 end" << std::endl;
97 }
98
99 /**
100 * @tc.name: GetCmdBySeqNo_001
101 * @tc.desc: test GetCmdBySeqNo func
102 * @tc.type: FUNC
103 */
104 HWTEST_F(MechSendManagerTest, GetCmdBySeqNo_001, TestSize.Level3)
105 {
106 DTEST_LOG << "MechSendManagerTest GetCmdBySeqNo_001 begin" << std::endl;
107 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
108 uint16_t seqNo = 1;
109 EXPECT_NO_FATAL_FAILURE(transportSendAdapterTest->GetCmdBySeqNo(seqNo));
110
111 CommandFactory factory;
112 std::shared_ptr<CommandBase> cmd = factory.CreateGetMechCameraTrackingLayoutCmd();
113 transportSendAdapterTest->pendingRequests_[seqNo] = cmd;
114 EXPECT_NO_FATAL_FAILURE(transportSendAdapterTest->GetCmdBySeqNo(seqNo));
115 DTEST_LOG << "MechSendManagerTest GetCmdBySeqNo_001 end" << std::endl;
116 }
117
118 /**
119 * @tc.name: ExeRespTimeoutTask_001
120 * @tc.desc: test ExeRespTimeoutTask func
121 * @tc.type: FUNC
122 */
123 HWTEST_F(MechSendManagerTest, ExeRespTimeoutTask_001, TestSize.Level3)
124 {
125 DTEST_LOG << "MechSendManagerTest ExeRespTimeoutTask_001 begin" << std::endl;
126 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
127 uint16_t seqNo = 1;
128 int32_t ret = transportSendAdapterTest->ExeRespTimeoutTask(seqNo);
129 EXPECT_EQ(ret, ERR_OK);
130
131 CommandFactory factory;
132 std::shared_ptr<CommandBase> cmd = factory.CreateGetMechCameraTrackingLayoutCmd();
133 std::shared_ptr<CommandBase> cmdNull = nullptr;
134 transportSendAdapterTest->pendingRequests_[seqNo] = cmdNull;
135 ret = transportSendAdapterTest->ExeRespTimeoutTask(seqNo);
136 EXPECT_EQ(ret, ERR_OK);
137
138 transportSendAdapterTest->pendingRequests_[seqNo] = cmd;
139 ret = transportSendAdapterTest->ExeRespTimeoutTask(seqNo);
140 EXPECT_EQ(ret, ERR_OK);
141 DTEST_LOG << "MechSendManagerTest ExeResponseTask_001 end" << std::endl;
142 }
143
144 /**
145 * @tc.name: RemoveRespTimeoutTask_001
146 * @tc.desc: test RemoveRespTimeoutTask func
147 * @tc.type: FUNC
148 */
149 HWTEST_F(MechSendManagerTest, RemoveRespTimeoutTask_001, TestSize.Level3)
150 {
151 DTEST_LOG << "MechSendManagerTest RemoveRespTimeoutTask_001 begin" << std::endl;
152 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
153 uint16_t seqNo = 1;
154 int32_t ret = transportSendAdapterTest->RemoveRespTimeoutTask(seqNo);
155 EXPECT_EQ(ret, ERR_OK);
156
157 CommandFactory factory;
158 std::shared_ptr<CommandBase> cmd = factory.CreateGetMechCameraTrackingLayoutCmd();
159 transportSendAdapterTest->pendingRequests_[seqNo] = cmd;
160 ret = transportSendAdapterTest->RemoveRespTimeoutTask(seqNo);
161 EXPECT_EQ(ret, ERR_OK);
162 DTEST_LOG << "MechSendManagerTest RemoveRespTimeoutTask_001 end" << std::endl;
163 }
164
165 /**
166 * @tc.name: BleReceviceListenerImpl_OnReceive_001
167 * @tc.desc: test BleReceviceListenerImpl_OnReceive func
168 * @tc.type: FUNC
169 */
170 HWTEST_F(MechSendManagerTest, BleReceviceListenerImpl_OnReceive_001, TestSize.Level3)
171 {
172 DTEST_LOG << "MechSendManagerTest BleReceviceListenerImpl_OnReceive_001 begin" << std::endl;
173 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
174 auto receviceListener = std::make_shared<BleReceviceListenerImpl>(transportSendAdapterTest);
175 uint8_t static_data[] = {1, 2, 3, 4};
176 uint8_t *data = static_data;
177 uint32_t dataLen = 4;
178 int32_t ret = receviceListener->OnReceive(data, dataLen);
179 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
180 DTEST_LOG << "MechSendManagerTest BleReceviceListenerImpl_OnReceive_001 end" << std::endl;
181 }
182
183 /**
184 * @tc.name: BleReceviceListenerImpl_OnReceive_002
185 * @tc.desc: test BleReceviceListenerImpl_OnReceive func
186 * @tc.type: FUNC
187 */
188 HWTEST_F(MechSendManagerTest, BleReceviceListenerImpl_OnReceive_002, TestSize.Level3)
189 {
190 DTEST_LOG << "MechSendManagerTest BleReceviceListenerImpl_OnReceive_002 begin" << std::endl;
191 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
192 auto receviceListener = std::make_shared<BleReceviceListenerImpl>(transportSendAdapterTest);
193 uint8_t *data = nullptr;
194 uint32_t dataLen = 4;
195 int32_t ret = receviceListener->OnReceive(data, dataLen);
196 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
197 DTEST_LOG << "MechSendManagerTest BleReceviceListenerImpl_OnReceive_002 end" << std::endl;
198 }
199
200 /**
201 * @tc.name: TransportSendAdapter_OnReceive_001
202 * @tc.desc: test TransportSendAdapter_OnReceive func
203 * @tc.type: FUNC
204 */
205 HWTEST_F(MechSendManagerTest, TransportSendAdapter_OnReceive_001, TestSize.Level3)
206 {
207 DTEST_LOG << "MechSendManagerTest TransportSendAdapter_OnReceive_001 begin" << std::endl;
208 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
209 bool isAck = true;
210 uint16_t seqNo = 1;
211 uint32_t dataLen = 4;
212 std::shared_ptr<MechDataBuffer> data = std::make_shared<MechDataBuffer>(static_cast<size_t>(dataLen));
213 int32_t ret = transportSendAdapterTest->OnReceive(isAck, seqNo, data);
214 EXPECT_EQ(ret, ERR_OK);
215
216 isAck = false;
217 ret = transportSendAdapterTest->OnReceive(isAck, seqNo, data);
218 EXPECT_EQ(ret, ERR_OK);
219 DTEST_LOG << "MechSendManagerTest TransportSendAdapter_OnReceive_001 end" << std::endl;
220 }
221
222 /**
223 * @tc.name: CreateResponseSeqNo_001
224 * @tc.desc: test CreateResponseSeqNo func
225 * @tc.type: FUNC
226 */
227 HWTEST_F(MechSendManagerTest, CreateResponseSeqNo_001, TestSize.Level3)
228 {
229 DTEST_LOG << "MechSendManagerTest CreateResponseSeqNo_001 begin" << std::endl;
230 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
231 transportSendAdapterTest->lastSeqNo_ = UINT16_MAX;
232 int32_t ret = transportSendAdapterTest->CreateResponseSeqNo();
233 EXPECT_EQ(ret, ERR_OK);
234 DTEST_LOG << "MechSendManagerTest PushResponseTask_001 end" << std::endl;
235 }
236
237 /**
238 * @tc.name: PushResponseTask_001
239 * @tc.desc: test PushResponseTask func
240 * @tc.type: FUNC
241 */
242 HWTEST_F(MechSendManagerTest, PushResponseTask_001, TestSize.Level3)
243 {
244 DTEST_LOG << "MechSendManagerTest PushResponseTask_001 begin" << std::endl;
245 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
246 uint16_t seqNo = 1;
247 int32_t ret = transportSendAdapterTest->PushResponseTask(nullptr, seqNo);
248 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
249 DTEST_LOG << "MechSendManagerTest PushResponseTask_001 end" << std::endl;
250 }
251
252 /**
253 * @tc.name: PushResponseTask_002
254 * @tc.desc: test PushResponseTask func
255 * @tc.type: FUNC
256 */
257 HWTEST_F(MechSendManagerTest, PushResponseTask_002, TestSize.Level3)
258 {
259 DTEST_LOG << "MechSendManagerTest PushResponseTask_002 begin" << std::endl;
260 std::shared_ptr<TransportSendAdapter> transportSendAdapterTest = std::make_shared<TransportSendAdapter>();
261 CommandFactory factory;
262 std::shared_ptr<CommandBase> cmd = factory.CreateGetMechCameraTrackingLayoutCmd();
263 uint16_t seqNo = 1;
264 transportSendAdapterTest->recvEventHandler_ = nullptr;
265 transportSendAdapterTest->RegisterBluetoothListener();
266 int32_t ret = transportSendAdapterTest->PushResponseTask(cmd, seqNo);
267 EXPECT_EQ(ret, INVALID_PARAMETERS_ERR);
268 DTEST_LOG << "MechSendManagerTest PushResponseTask_002 end" << std::endl;
269 }
270 }
271 }
272