1 /*
2 * Copyright (c) 2024 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 <fcntl.h>
17 #include <gtest/gtest.h>
18 #include <iostream>
19 #include <memory>
20 #include <vector>
21 #include "avcodec_errors.h"
22 #include "avcodec_server.h"
23 #include "avcodec_server_manager.h"
24 #include "codec_service_stub.h"
25 #include "codeclist_service_stub.h"
26 #include "iservice_registry.h"
27 #include "mem_mgr_client.h"
28 #include "system_ability.h"
29 #include "system_ability_definition.h"
30
31 using namespace OHOS;
32 using namespace OHOS::Memory;
33 using namespace OHOS::MediaAVCodec;
34 using namespace testing;
35 using namespace testing::ext;
36
37 namespace {
38 const std::string DUMP_FILE_PATH = "/data/test/media/dump.txt";
39 constexpr int32_t INVALID_NUM = -1;
40 } // namespace
41
42 namespace {
43 class SaAVCodecUnitTest : public testing::Test {
44 public:
45 static void SetUpTestCase(void);
46 static void TearDownTestCase(void);
47 void SetUp(void);
48 void TearDown(void);
49
50 void CreateCodecServiceStub(std::shared_ptr<AVCodecServer> &server);
51
52 std::shared_ptr<SystemAbilityMock> saMock_;
53 std::shared_ptr<MemMgrClientMock> memMgrMock_;
54 std::shared_ptr<AVCodecServiceStubMock> avcodecStubMock_;
55 std::shared_ptr<CodecServiceStubMock> codecStubMock_;
56 std::shared_ptr<CodecListServiceStubMock> codeclistStubMock_;
57
58 private:
59 std::vector<std::pair<AVCodecServerManager::StubType, sptr<IRemoteObject>>> stubList_;
60 };
61
SetUpTestCase(void)62 void SaAVCodecUnitTest::SetUpTestCase(void) {}
63
TearDownTestCase(void)64 void SaAVCodecUnitTest::TearDownTestCase(void) {}
65
SetUp(void)66 void SaAVCodecUnitTest::SetUp(void)
67 {
68 saMock_ = std::make_shared<SystemAbilityMock>();
69 SystemAbility::RegisterMock(saMock_);
70 memMgrMock_ = std::make_shared<MemMgrClientMock>();
71 MemMgrClient::RegisterMock(memMgrMock_);
72 avcodecStubMock_ = std::make_shared<AVCodecServiceStubMock>();
73 AVCodecServiceStub::RegisterMock(avcodecStubMock_);
74 codecStubMock_ = std::make_shared<CodecServiceStubMock>();
75 CodecServiceStub::RegisterMock(codecStubMock_);
76 codeclistStubMock_ = std::make_shared<CodecListServiceStubMock>();
77 CodecListServiceStub::RegisterMock(codeclistStubMock_);
78 }
79
TearDown(void)80 void SaAVCodecUnitTest::TearDown(void)
81 {
82 AVCodecServerManager &manager = AVCodecServerManager::GetInstance();
83 for (auto &val : stubList_) {
84 manager.DestroyStubObject(val.first, val.second);
85 }
86 stubList_.clear();
87 saMock_ = nullptr;
88 codecStubMock_ = nullptr;
89 codeclistStubMock_ = nullptr;
90 }
91
CreateCodecServiceStub(std::shared_ptr<AVCodecServer> & server)92 void SaAVCodecUnitTest::CreateCodecServiceStub(std::shared_ptr<AVCodecServer> &server)
93 {
94 sptr<IRemoteObject> listener = sptr<IRemoteObject>(new AVCodecListenerStub());
95 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
96 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
97 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
98 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
99 EXPECT_CALL(*avcodecStubMock_, SetDeathListener(listener)).Times(1).WillOnce(Return(AVCS_ERR_OK));
100 EXPECT_CALL(*codecStubMock_, Create()).Times(AtLeast(1)).WillOnce(Return(new CodecServiceStub()));
101 EXPECT_CALL(*codecStubMock_, CodecServiceStubDtor()).Times(AtLeast(1));
102
103 server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
104 EXPECT_NE(server, nullptr);
105 sptr<IRemoteObject> codecStub = nullptr;
106 int32_t ret = server->GetSubSystemAbility(IStandardAVCodecService::AVCODEC_CODEC, listener, codecStub);
107 EXPECT_NE(codecStub, nullptr);
108 EXPECT_EQ(ret, AVCS_ERR_OK);
109 stubList_.emplace_back(AVCodecServerManager::StubType::CODEC, codecStub);
110 }
111
112 /**
113 * @tc.name: AVCodec_Server_Constructor_001
114 * @tc.desc: id and bool is matched
115 */
116 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_Constructor_001, TestSize.Level1)
117 {
118 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
119 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
120 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
121 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
122
123 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
124 EXPECT_NE(server, nullptr);
125 server = nullptr;
126 }
127
128 /**
129 * @tc.name: AVCodec_Server_Constructor_002
130 * @tc.desc: id and bool is matched
131 */
132 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_Constructor_002, TestSize.Level1)
133 {
134 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, false)).Times(1);
135 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
136 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
137 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
138
139 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, false);
140 EXPECT_NE(server, nullptr);
141 server = nullptr;
142 }
143
144 /**
145 * @tc.name: AVCodec_Server_Constructor_003
146 * @tc.desc: id and bool is matched
147 */
148 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_Constructor_003, TestSize.Level1)
149 {
150 EXPECT_CALL(*saMock_, SystemAbilityCtor(1, false)).Times(1);
151 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
152 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
153 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
154
155 auto server = std::make_shared<AVCodecServer>(1, false);
156 EXPECT_NE(server, nullptr);
157 server = nullptr;
158 }
159
160 /**
161 * @tc.name: AVCodec_Server_OnStart_001
162 * @tc.desc: 1. will once publish success
163 */
164 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_OnStart_001, TestSize.Level1)
165 {
166 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
167 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
168 EXPECT_CALL(*saMock_, AddSystemAbilityListener(MEMORY_MANAGER_SA_ID)).Times(1);
169 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
170 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
171
172 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
173 EXPECT_NE(server, nullptr);
174
175 EXPECT_CALL(*saMock_, Publish(server.get())).Times(1).WillOnce(Return(true));
176 server->OnStart();
177 server = nullptr;
178 }
179
180 /**
181 * @tc.name: AVCodec_Server_OnStart_002
182 * @tc.desc: 1. will once publish fail
183 */
184 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_OnStart_002, TestSize.Level1)
185 {
186 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
187 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
188 EXPECT_CALL(*saMock_, AddSystemAbilityListener(MEMORY_MANAGER_SA_ID)).Times(1);
189 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
190 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
191
192 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
193 EXPECT_NE(server, nullptr);
194
195 EXPECT_CALL(*saMock_, Publish(server.get())).Times(1).WillOnce(Return(false));
196 server->OnStart();
197 server = nullptr;
198 }
199
200 /**
201 * @tc.name: AVCodec_Server_OnStop_001
202 * @tc.desc: 1. will once NotifyProcessStatus = 0 success
203 */
204 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_OnStop_001, TestSize.Level1)
205 {
206 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
207 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
208 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
209 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
210
211 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
212 EXPECT_NE(server, nullptr);
213
214 server->OnStop();
215 server = nullptr;
216 }
217
218 /**
219 * @tc.name: AVCodec_Server_OnAddSystemAbility_001
220 * @tc.desc: 1. will once NotifyProcessStatus = 1 success
221 */
222 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_OnAddSystemAbility_001, TestSize.Level1)
223 {
224 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
225 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
226 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
227 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
228
229 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
230 EXPECT_NE(server, nullptr);
231
232 server->OnAddSystemAbility(MEMORY_MANAGER_SA_ID, "testId");
233 server = nullptr;
234 }
235
236 /**
237 * @tc.name: AVCodec_Server_GetSubSystemAbility_001
238 * @tc.desc: GetSubSystemAbility will twice SetDeathListener succuss
239 */
240 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_GetSubSystemAbility_001, TestSize.Level1)
241 {
242 AVCodecServerManager &manager = AVCodecServerManager::GetInstance();
243 IStandardAVCodecService::AVCodecSystemAbility subSystemId;
244 sptr<IRemoteObject> listener = sptr<IRemoteObject>(new AVCodecListenerStub());
245
246 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
247 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
248 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
249 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
250 EXPECT_CALL(*avcodecStubMock_, SetDeathListener(listener)).Times(2).WillRepeatedly(Return(AVCS_ERR_OK));
251
252 EXPECT_CALL(*codecStubMock_, Create()).Times(1).WillOnce(Return(new CodecServiceStub()));
253 EXPECT_CALL(*codecStubMock_, CodecServiceStubDtor()).Times(1);
254 EXPECT_CALL(*codeclistStubMock_, Create()).Times(1).WillOnce(Return(new CodecListServiceStub()));
255 EXPECT_CALL(*codeclistStubMock_, CodecListServiceStubDtor()).Times(1);
256 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
257 EXPECT_NE(server, nullptr);
258
259 subSystemId = IStandardAVCodecService::AVCODEC_CODEC;
260 sptr<IRemoteObject> codecStub = nullptr;
261 int32_t ret = server->GetSubSystemAbility(subSystemId, listener, codecStub);
262 EXPECT_NE(codecStub, nullptr);
263 EXPECT_EQ(ret, AVCS_ERR_OK);
264 manager.DestroyStubObject(AVCodecServerManager::StubType::CODEC, codecStub);
265
266 subSystemId = IStandardAVCodecService::AVCODEC_CODECLIST;
267 sptr<IRemoteObject> codeclistStub = nullptr;
268 ret = server->GetSubSystemAbility(subSystemId, listener, codeclistStub);
269 EXPECT_NE(codeclistStub, nullptr);
270 EXPECT_EQ(ret, AVCS_ERR_OK);
271 manager.DestroyStubObject(AVCodecServerManager::StubType::CODECLIST, codeclistStub);
272
273 server = nullptr;
274 }
275
276 /**
277 * @tc.name: AVCodec_Server_GetSubSystemAbility_002
278 * @tc.desc: GetSubSystemAbility will twice SetDeathListener fail
279 */
280 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_GetSubSystemAbility_002, TestSize.Level1)
281 {
282 IStandardAVCodecService::AVCodecSystemAbility subSystemId;
283 sptr<IRemoteObject> listener = sptr<IRemoteObject>(new AVCodecListenerStub());
284
285 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
286 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
287 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
288 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
289 EXPECT_CALL(*avcodecStubMock_, SetDeathListener(listener))
290 .Times(2)
291 .WillRepeatedly(Return(AVCS_ERR_INVALID_OPERATION));
292 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
293
294 EXPECT_CALL(*codecStubMock_, Create()).Times(1).WillOnce(Return(new CodecServiceStub()));
295 EXPECT_CALL(*codecStubMock_, CodecServiceStubDtor()).Times(1);
296 EXPECT_CALL(*codeclistStubMock_, Create()).Times(1).WillOnce(Return(new CodecListServiceStub()));
297 EXPECT_CALL(*codeclistStubMock_, CodecListServiceStubDtor()).Times(1);
298 EXPECT_NE(server, nullptr);
299
300 subSystemId = IStandardAVCodecService::AVCODEC_CODEC;
301 sptr<IRemoteObject> codecStub = nullptr;
302 int32_t ret = server->GetSubSystemAbility(subSystemId, listener, codecStub);
303 EXPECT_EQ(codecStub, nullptr);
304 EXPECT_NE(ret, AVCS_ERR_OK);
305
306 subSystemId = IStandardAVCodecService::AVCODEC_CODECLIST;
307 sptr<IRemoteObject> codeclistStub = nullptr;
308 ret = server->GetSubSystemAbility(subSystemId, listener, codeclistStub);
309 EXPECT_EQ(codeclistStub, nullptr);
310 EXPECT_NE(ret, AVCS_ERR_OK);
311 server = nullptr;
312 }
313
314 /**
315 * @tc.name: AVCodec_Server_GetSubSystemAbility_003
316 * @tc.desc: GetSubSystemAbility will twice Stub create fail
317 */
318 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_GetSubSystemAbility_003, TestSize.Level1)
319 {
320 IStandardAVCodecService::AVCodecSystemAbility subSystemId;
321 sptr<IRemoteObject> listener = sptr<IRemoteObject>(new AVCodecListenerStub());
322 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
323 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
324 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
325 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
326
327 EXPECT_CALL(*codecStubMock_, Create()).Times(1).WillOnce(nullptr);
328 EXPECT_CALL(*codeclistStubMock_, Create()).Times(1).WillOnce(nullptr);
329 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
330 EXPECT_NE(server, nullptr);
331
332 subSystemId = IStandardAVCodecService::AVCODEC_CODEC;
333 sptr<IRemoteObject> codecStub = nullptr;
334 int32_t ret = server->GetSubSystemAbility(subSystemId, listener, codecStub);
335 EXPECT_EQ(codecStub, nullptr);
336 EXPECT_NE(ret, AVCS_ERR_OK);
337
338 subSystemId = IStandardAVCodecService::AVCODEC_CODECLIST;
339 sptr<IRemoteObject> codeclistStub = nullptr;
340 ret = server->GetSubSystemAbility(subSystemId, listener, codeclistStub);
341 EXPECT_EQ(codeclistStub, nullptr);
342 EXPECT_NE(ret, AVCS_ERR_OK);
343 server = nullptr;
344 }
345
346 /**
347 * @tc.name: AVCodec_Server_GetSubSystemAbility_004
348 * @tc.desc: GetSubSystemAbility invalid subSystemId
349 */
350 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_GetSubSystemAbility_004, TestSize.Level1)
351 {
352 auto subSystemId = static_cast<IStandardAVCodecService::AVCodecSystemAbility>(INVALID_NUM);
353 sptr<IRemoteObject> listener = sptr<IRemoteObject>(new AVCodecListenerStub());
354 EXPECT_CALL(*saMock_, SystemAbilityCtor(AV_CODEC_SERVICE_ID, true)).Times(1);
355 EXPECT_CALL(*saMock_, SystemAbilityDtor()).Times(1);
356 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubCtor()).Times(1);
357 EXPECT_CALL(*avcodecStubMock_, AVCodecServiceStubDtor()).Times(1);
358
359 EXPECT_CALL(*codecStubMock_, Create()).Times(0);
360 EXPECT_CALL(*codeclistStubMock_, Create()).Times(0);
361 auto server = std::make_shared<AVCodecServer>(AV_CODEC_SERVICE_ID, true);
362 EXPECT_NE(server, nullptr);
363
364 sptr<IRemoteObject> codecStub = nullptr;
365 int32_t ret = server->GetSubSystemAbility(subSystemId, listener, codecStub);
366 EXPECT_EQ(codecStub, nullptr);
367 EXPECT_NE(ret, AVCS_ERR_OK);
368 server = nullptr;
369 }
370
371 /**
372 * @tc.name: AVCodec_Server_GetSubSystemAbility_005
373 * @tc.desc: server manager createobject
374 */
375 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_GetSubSystemAbility_005, TestSize.Level1)
376 {
377 AVCodecServerManager &manager = AVCodecServerManager::GetInstance();
378 sptr<IRemoteObject> codecStub = nullptr;
379 EXPECT_NE(manager.CreateStubObject(static_cast<AVCodecServerManager::StubType>(INVALID_NUM), codecStub),
380 AVCS_ERR_OK);
381 EXPECT_EQ(codecStub, nullptr);
382 }
383
PrintAndCloseFd(int32_t fd)384 void PrintAndCloseFd(int32_t fd)
385 {
386 int32_t fileSize = lseek(fd, 0, SEEK_END);
387 std::string str = std::string(fileSize + 1, ' ');
388 lseek(fd, 0, SEEK_SET);
389 read(fd, str.data(), fileSize);
390 std::cout << "dump str: \n==========\n" << str << "\n==========\n";
391 close(fd);
392 }
393
394 /**
395 * @tc.name: AVCodec_Server_Dump_001
396 * @tc.desc: DumpInfo will once Dump success
397 */
398 HWTEST_F(SaAVCodecUnitTest, AVCodec_Server_Dump_001, TestSize.Level1)
399 {
400 std::shared_ptr<AVCodecServer> server = nullptr;
401 std::vector<std::u16string> args = {u"All"};
402 int32_t fileFd = open(DUMP_FILE_PATH.c_str(), O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP);
403 EXPECT_CALL(*codecStubMock_, Dump).Times(AtLeast(1)).WillRepeatedly(Return(OHOS::NO_ERROR));
404
405 CreateCodecServiceStub(server);
406 EXPECT_EQ(server->Dump(fileFd, args), OHOS::NO_ERROR);
407 PrintAndCloseFd(fileFd);
408 }
409 } // namespace