diff --git a/services/samgr/native/source/collect/ref_count_collect.cpp b/services/samgr/native/source/collect/ref_count_collect.cpp index 1372a612b15ee9422253d5abc0c7510667b2189b..214067a49e5de2f2a68c261db5048b714544038d 100644 --- a/services/samgr/native/source/collect/ref_count_collect.cpp +++ b/services/samgr/native/source/collect/ref_count_collect.cpp @@ -64,7 +64,7 @@ int32_t RefCountCollect::OnStop() { if (timer_ != nullptr) { HILOGI("RefCountCollect stop timer"); - timer_->Shutdown(); + timer_->Shutdown(false); } return ERR_OK; } diff --git a/services/samgr/native/test/unittest/BUILD.gn b/services/samgr/native/test/unittest/BUILD.gn index 8ff86f26d6095b41dba5b18debb27185e9e159b7..2a17423c3d13e2bd216d6b58d5ffa665a766c5f2 100644 --- a/services/samgr/native/test/unittest/BUILD.gn +++ b/services/samgr/native/test/unittest/BUILD.gn @@ -144,6 +144,7 @@ ohos_unittest("SystemAbilityMgrTest") { if (support_common_event) { sources += [ "${samgr_services_dir}/source/collect/common_event_collect.cpp", + "${samgr_services_dir}/test/unittest/src/mock_dbinder_service.cpp", "${samgr_services_dir}/test/unittest/src/system_ability_mgr_load_test.cpp", "${samgr_services_dir}/test/unittest/src/system_ability_mgr_new_test.cpp", "${samgr_services_dir}/test/unittest/src/system_ability_mgr_ondemand_test.cpp", diff --git a/services/samgr/native/test/unittest/src/device_status_collect_manager_test.cpp b/services/samgr/native/test/unittest/src/device_status_collect_manager_test.cpp index 6c644ae6e716faeb4f8dd38f61a96631837c64d6..1cadd1230c741ea0576f1ac7fc827a927568190c 100644 --- a/services/samgr/native/test/unittest/src/device_status_collect_manager_test.cpp +++ b/services/samgr/native/test/unittest/src/device_status_collect_manager_test.cpp @@ -504,17 +504,15 @@ HWTEST_F(DeviceStatusCollectManagerTest, ReportEvent002, TestSize.Level3) { DTEST_LOG << " ReportEvent002 BEGIN" << std::endl; std::list saProfiles; - collect->Init(saProfiles); + sptr collectMgr = new DeviceStatusCollectManager(); + EXPECT_EQ(true, collectMgr != nullptr); + collectMgr->Init(saProfiles); OnDemandEvent event; - collect->collectHandler_ = std::make_shared("collect"); - collect->ReportEvent(event); - EXPECT_EQ(true, collect->collectHandler_ != nullptr); - PostTask(collect->collectHandler_); - collect->PostDelayTask(nullptr, -1); - collect->PostDelayTask(nullptr, std::numeric_limits::max()); - event = { DEVICE_ONLINE, SA_TAG_DEVICE_ON_LINE, "on" }; - collect->ReportEvent(event); - collect->collectHandler_->CleanFfrt(); + collectMgr->ReportEvent(event); + EXPECT_EQ(true, collectMgr->collectHandler_ != nullptr); + PostTask(collectMgr->collectHandler_); + collectMgr->PostDelayTask(nullptr, -1); + collectMgr->PostDelayTask(nullptr, std::numeric_limits::max()); DTEST_LOG << " ReportEvent002 END" << std::endl; } @@ -527,7 +525,9 @@ HWTEST_F(DeviceStatusCollectManagerTest, ReportEvent003, TestSize.Level3) { DTEST_LOG << " ReportEvent003 BEGIN" << std::endl; std::list saProfiles; - collect->Init(saProfiles); + sptr collectMgr = new DeviceStatusCollectManager(); + EXPECT_EQ(true, collectMgr != nullptr); + collectMgr->Init(saProfiles); OnDemandEvent event = { DEVICE_ONLINE, SA_TAG_DEVICE_ON_LINE, "on" }; std::list saControlList; SaProfile saProfile; @@ -537,11 +537,10 @@ HWTEST_F(DeviceStatusCollectManagerTest, ReportEvent003, TestSize.Level3) saProfile.startOnDemand.onDemandEvents.emplace_back(event1); saProfile.stopOnDemand.onDemandEvents.emplace_back(event2); saProfiles.emplace_back(saProfile); - collect->FilterOnDemandSaProfiles(saProfiles); - collect->ReportEvent(event); - EXPECT_EQ(true, collect->collectHandler_ != nullptr); - PostTask(collect->collectHandler_); - collect->collectHandler_->CleanFfrt(); + collectMgr->FilterOnDemandSaProfiles(saProfiles); + collectMgr->ReportEvent(event); + EXPECT_EQ(true, collectMgr->collectHandler_!= nullptr); + PostTask(collectMgr->collectHandler_); DTEST_LOG << " ReportEvent003 END" << std::endl; } diff --git a/services/samgr/native/test/unittest/src/device_timed_collect_test.cpp b/services/samgr/native/test/unittest/src/device_timed_collect_test.cpp index a75f0a4fb206a0896d8005a16cca8da0523e1701..dee78a4d4e6df7a0be3bc7b465f3de36ecfd30cf 100644 --- a/services/samgr/native/test/unittest/src/device_timed_collect_test.cpp +++ b/services/samgr/native/test/unittest/src/device_timed_collect_test.cpp @@ -68,8 +68,8 @@ HWTEST_F(DeviceTimedCollectTest, Init001, TestSize.Level3) saProfile.startOnDemand.onDemandEvents.push_back(onDemandEvent); saProfiles.push_back(saProfile); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 1); DTEST_LOG << "Init001 end" << std::endl; @@ -89,8 +89,8 @@ HWTEST_F(DeviceTimedCollectTest, Init002, TestSize.Level3) saProfile.startOnDemand.onDemandEvents.push_back(onDemandEvent); saProfiles.push_back(saProfile); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 0); DTEST_LOG << "Init002 end" << std::endl; @@ -110,8 +110,8 @@ HWTEST_F(DeviceTimedCollectTest, Init003, TestSize.Level3) saProfile.stopOnDemand.onDemandEvents.push_back(onDemandEvent); saProfiles.push_back(saProfile); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 1); DTEST_LOG << "Init003 end" << std::endl; @@ -131,8 +131,8 @@ HWTEST_F(DeviceTimedCollectTest, Init004, TestSize.Level3) saProfile.stopOnDemand.onDemandEvents.push_back(onDemandEvent); saProfiles.push_back(saProfile); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 0); DTEST_LOG << "Init004 end" << std::endl; @@ -152,8 +152,8 @@ HWTEST_F(DeviceTimedCollectTest, Init005, TestSize.Level3) saProfile.stopOnDemand.onDemandEvents.push_back(onDemandEvent); saProfiles.push_back(saProfile); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 0); DTEST_LOG << "Init005 end" << std::endl; @@ -173,8 +173,8 @@ HWTEST_F(DeviceTimedCollectTest, Init006, TestSize.Level3) saProfile.startOnDemand.onDemandEvents.push_back(onDemandEvent); saProfiles.push_back(saProfile); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 0); DTEST_LOG << "Init006 end" << std::endl; @@ -194,8 +194,8 @@ HWTEST_F(DeviceTimedCollectTest, Init007, TestSize.Level3) saProfile.startOnDemand.onDemandEvents.push_back(onDemandEvent); saProfiles.push_back(saProfile); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 0); DTEST_LOG << "Init007 end" << std::endl; @@ -223,8 +223,8 @@ HWTEST_F(DeviceTimedCollectTest, Init008, TestSize.Level3) saProfile3.startOnDemand.onDemandEvents.push_back(onDemandEvent3); saProfiles.push_back(saProfile3); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->Init(saProfiles); EXPECT_EQ(deviceTimedCollect->nonPersitenceLoopEventSet_.size(), 2); deviceTimedCollect->timeInfos_.clear(); @@ -240,8 +240,9 @@ HWTEST_F(DeviceTimedCollectTest, OnStart001, TestSize.Level0) { DTEST_LOG << "OnStart001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->nonPersitenceLoopEventSet_.insert(101); deviceTimedCollect->OnStart(); EXPECT_NE(collect, nullptr); @@ -260,12 +261,13 @@ HWTEST_F(DeviceTimedCollectTest, OnStart002, TestSize.Level3) #ifdef PREFERENCES_ENABLE std::shared_ptr preferencesUtil_ = PreferencesUtil::GetInstance(); sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); int64_t currentTime = TimeUtils::GetTimestamp(); preferencesUtil_->SaveString("timedevent_2017-9-1-16:59:10", "start#149999#"); - preferencesUtil_->SaveLong("2017-9-1-16:59:10", currentTime + 10); - preferencesUtil_->SaveLong("2017-9-1-16:59:11", currentTime - 10); + preferencesUtil_->SaveLong("2017-9-1-16:59:10", currentTime + 1000); + preferencesUtil_->SaveLong("2017-9-1-16:59:11", currentTime - 1000); deviceTimedCollect->OnStart(); EXPECT_NE(collect, nullptr); preferencesUtil_->RefreshSync(); @@ -289,8 +291,8 @@ HWTEST_F(DeviceTimedCollectTest, ReportEventByTimeInfo001, TestSize.Level3) { DTEST_LOG << "ReportEventByTimeInfo001 begin" << std::endl; sptr collect = nullptr; - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); TimeInfo info; info.awake = true; info.normal = true; @@ -310,8 +312,8 @@ HWTEST_F(DeviceTimedCollectTest, PostDelayTaskByTimeInfo001, TestSize.Level3) { DTEST_LOG << "PostDelayTaskByTimeInfo001 begin" << std::endl; sptr collect = nullptr; - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); TimeInfo info; info.awake = true; info.normal = true; @@ -332,8 +334,8 @@ HWTEST_F(DeviceTimedCollectTest, ReportEvent001, TestSize.Level3) { DTEST_LOG << "ReportEvent001 begin" << std::endl; sptr collect = nullptr; - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event; deviceTimedCollect->ReportEvent(event); EXPECT_EQ(collect, nullptr); @@ -350,8 +352,8 @@ HWTEST_F(DeviceTimedCollectTest, PostDelayTask001, TestSize.Level3) { DTEST_LOG << "PostDelayTask001 begin" << std::endl; sptr collect = nullptr; - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->PostDelayTask(deviceTimedCollect->nonPersitenceLoopTasks_[0], 0); EXPECT_EQ(collect, nullptr); DTEST_LOG << "PostDelayTask001 end" << std::endl; @@ -368,8 +370,8 @@ HWTEST_F(DeviceTimedCollectTest, PostDelayTask002, TestSize.Level3) DTEST_LOG << "PostDelayTask002 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); collect->collectHandler_ = std::make_shared("collect"); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->nonPersitenceLoopTasks_[0] = [] () {}; deviceTimedCollect->PostDelayTask(deviceTimedCollect->nonPersitenceLoopTasks_[0], 0); EXPECT_NE(collect, nullptr); @@ -386,8 +388,9 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent001, TestSize.Level3) { DTEST_LOG << "AddCollectEvent001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event; std::vector events; events.emplace_back(event); @@ -406,8 +409,9 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent002, TestSize.Level3) { DTEST_LOG << "AddCollectEvent002 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "mockevent", "10"}; std::vector events; events.emplace_back(event); @@ -426,8 +430,9 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent003, TestSize.Level3) { DTEST_LOG << "AddCollectEvent003 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "loopevent", "10"}; std::vector events; events.emplace_back(event); @@ -446,8 +451,9 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent004, TestSize.Level3) { DTEST_LOG << "AddCollectEvent004 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "order_timed_event", "10", -1, true}; std::vector events; events.emplace_back(event); @@ -466,8 +472,9 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent005, TestSize.Level3) { DTEST_LOG << "AddCollectEvent005 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "order_timed_event", "10"}; std::vector events; events.emplace_back(event); @@ -486,8 +493,9 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent006, TestSize.Level3) { DTEST_LOG << "AddCollectEvent006 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "mockevent", "10", -1, true}; std::vector events; events.emplace_back(event); @@ -506,8 +514,9 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent007, TestSize.Level3) DTEST_LOG << "AddCollectEvent007 begin" << std::endl; #ifdef PREFERENCES_ENABLE sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); std::vector events; OnDemandEvent event = {TIMED_EVENT, "timedevent", "2017-9-1-16:59:10", -1, true}; @@ -522,11 +531,11 @@ HWTEST_F(DeviceTimedCollectTest, AddCollectEvent007, TestSize.Level3) events.emplace_back(event2); ret = deviceTimedCollect->AddCollectEvent(events); EXPECT_EQ(ret, ERR_OK); - OnDemandEvent event3 = {TIMED_EVENT, "awakeloopevent", "100", -1, true}; + OnDemandEvent event3 = {TIMED_EVENT, "awakeloopevent", "1000", -1, true}; events.emplace_back(event3); ret = deviceTimedCollect->AddCollectEvent(events); EXPECT_EQ(ret, ERR_INVALID_VALUE); - OnDemandEvent event4 = {TIMED_EVENT, "awakeloopevent", "100", -1, false}; + OnDemandEvent event4 = {TIMED_EVENT, "awakeloopevent", "1000", -1, false}; events.emplace_back(event4); ret = deviceTimedCollect->AddCollectEvent(events); EXPECT_EQ(ret, ERR_INVALID_VALUE); @@ -545,8 +554,9 @@ HWTEST_F(DeviceTimedCollectTest, OnStop001, TestSize.Level0) { DTEST_LOG << "OnStop001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = - std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); int32_t ret = deviceTimedCollect->OnStop(); EXPECT_EQ(ret, ERR_OK); DTEST_LOG << "OnStop001 end" << std::endl; @@ -562,8 +572,8 @@ HWTEST_F(DeviceTimedCollectTest, RemoveUnusedEvent001, TestSize.Level3) { DTEST_LOG << "RemoveUnusedEvent001 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = - std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "invalid", "10"}; int32_t ret = deviceTimedCollect->RemoveUnusedEvent(event); EXPECT_EQ(ret, ERR_INVALID_VALUE); @@ -580,8 +590,8 @@ HWTEST_F(DeviceTimedCollectTest, RemoveUnusedEvent002, TestSize.Level3) { DTEST_LOG << "RemoveUnusedEvent002 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = - std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "loopevent", "10"}; deviceTimedCollect->nonPersitenceLoopEventSet_.clear(); int32_t ret = deviceTimedCollect->RemoveUnusedEvent(event); @@ -599,8 +609,8 @@ HWTEST_F(DeviceTimedCollectTest, RemoveUnusedEvent003, TestSize.Level3) { DTEST_LOG << "RemoveUnusedEvent003 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = - std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "loopevent", "10"}; deviceTimedCollect->nonPersitenceLoopEventSet_.insert(10); int32_t ret = deviceTimedCollect->RemoveUnusedEvent(event); @@ -618,8 +628,8 @@ HWTEST_F(DeviceTimedCollectTest, RemoveUnusedEvent004, TestSize.Level3) { DTEST_LOG << "RemoveUnusedEvent004 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = - std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "loopevent", "10", -1, true}; deviceTimedCollect->nonPersitenceLoopEventSet_.insert(10); int32_t ret = deviceTimedCollect->RemoveUnusedEvent(event); @@ -637,8 +647,8 @@ HWTEST_F(DeviceTimedCollectTest, RemoveUnusedEvent005, TestSize.Level3) { DTEST_LOG << "RemoveUnusedEvent005 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = - std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); OnDemandEvent event = {TIMED_EVENT, "awakeloopevent", "3600", -1, true}; deviceTimedCollect->nonPersitenceLoopEventSet_.insert(3600); int32_t ret = deviceTimedCollect->RemoveUnusedEvent(event); @@ -715,14 +725,15 @@ HWTEST_F(DeviceTimedCollectTest, ProcessPersistenceTimedTask001, TestSize.Level3 { DTEST_LOG << "ProcessPersistenceTimedTask001 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); int64_t disTime = 0; std::string strTime = "IntervalTime"; deviceTimedCollect->ProcessPersistenceTimedTask(disTime, strTime); EXPECT_EQ(disTime, 0); - disTime = 50; + disTime = 5000; deviceTimedCollect->ProcessPersistenceTimedTask(disTime, strTime); EXPECT_NE(disTime, 0); DTEST_LOG << "ProcessPersistenceTimedTask001 end" << std::endl; @@ -734,7 +745,8 @@ HWTEST_F(DeviceTimedCollectTest, PostPersistenceDelayTask001, TestSize.Level3) { DTEST_LOG << "PostPersistenceDelayTask001 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); int32_t interval = 1; int32_t disTime = 1; @@ -750,7 +762,9 @@ HWTEST_F(DeviceTimedCollectTest, PostNonPersistenceTimedTaskLocked001, TestSize. { DTEST_LOG << "PostNonPersistenceTimedTaskLocked001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); std::string strTime = "timedevent"; int64_t timeGap = 0; deviceTimedCollect->PostNonPersistenceTimedTaskLocked(strTime, timeGap); @@ -763,14 +777,15 @@ HWTEST_F(DeviceTimedCollectTest, ProcessPersistenceTimedTask003, TestSize.Level3 { DTEST_LOG << " ProcessPersistenceTimedTask003 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); int64_t disTime = 0; std::string strTime = "IntervalTime"; deviceTimedCollect->ProcessPersistenceTimedTask(disTime, strTime); EXPECT_EQ(disTime, 0); - disTime = 50; + disTime = 5000; deviceTimedCollect->ProcessPersistenceTimedTask(disTime, strTime); EXPECT_NE(disTime, 0); DTEST_LOG << " ProcessPersistenceTimedTask003 end" << std::endl; @@ -782,7 +797,8 @@ HWTEST_F(DeviceTimedCollectTest, PostPersistenceDelayTask002, TestSize.Level3) { DTEST_LOG << " PostPersistenceDelayTask002 begin" << std::endl; sptr report; - std::shared_ptr deviceTimedCollect = std::make_shared(report); + sptr deviceTimedCollect = new DeviceTimedCollect(report); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); int32_t interVal = 1; int32_t disTime = 1; @@ -798,7 +814,9 @@ HWTEST_F(DeviceTimedCollectTest, PostNonPersistenceTimedTaskLocked002, TestSize. { DTEST_LOG << " PostNonPersistenceTimedTaskLocked002 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); std::string strTime = "timedevent"; int64_t timeGap = 0; deviceTimedCollect->PostNonPersistenceTimedTaskLocked(strTime, timeGap); @@ -811,14 +829,16 @@ HWTEST_F(DeviceTimedCollectTest, ProcessPersistenceTimedTask002, TestSize.Level3 { DTEST_LOG << " ProcessPersistenceTimedTask002 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); int64_t disTime = -1; std::string strTime = "time_2017_9-1-16:59:10"; deviceTimedCollect->ProcessPersistenceTimedTask(disTime, strTime); EXPECT_NE(nullptr, deviceTimedCollect->preferencesUtil_); - disTime = 100; + disTime = 1000; deviceTimedCollect->ProcessPersistenceTimedTask(disTime, strTime); EXPECT_NE(nullptr, deviceTimedCollect->preferencesUtil_); DTEST_LOG << " ProcessPersistenceTimedTask002 end" << std::endl; @@ -829,7 +849,9 @@ HWTEST_F(DeviceTimedCollectTest, ProcessPersistenceLoopTask001, TestSize.Level3) { DTEST_LOG << " ProcessPersistenceLoopTask001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); int64_t disTime = 0; @@ -837,7 +859,7 @@ HWTEST_F(DeviceTimedCollectTest, ProcessPersistenceLoopTask001, TestSize.Level3) std::string strInterval = "1729909174"; deviceTimedCollect->ProcessPersistenceLoopTask(disTime, triggerTime, strInterval); EXPECT_EQ(0, disTime); - disTime = 100; + disTime = 1000; deviceTimedCollect->ProcessPersistenceLoopTask(disTime, triggerTime, strInterval); EXPECT_NE(0, disTime); DTEST_LOG << " ProcessPersistenceLoopTask001 end" << std::endl; @@ -847,7 +869,9 @@ HWTEST_F(DeviceTimedCollectTest, PostNonPersistenceLoopTaskLocked001, TestSize.L { DTEST_LOG << " PostNonPersistenceLoopTaskLocked001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); int32_t interVal = 65; deviceTimedCollect->nonPersitenceLoopTasks_[interVal] = [interVal] () {}; deviceTimedCollect->PostNonPersistenceLoopTaskLocked(interVal); @@ -868,7 +892,9 @@ HWTEST_F(DeviceTimedCollectTest, PostPersistenceDelayTaskd001, TestSize.Level3) { DTEST_LOG << " PostPersistenceDelayTaskd001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); deviceTimedCollect->preferencesUtil_ = PreferencesUtil::GetInstance(); std::function postTask = [] () {}; @@ -884,12 +910,14 @@ HWTEST_F(DeviceTimedCollectTest, PostNonPersistenceTimedTaskLocked003, TestSize. { DTEST_LOG << " PostNonPersistenceTimedTaskLocked003 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); std::string strTime = "100"; int64_t timeGap = 0; deviceTimedCollect->PostNonPersistenceTimedTaskLocked(strTime, timeGap); EXPECT_EQ(0, timeGap); - timeGap = 50; + timeGap = 5000; deviceTimedCollect->PostNonPersistenceTimedTaskLocked(strTime, timeGap); EXPECT_NE(0, timeGap); DTEST_LOG << " PostNonPersistenceTimedTaskLocked003 end" << std::endl; @@ -899,7 +927,9 @@ HWTEST_F(DeviceTimedCollectTest, RemovePersistenceLoopTask001, TestSize.Level3) { DTEST_LOG << " RemovePersistenceLoopTask001 begin" << std::endl; sptr collect = new DeviceStatusCollectManager(); - std::shared_ptr deviceTimedCollect = std::make_shared(collect); + collect->collectHandler_ = std::make_shared("collect"); + sptr deviceTimedCollect = new DeviceTimedCollect(collect); + EXPECT_EQ(true, deviceTimedCollect != nullptr); int32_t interVal = 64; deviceTimedCollect->persitenceLoopEventSet_.insert(interVal); diff --git a/services/samgr/native/test/unittest/src/mock_dbinder_service.cpp b/services/samgr/native/test/unittest/src/mock_dbinder_service.cpp new file mode 100644 index 0000000000000000000000000000000000000000..c9011460ed6c36a7972ac284a2087ae851429d81 --- /dev/null +++ b/services/samgr/native/test/unittest/src/mock_dbinder_service.cpp @@ -0,0 +1,66 @@ +/* + * Copyright (C) 2021-2025 Huawei Device Co., Ltd. + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#include "dbinder_service.h" +#include "sam_log.h" + +namespace OHOS { +DBinderService::DBinderService() +{ + HILOGI("Mock_DBinderService::DBinderService"); +} + +DBinderService::~DBinderService() +{ + HILOGI("Mock_DBinderService::~DBinderService"); +} + +sptr DBinderService::MakeRemoteBinder(const std::u16string &serviceName, + const std::string &deviceID, int32_t binderObject, uint32_t pid, uint32_t uid) +{ + HILOGI("Mock_DBinderService::MakeRemoteBinder"); + return nullptr; +} + +void DBinderService::LoadSystemAbilityComplete(const std::string& srcNetworkId, int32_t systemAbilityId, + const sptr& remoteObject) +{ + HILOGI("Mock_DBinderService::LoadSystemAbilityComplete"); +} + +bool DBinderService::RegisterRemoteProxy(std::u16string serviceName, int32_t systemAbilityId) +{ + HILOGI("Mock_DBinderService::RegisterRemoteProxy"); + return true; +} + +bool DBinderService::StartDBinderService(std::shared_ptr &callbackImpl) +{ + HILOGI("Mock_DBinderService::StartDBinderService"); + return true; +} + +int32_t DBinderService::NoticeServiceDie(const std::u16string &serviceName, const std::string &deviceID) +{ + HILOGI("Mock_DBinderService::NoticeServiceDie"); + return ERR_NONE; +} + +int32_t DBinderService::NoticeDeviceDie(const std::string &deviceID) +{ + HILOGI("Mock_DBinderService::NoticeDeviceDie"); + return ERR_NONE; +} +} // namespace OHOS diff --git a/services/samgr/native/test/unittest/src/ref_count_collect_test.cpp b/services/samgr/native/test/unittest/src/ref_count_collect_test.cpp index 77e3d1537fc54e90f1ce35f6805987244a7970c7..b0a9c4802d28c66c55581b3b00f6e9ff278632f0 100644 --- a/services/samgr/native/test/unittest/src/ref_count_collect_test.cpp +++ b/services/samgr/native/test/unittest/src/ref_count_collect_test.cpp @@ -130,6 +130,7 @@ HWTEST_F(RefCountCollectTest, OnStart001, TestSize.Level1) auto ret = collect->OnStart(); EXPECT_EQ(ret, ERR_OK); ret = collect->OnStop(); + usleep(500 * 1000); EXPECT_EQ(ret, ERR_OK); } @@ -147,6 +148,7 @@ HWTEST_F(RefCountCollectTest, OnStart002, TestSize.Level1) auto ret = collect->OnStart(); EXPECT_EQ(ret, ERR_OK); ret = collect->OnStop(); + usleep(500 * 1000); EXPECT_EQ(ret, ERR_OK); } @@ -164,6 +166,7 @@ HWTEST_F(RefCountCollectTest, OnStart003, TestSize.Level1) auto ret = collect->OnStart(); EXPECT_EQ(ret, ERR_OK); ret = collect->OnStop(); + usleep(500 * 1000); EXPECT_EQ(ret, ERR_OK); }