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 #include <regex>
18 #include <bundle_mgr_interface.h>
19 #include <bundlemgr/launcher_service.h>
20
21 #include "context.h"
22 #include "interfaces/include/ws_common.h"
23 #include "session_manager/include/rdb/starting_window_rdb_manager.h"
24 #include "session_manager/include/scene_session_manager.h"
25 #include "window_manager_hilog.h"
26
27 using namespace testing;
28 using namespace testing::ext;
29
30 namespace OHOS {
31 namespace Rosen {
32 namespace {
33 const std::string TEST_RDB_PATH = "/data/test/";
34 const std::string TEST_INVALID_PATH = "";
35 const std::string TEST_RDB_NAME = "starting_window_config_test.db";
36 const uint32_t WAIT_SLEEP_TIME = 200000;
37 std::string g_logMsg;
RdbLogCallback(const LogType type,const LogLevel level,const unsigned int domain,const char * tag,const char * msg)38 void RdbLogCallback(const LogType type, const LogLevel level, const unsigned int domain, const char* tag,
39 const char* msg)
40 {
41 g_logMsg = msg;
42 }
43 } // namespace
44
45 class WindowPatternStartingWindowTest : public testing::Test {
46 public:
47 static void SetUpTestCase();
48 static void TearDownTestCase();
49 void SetUp() override;
50 void TearDown() override;
51
52 static sptr<SceneSessionManager> ssm_;
53
54 private:
55 void InitTestStartingWindowRdb();
56 };
57
58 sptr<SceneSessionManager> WindowPatternStartingWindowTest::ssm_ = nullptr;
59
SetUpTestCase()60 void WindowPatternStartingWindowTest::SetUpTestCase()
61 {
62 ssm_ = new SceneSessionManager();
63 ssm_->Init();
64 }
65
TearDownTestCase()66 void WindowPatternStartingWindowTest::TearDownTestCase()
67 {
68 ssm_ = nullptr;
69 NativeRdb::RdbHelper::DeleteRdbStore(TEST_RDB_PATH + TEST_RDB_NAME);
70 }
71
SetUp()72 void WindowPatternStartingWindowTest::SetUp()
73 {
74 }
75
TearDown()76 void WindowPatternStartingWindowTest::TearDown()
77 {
78 }
79
InitTestStartingWindowRdb()80 void WindowPatternStartingWindowTest::InitTestStartingWindowRdb()
81 {
82 NativeRdb::RdbHelper::DeleteRdbStore(TEST_RDB_PATH + TEST_RDB_NAME);
83 WmsRdbConfig config;
84 config.dbName = TEST_RDB_NAME;
85 config.dbPath = TEST_RDB_PATH;
86 ssm_->startingWindowRdbMgr_ = std::make_unique<StartingWindowRdbManager>(config);
87 }
88
89 namespace {
90 /**
91 * @tc.name: GetStartupPage01
92 * @tc.desc: GetStartupPage from want
93 * @tc.type: FUNC
94 */
95 HWTEST_F(WindowPatternStartingWindowTest, GetStartupPage01, TestSize.Level1)
96 {
97 ASSERT_NE(ssm_, nullptr);
98 SessionInfo sessionInfo;
99 StartingWindowInfo startingWindowInfo;
100 startingWindowInfo.iconPathEarlyVersion_ = "default";
101 ssm_->GetStartupPage(sessionInfo, startingWindowInfo);
102 ASSERT_EQ(startingWindowInfo.iconPathEarlyVersion_, "default");
103 sptr<AppExecFwk::IBundleMgr> tempBundleMgr = ssm_->bundleMgr_;
104 ssm_->bundleMgr_ = nullptr;
105 ssm_->GetStartupPage(sessionInfo, startingWindowInfo);
106 ssm_->bundleMgr_ = tempBundleMgr;
107 ASSERT_EQ(startingWindowInfo.iconPathEarlyVersion_, "default");
108 sessionInfo.want = std::make_shared<AAFwk::Want>();
109 ASSERT_NE(sessionInfo.want, nullptr);
110 const std::string pathFromDesk = "pathFromDesk";
111 sessionInfo.want->SetParam("realAppIcon", pathFromDesk);
112 ssm_->GetStartupPage(sessionInfo, startingWindowInfo);
113 ASSERT_EQ(startingWindowInfo.iconPathEarlyVersion_, "pathFromDesk");
114 }
115
116 /**
117 * @tc.name: GetStartupPage02
118 * @tc.desc: GetStartupPage from cache
119 * @tc.type: FUNC
120 */
121 HWTEST_F(WindowPatternStartingWindowTest, GetStartupPage02, TestSize.Level1)
122 {
123 ASSERT_NE(ssm_, nullptr);
124 SessionInfo sessionInfo;
125 sessionInfo.moduleName_ = "moduleName";
126 sessionInfo.abilityName_ = "abilityName";
127 sessionInfo.bundleName_ = "bundleName";
128 StartingWindowInfo cachedInfo;
129 cachedInfo.iconPathEarlyVersion_ = "pathFromCache";
130 ssm_->startingWindowMap_.clear();
131 auto key = sessionInfo.moduleName_ + sessionInfo.abilityName_;
132 std::map<std::string, StartingWindowInfo> startingWindowInfoMap{ { key, cachedInfo } };
133 ssm_->startingWindowMap_.insert({ sessionInfo.bundleName_, startingWindowInfoMap });
134 StartingWindowInfo outInfo;
135 outInfo.iconPathEarlyVersion_ = "default";
136 ssm_->GetStartupPage(sessionInfo, outInfo);
137 ASSERT_EQ(outInfo.iconPathEarlyVersion_, "pathFromCache");
138 }
139
140 /**
141 * @tc.name: GetStartupPage03
142 * @tc.desc: GetStartupPage from rdb
143 * @tc.type: FUNC
144 */
145 HWTEST_F(WindowPatternStartingWindowTest, GetStartupPage03, TestSize.Level1)
146 {
147 ASSERT_NE(ssm_, nullptr);
148 InitTestStartingWindowRdb();
149 ASSERT_NE(ssm_->startingWindowRdbMgr_, nullptr);
150 ssm_->startingWindowMap_.clear();
151 SessionInfo sessionInfo;
152 StartingWindowRdbItemKey itemKey;
153 sessionInfo.moduleName_ = itemKey.moduleName = "moduleName";
154 sessionInfo.abilityName_ = itemKey.abilityName = "abilityName";
155 sessionInfo.bundleName_ = itemKey.bundleName = "bundleName";
156 itemKey.darkMode = false;
157 StartingWindowInfo rdbInfo;
158 rdbInfo.iconPathEarlyVersion_ = "pathFromRdb";
159 StartingWindowInfo outInfo;
160 outInfo.iconPathEarlyVersion_ = "default";
161 bool insertRes = ssm_->startingWindowRdbMgr_->InsertData(itemKey, rdbInfo);
162 EXPECT_EQ(insertRes, true);
163 ssm_->GetStartupPage(sessionInfo, outInfo);
164 EXPECT_EQ(outInfo.iconPathEarlyVersion_, "pathFromRdb");
165 }
166
167 /**
168 * @tc.name: GetStartingWindowInfoFromCache
169 * @tc.desc: GetStartingWindowInfoFromCache
170 * @tc.type: FUNC
171 */
172 HWTEST_F(WindowPatternStartingWindowTest, GetStartingWindowInfoFromCache, TestSize.Level1)
173 {
174 ASSERT_NE(ssm_, nullptr);
175 ssm_->startingWindowMap_.clear();
176 SessionInfo sessionInfo;
177 sessionInfo.moduleName_ = "moduleName";
178 sessionInfo.abilityName_ = "abilityName";
179 sessionInfo.bundleName_ = "bundleName";
180 StartingWindowInfo startingWindowInfo;
181 auto res = ssm_->GetStartingWindowInfoFromCache(sessionInfo, startingWindowInfo);
182 ASSERT_EQ(res, false);
183 auto key = sessionInfo.moduleName_ + sessionInfo.abilityName_;
184 std::map<std::string, StartingWindowInfo> startingWindowInfoMap{ { key, startingWindowInfo } };
185 ssm_->startingWindowMap_.insert({ sessionInfo.bundleName_, startingWindowInfoMap });
186 res = ssm_->GetStartingWindowInfoFromCache(sessionInfo, startingWindowInfo);
187 ASSERT_EQ(res, true);
188 sessionInfo.moduleName_ = "invalidModuleName";
189 res = ssm_->GetStartingWindowInfoFromCache(sessionInfo, startingWindowInfo);
190 ASSERT_EQ(res, false);
191 }
192
193 /**
194 * @tc.name: GetStartingWindowInfoFromRdb
195 * @tc.desc: GetStartingWindowInfoFromRdb
196 * @tc.type: FUNC
197 */
198 HWTEST_F(WindowPatternStartingWindowTest, GetStartingWindowInfoFromRdb, TestSize.Level1)
199 {
200 ASSERT_NE(ssm_, nullptr);
201 InitTestStartingWindowRdb();
202 ASSERT_NE(ssm_->startingWindowRdbMgr_, nullptr);
203 NativeRdb::RdbHelper::DeleteRdbStore(TEST_RDB_PATH + TEST_RDB_NAME);
204 SessionInfo sessionInfo;
205 StartingWindowRdbItemKey itemKey;
206 StartingWindowInfo outInfo;
207 sessionInfo.moduleName_ = itemKey.moduleName = "moduleName";
208 sessionInfo.abilityName_ = itemKey.abilityName = "abilityName";
209 sessionInfo.bundleName_ = itemKey.bundleName = "bundleName";
210 itemKey.darkMode = false;
211 auto res = ssm_->GetStartingWindowInfoFromRdb(sessionInfo, outInfo);
212 EXPECT_EQ(res, false);
213 bool insertRes = ssm_->startingWindowRdbMgr_->InsertData(itemKey, outInfo);
214 EXPECT_EQ(insertRes, true);
215 res = ssm_->GetStartingWindowInfoFromRdb(sessionInfo, outInfo);
216 EXPECT_EQ(res, true);
217 ssm_->startingWindowRdbMgr_ = nullptr;
218 res = ssm_->GetStartingWindowInfoFromRdb(sessionInfo, outInfo);
219 EXPECT_EQ(res, false);
220 }
221
222 /**
223 * @tc.name: GetIconFromDesk
224 * @tc.desc: GetIconFromDesk
225 * @tc.type: FUNC
226 */
227 HWTEST_F(WindowPatternStartingWindowTest, GetIconFromDesk, TestSize.Level1)
228 {
229 ASSERT_NE(ssm_, nullptr);
230 SessionInfo sessionInfo;
231 std::string outPath;
232 bool res = ssm_->GetIconFromDesk(sessionInfo, outPath);
233 ASSERT_EQ(res, false);
234 sessionInfo.want = std::make_shared<AAFwk::Want>();
235 ASSERT_NE(sessionInfo.want, nullptr);
236 res = ssm_->GetIconFromDesk(sessionInfo, outPath);
237 ASSERT_EQ(res, false);
238 const std::string pathFromDesk = "pathFromDesk";
239 sessionInfo.want->SetParam("realAppIcon", pathFromDesk);
240 res = ssm_->GetIconFromDesk(sessionInfo, outPath);
241 ASSERT_EQ(res, true);
242 }
243
244 /**
245 * @tc.name: GetStartupPageFromResource
246 * @tc.desc: GetStartupPageFromResource
247 * @tc.type: FUNC
248 */
249 HWTEST_F(WindowPatternStartingWindowTest, GetStartupPageFromResource, TestSize.Level1)
250 {
251 ASSERT_NE(ssm_, nullptr);
252 AppExecFwk::AbilityInfo info;
253 info.startWindowBackgroundId = 1;
254 StartingWindowInfo outInfo;
255 ASSERT_EQ(false, ssm_->GetStartupPageFromResource(info, outInfo));
256 info.startWindowIconId = 1;
257 ASSERT_EQ(false, ssm_->GetStartupPageFromResource(info, outInfo));
258 info.hapPath = "hapPath";
259 ASSERT_EQ(false, ssm_->GetStartupPageFromResource(info, outInfo));
260 }
261
262 /**
263 * @tc.name: CacheStartingWindowInfo01
264 * @tc.desc: Cache new starting window info
265 * @tc.type: FUNC
266 */
267 HWTEST_F(WindowPatternStartingWindowTest, CacheStartingWindowInfo01, TestSize.Level1)
268 {
269 ASSERT_NE(ssm_, nullptr);
270 ssm_->startingWindowMap_.clear();
271 /**
272 * @tc.steps: step1. Build input parameter.
273 */
274 AppExecFwk::AbilityInfo abilityInfo;
275 abilityInfo.name = "abilityName";
276 abilityInfo.bundleName = "bundleName";
277 abilityInfo.moduleName = "moduleName";
278 StartingWindowInfo startingWindowInfo;
279 startingWindowInfo.backgroundColorEarlyVersion_ = 0xff000000;
280 startingWindowInfo.iconPathEarlyVersion_ = "cachedPath";
281
282 /**
283 * @tc.steps: step2. Cache info and check result.
284 */
285 ssm_->CacheStartingWindowInfo(abilityInfo.bundleName, abilityInfo.moduleName, abilityInfo.name, startingWindowInfo);
286 auto iter = ssm_->startingWindowMap_.find(abilityInfo.bundleName);
287 ASSERT_NE(iter, ssm_->startingWindowMap_.end());
288 auto& infoMap = iter->second;
289 auto infoIter = infoMap.find(abilityInfo.moduleName + abilityInfo.name);
290 ASSERT_NE(infoIter, infoMap.end());
291 ASSERT_EQ(infoIter->second.backgroundColorEarlyVersion_, 0xff000000);
292 ASSERT_EQ(infoIter->second.iconPathEarlyVersion_, "cachedPath");
293 }
294
295 /**
296 * @tc.name: CacheStartingWindowInfo02
297 * @tc.desc: Execute when info is cached
298 * @tc.type: FUNC
299 */
300 HWTEST_F(WindowPatternStartingWindowTest, CacheStartingWindowInfo02, TestSize.Level1)
301 {
302 ASSERT_NE(ssm_, nullptr);
303 ssm_->startingWindowMap_.clear();
304 /**
305 * @tc.steps: step1. Build input parameter.
306 */
307 AppExecFwk::AbilityInfo abilityInfo;
308 abilityInfo.name = "abilityName";
309 abilityInfo.bundleName = "bundleName";
310 abilityInfo.moduleName = "moduleName";
311 StartingWindowInfo startingWindowInfo;
312 startingWindowInfo.backgroundColorEarlyVersion_ = 0xff000000;
313 startingWindowInfo.iconPathEarlyVersion_ = "cachedPath";
314
315 /**
316 * @tc.steps: step2. Insert one item.
317 */
318 auto key = abilityInfo.moduleName + abilityInfo.name;
319 StartingWindowInfo anotherStartingWindowInfo = {
320 .backgroundColorEarlyVersion_ = 0x00000000,
321 .iconPathEarlyVersion_ = "path",
322 };
323 std::map<std::string, StartingWindowInfo> startingWindowInfoMap{ { key, anotherStartingWindowInfo } };
324 ssm_->startingWindowMap_.insert({ abilityInfo.bundleName, startingWindowInfoMap });
325
326 /**
327 * @tc.steps: step3. Execute and check result.
328 */
329 ssm_->CacheStartingWindowInfo(abilityInfo.bundleName, abilityInfo.moduleName, abilityInfo.name, startingWindowInfo);
330 auto iter = ssm_->startingWindowMap_.find(abilityInfo.bundleName);
331 ASSERT_NE(iter, ssm_->startingWindowMap_.end());
332 auto& infoMap = iter->second;
333 auto infoIter = infoMap.find(abilityInfo.moduleName + abilityInfo.name);
334 ASSERT_NE(infoIter, infoMap.end());
335 ASSERT_NE(infoIter->second.backgroundColorEarlyVersion_, 0xff000000);
336 ASSERT_NE(infoIter->second.iconPathEarlyVersion_, "cachedPath");
337 }
338
339 /**
340 * @tc.name: GetPathInfoFromResource
341 * @tc.desc: GetPathInfoFromResource
342 * @tc.type: FUNC
343 */
344 HWTEST_F(WindowPatternStartingWindowTest, GetPathInfoFromResource, TestSize.Level1)
345 {
346 ASSERT_NE(ssm_, nullptr);
347 uint32_t resourceId = 0;
348 std::string path;
349 bool res = ssm_->GetPathInfoFromResource(nullptr, true, resourceId, path);
350 ASSERT_EQ(res, false);
351 }
352
353 /**
354 * @tc.name: GetBundleStartingWindowInfos
355 * @tc.desc: GetBundleStartingWindowInfos
356 * @tc.type: FUNC
357 */
358 HWTEST_F(WindowPatternStartingWindowTest, GetBundleStartingWindowInfos, TestSize.Level1)
359 {
360 ASSERT_NE(ssm_, nullptr);
361 AppExecFwk::BundleInfo bundleInfo;
362 std::vector<std::pair<StartingWindowRdbItemKey, StartingWindowInfo>> outValues;
363 ssm_->GetBundleStartingWindowInfos(false, bundleInfo, outValues);
364 EXPECT_EQ(outValues.size(), 0);
365 }
366
367 /**
368 * @tc.name: GetPreLoadStartingWindow
369 * @tc.desc: GetPreLoadStartingWindow
370 * @tc.type: FUNC
371 */
372 HWTEST_F(WindowPatternStartingWindowTest, GetPreLoadStartingWindow, TestSize.Level1)
373 {
374 ASSERT_NE(ssm_, nullptr);
375 ssm_->preLoadStartingWindowMap_.clear();
376 SessionInfo sessionInfo;
377 ASSERT_EQ(nullptr, ssm_->GetPreLoadStartingWindow(sessionInfo));
378 sessionInfo.bundleName_ = "bundleName_";
379 sessionInfo.moduleName_ = "moduleName_";
380 sessionInfo.abilityName_ = "abilityName_";
381 std::string key = sessionInfo.bundleName_ + '_' + sessionInfo.moduleName_ + '_' +sessionInfo.abilityName_;
382 ssm_->preLoadStartingWindowMap_[key] = std::make_shared<Media::PixelMap>();
383 ASSERT_NE(nullptr, ssm_->GetPreLoadStartingWindow(sessionInfo));
384 ssm_->preLoadStartingWindowMap_.clear();
385 EXPECT_EQ(true, ssm_->preLoadStartingWindowMap_.empty());
386 }
387
388 /**
389 * @tc.name: RemovePreLoadStartingWindowFromMap
390 * @tc.desc: RemovePreLoadStartingWindowFromMap
391 * @tc.type: FUNC
392 */
393 HWTEST_F(WindowPatternStartingWindowTest, RemovePreLoadStartingWindowFromMap, TestSize.Level1)
394 {
395 ASSERT_NE(ssm_, nullptr);
396 ssm_->preLoadStartingWindowMap_.clear();
397 SessionInfo sessionInfo;
398 sessionInfo.bundleName_ = "bundleName_";
399 sessionInfo.moduleName_ = "moduleName_";
400 sessionInfo.abilityName_ = "abilityName_";
401 std::string key = sessionInfo.bundleName_ + '_' + sessionInfo.moduleName_ + '_' +sessionInfo.abilityName_;
402 ssm_->preLoadStartingWindowMap_[key] = std::make_shared<Media::PixelMap>();
403 SessionInfo anotherSessionInfo;
404 ssm_->RemovePreLoadStartingWindowFromMap(anotherSessionInfo);
405 EXPECT_EQ(false, ssm_->preLoadStartingWindowMap_.empty());
406 ssm_->RemovePreLoadStartingWindowFromMap(sessionInfo);
407 EXPECT_EQ(true, ssm_->preLoadStartingWindowMap_.empty());
408 }
409
410 /**
411 * @tc.name: EraseSceneSessionMapById
412 * @tc.desc: release preload starting window when EraseSceneSessionMapById
413 * @tc.type: FUNC
414 */
415 HWTEST_F(WindowPatternStartingWindowTest, EraseSceneSessionMapById, TestSize.Level1)
416 {
417 ASSERT_NE(ssm_, nullptr);
418 ssm_->preLoadStartingWindowMap_.clear();
419 SessionInfo sessionInfo;
420 sessionInfo.bundleName_ = "bundleName_";
421 sessionInfo.moduleName_ = "moduleName_";
422 sessionInfo.abilityName_ = "abilityName_";
423 std::string key = sessionInfo.bundleName_ + '_' + sessionInfo.moduleName_ + '_' +sessionInfo.abilityName_;
424 ssm_->preLoadStartingWindowMap_[key] = std::make_shared<Media::PixelMap>();
425 EXPECT_EQ(false, ssm_->preLoadStartingWindowMap_.empty());
426 ssm_->EraseSceneSessionMapById(0);
427 EXPECT_EQ(false, ssm_->preLoadStartingWindowMap_.empty());
428 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(sessionInfo, nullptr);
429 ASSERT_NE(sceneSession, nullptr);
430 ssm_->sceneSessionMap_.insert({sceneSession->GetPersistentId(), sceneSession});
431 ASSERT_NE(nullptr, ssm_->GetSceneSession(sceneSession->GetPersistentId()));
432 ssm_->EraseSceneSessionMapById(sceneSession->GetPersistentId());
433 ASSERT_EQ(nullptr, ssm_->GetSceneSession(sceneSession->GetPersistentId()));
434 EXPECT_EQ(true, ssm_->preLoadStartingWindowMap_.empty());
435 }
436
437 /**
438 * @tc.name: CheckAndGetPreLoadResourceId
439 * @tc.desc: CheckAndGetPreLoadResourceId
440 * @tc.type: FUNC
441 */
442 HWTEST_F(WindowPatternStartingWindowTest, CheckAndGetPreLoadResourceId, TestSize.Level1)
443 {
444 ASSERT_NE(ssm_, nullptr);
445 StartingWindowInfo startingWindowInfo;
446 uint32_t resId = 0;
447 startingWindowInfo.configFileEnabled_ = true;
448 EXPECT_EQ(false, ssm_->CheckAndGetPreLoadResourceId(startingWindowInfo, resId));
449 startingWindowInfo.configFileEnabled_ = false;
450 EXPECT_EQ(false, ssm_->CheckAndGetPreLoadResourceId(startingWindowInfo, resId));
451 startingWindowInfo.iconPathEarlyVersion_ = "resource:///12345678.svg";
452 EXPECT_EQ(false, ssm_->CheckAndGetPreLoadResourceId(startingWindowInfo, resId));
453 startingWindowInfo.iconPathEarlyVersion_ = "resource:///abc12345678.jpg";
454 EXPECT_EQ(false, ssm_->CheckAndGetPreLoadResourceId(startingWindowInfo, resId));
455 startingWindowInfo.iconPathEarlyVersion_ = "resource:///12345678.png";
456 EXPECT_EQ(true, ssm_->CheckAndGetPreLoadResourceId(startingWindowInfo, resId));
457 startingWindowInfo.iconPathEarlyVersion_ = "resource:///12345678.jpg";
458 EXPECT_EQ(true, ssm_->CheckAndGetPreLoadResourceId(startingWindowInfo, resId));
459 }
460
461 /**
462 * @tc.name: PreLoadStartingWindow
463 * @tc.desc: PreLoadStartingWindow
464 * @tc.type: FUNC
465 */
466 HWTEST_F(WindowPatternStartingWindowTest, PreLoadStartingWindow, TestSize.Level1)
467 {
468 ASSERT_NE(ssm_, nullptr);
469 sptr<SceneSession> sceneSession = nullptr;
470 ssm_->PreLoadStartingWindow(sceneSession);
471 SessionInfo info;
472 info.bundleName_ = "bundleName_";
473 info.moduleName_ = "moduleName_";
474 info.abilityName_ = "abilityName_";
475 sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
476 ASSERT_NE(nullptr, sceneSession);
477 ssm_->PreLoadStartingWindow(sceneSession);
478 ASSERT_NE(nullptr, sceneSession);
479 EXPECT_EQ(false, ssm_->needUpdateRdb_);
480 }
481
482 /**
483 * @tc.name: NotifyPreLoadStartingWindowFinished
484 * @tc.desc: NotifyPreLoadStartingWindowFinished
485 * @tc.type: FUNC
486 */
487 HWTEST_F(WindowPatternStartingWindowTest, NotifyPreLoadStartingWindowFinished, TestSize.Level1)
488 {
489 SessionInfo info;
490 info.bundleName_ = "bundleName_";
491 info.moduleName_ = "moduleName_";
492 info.abilityName_ = "abilityName_";
493 sptr<SceneSession> sceneSession = sptr<SceneSession>::MakeSptr(info, nullptr);
494 ASSERT_NE(nullptr, sceneSession);
495 sceneSession->NotifyPreLoadStartingWindowFinished();
496 ASSERT_NE(nullptr, sceneSession);
497 }
498
499 /**
500 * @tc.name: GetIsDarkFromConfiguration
501 * @tc.desc: GetIsDarkFromConfiguration
502 * @tc.type: FUNC
503 */
504 HWTEST_F(WindowPatternStartingWindowTest, GetIsDarkFromConfiguration, TestSize.Level1)
505 {
506 ASSERT_NE(ssm_, nullptr);
507 bool isDark = ssm_->GetIsDarkFromConfiguration();
508 EXPECT_EQ(false, isDark);
509 }
510
511 /**
512 * @tc.name: UpdateAllStartingWindowRdb
513 * @tc.desc: UpdateAllStartingWindowRdb
514 * @tc.type: FUNC
515 */
516 HWTEST_F(WindowPatternStartingWindowTest, UpdateAllStartingWindowRdb, TestSize.Level1)
517 {
518 g_logMsg.clear();
519 LOG_SetCallback(RdbLogCallback);
520 ASSERT_NE(ssm_, nullptr);
521 ssm_->UpdateAllStartingWindowRdb();
522 usleep(WAIT_SLEEP_TIME);
523 EXPECT_TRUE(g_logMsg.find("GetBundleInfosV9 error") != std::string::npos);
524 }
525 } // namespace
526 } // namespace Rosen
527 } // namespace OHOS