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 #define private public
19 #include "hidden_start_observer_manager.h"
20 #undef private
21
22 #include "ability_record.h"
23 #include "hilog_tag_wrapper.h"
24 #include "hilog_wrapper.h"
25 #include "token.h"
26 #include "ihidden_start_observer.h"
27
28 using namespace testing::ext;
29 using namespace OHOS::AAFwk;
30
31 namespace OHOS {
32 namespace AppExecFwk {
33
34 class HiddenStartObserverManagerTest : public testing::Test {
35 public:
HiddenStartObserverManagerTest()36 HiddenStartObserverManagerTest()
37 {}
~HiddenStartObserverManagerTest()38 ~HiddenStartObserverManagerTest()
39 {}
40 static void SetUpTestCase(void);
41 static void TearDownTestCase(void);
42 void SetUp();
43 void TearDown();
44 sptr<Token> MockToken();
45 };
46
SetUpTestCase(void)47 void HiddenStartObserverManagerTest::SetUpTestCase(void) {}
48
TearDownTestCase(void)49 void HiddenStartObserverManagerTest::TearDownTestCase(void) {}
50
SetUp(void)51 void HiddenStartObserverManagerTest::SetUp(void) {}
52
TearDown(void)53 void HiddenStartObserverManagerTest::TearDown(void)
54 {}
55
MockToken()56 sptr<Token> HiddenStartObserverManagerTest::MockToken()
57 {
58 sptr<Token> token = nullptr;
59 AbilityRequest abilityRequest;
60 abilityRequest.appInfo.bundleName = "com.test.demo";
61 abilityRequest.abilityInfo.name = "MainAbility";
62 abilityRequest.abilityInfo.type = AbilityType::PAGE;
63 std::shared_ptr<AbilityRecord> abilityRecord = AbilityRecord::CreateAbilityRecord(abilityRequest);
64 if (!abilityRecord) {
65 return nullptr;
66 }
67 return abilityRecord->GetToken();
68 }
69
70 class IHiddenStartObserverMock : public IHiddenStartObserver {
71 public:
72 IHiddenStartObserverMock() = default;
73 virtual ~IHiddenStartObserverMock() = default;
74
IsHiddenStart(int32_t pid)75 bool IsHiddenStart(int32_t pid) override
76 {
77 return mockReturnValue;
78 }
79
AsObject()80 sptr<IRemoteObject> AsObject() override
81 {
82 return mockObject;
83 }
84
SetMockObject(sptr<IRemoteObject> object)85 void SetMockObject(sptr<IRemoteObject> object)
86 {
87 mockObject = object;
88 }
89
SetMockReturnValue(bool value)90 void SetMockReturnValue(bool value)
91 {
92 mockReturnValue = value;
93 }
94
UseCustomRemote(bool value)95 void UseCustomRemote(bool value)
96 {
97 useCustomRemote = value;
98 }
99
100 private:
101 sptr<IRemoteObject> mockObject = nullptr;
102 bool mockReturnValue = false;
103 bool useCustomRemote = false;
104 };
105
106 class CustomRemoteObject : public IRemoteObject {
107 public:
CustomRemoteObject(sptr<IRemoteObject> target,sptr<IHiddenStartObserverMock> observer)108 CustomRemoteObject(sptr<IRemoteObject> target, sptr<IHiddenStartObserverMock> observer)
109 : target_(target), observer_(observer) {}
110
111 virtual ~CustomRemoteObject() = default;
112
promote() const113 sptr<IRemoteObject> promote() const
114 {
115 return target_;
116 }
117 template<typename I>
GetInterfaceByType() const118 sptr<I> GetInterfaceByType() const
119 {
120 return sptr<I>(static_cast<I*>(observer_.GetRefPtr()));
121 }
CheckObjectLegality() const122 bool CheckObjectLegality() const override
123 {
124 return target_->CheckObjectLegality();
125 }
AddDeathRecipient(const sptr<DeathRecipient> & recipient)126 bool AddDeathRecipient(const sptr<DeathRecipient> &recipient) override
127 {
128 return target_->AddDeathRecipient(recipient);
129 }
RemoveDeathRecipient(const sptr<DeathRecipient> & recipient)130 bool RemoveDeathRecipient(const sptr<DeathRecipient> &recipient) override
131 {
132 return target_->RemoveDeathRecipient(recipient);
133 }
IsProxyObject() const134 bool IsProxyObject() const override
135 {
136 return target_->IsProxyObject();
137 }
GetObjectRefCount()138 int GetObjectRefCount() override
139 {
140 return target_->GetObjectRefCount();
141 }
Dump(int fd,const std::vector<std::u16string> & args)142 int Dump(int fd, const std::vector<std::u16string> &args) override
143 {
144 return target_->Dump(fd, args);
145 }
SendRequest(uint32_t code,MessageParcel & data,MessageParcel & reply,MessageOption & option)146 int SendRequest(uint32_t code, MessageParcel &data, MessageParcel &reply, MessageOption &option) override
147 {
148 return target_->SendRequest(code, data, reply, option);
149 }
150 sptr<IRemoteObject> target_;
151 sptr<IHiddenStartObserverMock> observer_;
152 };
153
154 /**
155 * @tc.number: RegisterObserver_001
156 * @tc.name: RegisterObserver
157 * @tc.desc: Test RegisterObserver with null observer.
158 */
159 HWTEST_F(HiddenStartObserverManagerTest, RegisterObserver_001, TestSize.Level1)
160 {
161 sptr<IHiddenStartObserver> observer = nullptr;
162 int32_t result = HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
163 EXPECT_EQ(result, ERR_INVALID_VALUE);
164 }
165
166 /**
167 * @tc.number: RegisterObserver_002
168 * @tc.name: RegisterObserver
169 * @tc.desc: Test RegisterObserver with valid observer.
170 */
171 HWTEST_F(HiddenStartObserverManagerTest, RegisterObserver_002, TestSize.Level1)
172 {
173 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
174 sptr<Token> token = MockToken();
175 observer->SetMockObject(token);
176 int32_t result = HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
177 EXPECT_EQ(result, ERR_OK);
178 HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
179 }
180
181 /**
182 * @tc.number: RegisterObserver_003
183 * @tc.name: RegisterObserver
184 * @tc.desc: Test RegisterObserver with observer that already exists.
185 */
186 HWTEST_F(HiddenStartObserverManagerTest, RegisterObserver_003, TestSize.Level1)
187 {
188 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
189 sptr<Token> token = MockToken();
190 observer->SetMockObject(token);
191 int32_t result1 = HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
192 EXPECT_EQ(result1, ERR_OK);
193 int32_t result2 = HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
194 EXPECT_EQ(result2, ERR_INVALID_VALUE);
195 HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
196 }
197
198 /**
199 * @tc.number: UnregisterObserver_001
200 * @tc.name: UnregisterObserver
201 * @tc.desc: Test UnregisterObserver with null observer.
202 */
203 HWTEST_F(HiddenStartObserverManagerTest, UnregisterObserver_001, TestSize.Level1)
204 {
205 sptr<IHiddenStartObserver> observer = nullptr;
206 int32_t result = HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
207 EXPECT_EQ(result, ERR_INVALID_VALUE);
208 }
209
210 /**
211 * @tc.number: UnregisterObserver_002
212 * @tc.name: UnregisterObserver
213 * @tc.desc: Test UnregisterObserver with observer that doesn't exist.
214 */
215 HWTEST_F(HiddenStartObserverManagerTest, UnregisterObserver_002, TestSize.Level1)
216 {
217 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
218 sptr<Token> token = MockToken();
219 observer->SetMockObject(token);
220 int32_t result = HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
221 EXPECT_EQ(result, ERR_INVALID_VALUE);
222 }
223
224 /**
225 * @tc.number: UnregisterObserver_003
226 * @tc.name: UnregisterObserver
227 * @tc.desc: Test UnregisterObserver with valid observer.
228 */
229 HWTEST_F(HiddenStartObserverManagerTest, UnregisterObserver_003, TestSize.Level1)
230 {
231 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
232 sptr<Token> token = MockToken();
233 observer->SetMockObject(token);
234 HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
235 int32_t result = HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
236 EXPECT_EQ(result, ERR_OK);
237 }
238
239 /**
240 * @tc.number: IsHiddenStart_001
241 * @tc.name: IsHiddenStart
242 * @tc.desc: Test IsHiddenStart with no observers.
243 */
244 HWTEST_F(HiddenStartObserverManagerTest, IsHiddenStart_001, TestSize.Level1)
245 {
246 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
247 sptr<Token> token = MockToken();
248 observer->SetMockObject(token);
249 int32_t result1 = HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
250 EXPECT_EQ(result1, ERR_OK);
251 HiddenStartObserverSet observers = HiddenStartObserverManager::GetInstance().GetObserversCopy();
252 for (auto it = observers.begin(); it != observers.end(); ++it) {
253 HiddenStartObserverManager::GetInstance().UnregisterObserver(*it);
254 }
255 bool result2 = HiddenStartObserverManager::GetInstance().IsHiddenStart(12345);
256 EXPECT_FALSE(result2);
257 }
258
259 /**
260 * @tc.number: IsHiddenStart_002
261 * @tc.name: IsHiddenStart
262 * @tc.desc: Test IsHiddenStart with one observer returning false.
263 */
264 HWTEST_F(HiddenStartObserverManagerTest, IsHiddenStart_002, TestSize.Level1)
265 {
266 HiddenStartObserverSet observers = HiddenStartObserverManager::GetInstance().GetObserversCopy();
267 for (auto it = observers.begin(); it != observers.end(); ++it) {
268 HiddenStartObserverManager::GetInstance().UnregisterObserver(*it);
269 }
270 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
271 sptr<Token> token = MockToken();
272 observer->SetMockObject(token);
273 observer->SetMockReturnValue(false);
274 HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
275 bool result = HiddenStartObserverManager::GetInstance().IsHiddenStart(12345);
276 EXPECT_FALSE(result);
277 HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
278 }
279
280 /**
281 * @tc.number: IsHiddenStart_003
282 * @tc.name: IsHiddenStart
283 * @tc.desc: Test IsHiddenStart with one observer returning true.
284 */
285 HWTEST_F(HiddenStartObserverManagerTest, IsHiddenStart_003, TestSize.Level1)
286 {
287 HiddenStartObserverSet observers = HiddenStartObserverManager::GetInstance().GetObserversCopy();
288 for (auto it = observers.begin(); it != observers.end(); ++it) {
289 HiddenStartObserverManager::GetInstance().UnregisterObserver(*it);
290 }
291 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
292 sptr<Token> token = MockToken();
293 observer->SetMockObject(token);
294 observer->SetMockReturnValue(true);
295 HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
296 bool result = HiddenStartObserverManager::GetInstance().IsHiddenStart(12345);
297 EXPECT_TRUE(result);
298 HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
299 }
300
301 /**
302 * @tc.number: ObserverExist_001
303 * @tc.name: ObserverExist
304 * @tc.desc: Test ObserverExist with null observer.
305 */
306 HWTEST_F(HiddenStartObserverManagerTest, ObserverExist_001, TestSize.Level1)
307 {
308 sptr<IRemoteBroker> observer = nullptr;
309 bool result = HiddenStartObserverManager::GetInstance().ObserverExist(observer);
310 EXPECT_FALSE(result);
311 }
312
313 /**
314 * @tc.number: ObserverExist_002
315 * @tc.name: ObserverExist
316 * @tc.desc: Test ObserverExist with observer that doesn't exist.
317 */
318 HWTEST_F(HiddenStartObserverManagerTest, ObserverExist_002, TestSize.Level1)
319 {
320 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
321 sptr<Token> token = MockToken();
322 observer->SetMockObject(token);
323 bool result = HiddenStartObserverManager::GetInstance().ObserverExist(observer);
324 EXPECT_FALSE(result);
325 }
326
327 /**
328 * @tc.number: ObserverExist_003
329 * @tc.name: ObserverExist
330 * @tc.desc: Test ObserverExist with observer that exists.
331 */
332 HWTEST_F(HiddenStartObserverManagerTest, ObserverExist_003, TestSize.Level1)
333 {
334 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
335 sptr<Token> token = MockToken();
336 observer->SetMockObject(token);
337 HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
338 bool result = HiddenStartObserverManager::GetInstance().ObserverExist(observer);
339 EXPECT_TRUE(result);
340 HiddenStartObserverManager::GetInstance().UnregisterObserver(observer);
341 }
342
343 /**
344 * @tc.number: AddObserverDeathRecipient_001
345 * @tc.name: AddObserverDeathRecipient
346 * @tc.desc: Test AddObserverDeathRecipient with null observer.
347 */
348 HWTEST_F(HiddenStartObserverManagerTest, AddObserverDeathRecipient_001, TestSize.Level1)
349 {
350 sptr<IRemoteBroker> observer = nullptr;
351 HiddenStartObserverManager::GetInstance().AddObserverDeathRecipient(observer);
352 EXPECT_EQ(HiddenStartObserverManager::GetInstance().recipientMap_.size(), 0);
353 }
354
355 /**
356 * @tc.number: AddObserverDeathRecipient_002
357 * @tc.name: AddObserverDeathRecipient
358 * @tc.desc: Test AddObserverDeathRecipient with valid observer.
359 */
360 HWTEST_F(HiddenStartObserverManagerTest, AddObserverDeathRecipient_002, TestSize.Level1)
361 {
362 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
363 sptr<Token> token = MockToken();
364 observer->SetMockObject(token);
365 HiddenStartObserverManager::GetInstance().recipientMap_.clear();
366 HiddenStartObserverManager::GetInstance().AddObserverDeathRecipient(observer);
367 EXPECT_EQ(HiddenStartObserverManager::GetInstance().recipientMap_.size(), 1);
368 HiddenStartObserverManager::GetInstance().RemoveObserverDeathRecipient(observer);
369 }
370
371 /**
372 * @tc.number: RemoveObserverDeathRecipient_001
373 * @tc.name: RemoveObserverDeathRecipient
374 * @tc.desc: Test RemoveObserverDeathRecipient with observer null.
375 */
376 HWTEST_F(HiddenStartObserverManagerTest, RemoveObserverDeathRecipient_001, TestSize.Level1)
377 {
378 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
379 sptr<Token> token = MockToken();
380 observer->SetMockObject(token);
381 HiddenStartObserverManager::GetInstance().AddObserverDeathRecipient(observer);
382 EXPECT_EQ(HiddenStartObserverManager::GetInstance().recipientMap_.size(), 1);
383 observer->SetMockObject(nullptr);
384 HiddenStartObserverManager::GetInstance().RemoveObserverDeathRecipient(observer);
385 EXPECT_EQ(HiddenStartObserverManager::GetInstance().recipientMap_.size(), 1);
386 observer->SetMockObject(token);
387 HiddenStartObserverManager::GetInstance().RemoveObserverDeathRecipient(observer);
388 EXPECT_EQ(HiddenStartObserverManager::GetInstance().recipientMap_.size(), 0);
389 }
390
391 /**
392 * @tc.number: RemoveObserverDeathRecipient_002
393 * @tc.name: RemoveObserverDeathRecipient
394 * @tc.desc: Test RemoveObserverDeathRecipient with valid observer.
395 */
396 HWTEST_F(HiddenStartObserverManagerTest, RemoveObserverDeathRecipient_002, TestSize.Level1)
397 {
398 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
399 sptr<Token> token = MockToken();
400 observer->SetMockObject(token);
401 HiddenStartObserverManager::GetInstance().AddObserverDeathRecipient(observer);
402 EXPECT_EQ(HiddenStartObserverManager::GetInstance().recipientMap_.size(), 1);
403 HiddenStartObserverManager::GetInstance().RemoveObserverDeathRecipient(observer);
404 EXPECT_EQ(HiddenStartObserverManager::GetInstance().recipientMap_.size(), 0);
405 }
406
407 /**
408 * @tc.number: OnObserverDied_001
409 * @tc.name: OnObserverDied
410 * @tc.desc: Test OnObserverDied with null remote object.
411 */
412 HWTEST_F(HiddenStartObserverManagerTest, OnObserverDied_001, TestSize.Level1)
413 {
414 sptr<IHiddenStartObserverMock> observer = new IHiddenStartObserverMock();
415 sptr<Token> token = MockToken();
416 observer->SetMockObject(token);
417 HiddenStartObserverManager::GetInstance().RegisterObserver(observer);
418 EXPECT_TRUE(HiddenStartObserverManager::GetInstance().ObserverExist(observer));
419 wptr<IRemoteObject> remote = nullptr;
420 HiddenStartObserverManager::GetInstance().OnObserverDied(remote);
421 EXPECT_TRUE(HiddenStartObserverManager::GetInstance().ObserverExist(observer));
422 }
423 } // namespace AppExecFwk
424 } // namespace OHOS