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 <gtest/gtest.h> 17 #include <gmock/gmock.h> 18 19 // mock 20 #include "alarm_timer_manager.h" 21 #include "setting_data_manager.h" 22 23 #define private public 24 #include "dark_mode_manager.h" 25 #undef private 26 27 using namespace testing; 28 using namespace testing::ext; 29 30 namespace OHOS::ArkUi::UiAppearance { 31 namespace { 32 const std::string SETTING_DARK_MODE_MODE = "settings.uiappearance.darkmode_mode"; 33 const std::string SETTING_DARK_MODE_START_TIME = "settings.uiappearance.darkmode_starttime"; 34 const std::string SETTING_DARK_MODE_END_TIME = "settings.uiappearance.darkmode_endtime"; 35 constexpr int32_t SETTING_NUM = 3; 36 constexpr int32_t TEST_USER100 = 100; 37 constexpr int32_t TEST_USER101 = 101; 38 constexpr int32_t TEST_USER1 = 1; 39 constexpr ErrCode TEST_ERROR = 123456; 40 using DarkModeMode = DarkModeManager::DarkModeMode; 41 } 42 43 class DarkModeManagerInitializeTest : public Test { 44 protected: TearDown()45 void TearDown() override 46 { 47 DarkModeManager& manager = DarkModeManager::GetInstance(); 48 manager.settingDataObservers_.clear(); 49 manager.settingDataObserversUserId_ = INVALID_USER_ID; 50 manager.darkModeStates_.clear(); 51 manager.updateCallback_ = nullptr; 52 } 53 54 MOCK_METHOD(void, UpdateCallback1, (bool, int32_t), (const)); 55 MOCK_METHOD(void, UpdateCallback2, (bool, int32_t), (const)); 56 }; 57 58 class DarkModeManagerTest : public Test { 59 protected: SetUp()60 void SetUp() override 61 { 62 DarkModeManager& manager = DarkModeManager::GetInstance(); 63 EXPECT_EQ(manager.Initialize([this](const bool isDarkMode, const int32_t userId) { 64 UpdateCallback(isDarkMode, userId); 65 }), ERR_OK); 66 } 67 TearDown()68 void TearDown() override 69 { 70 DarkModeManager& manager = DarkModeManager::GetInstance(); 71 manager.settingDataObservers_.clear(); 72 manager.settingDataObserversUserId_ = INVALID_USER_ID; 73 manager.darkModeStates_.clear(); 74 manager.updateCallback_ = nullptr; 75 } 76 LoadUserSettingDataInvalidDarkModeTest(const int32_t userId,const int32_t darkMode,const int32_t startTime,const int32_t endTime,const DarkModeMode expectDarkMode) const77 void LoadUserSettingDataInvalidDarkModeTest(const int32_t userId, const int32_t darkMode, 78 const int32_t startTime, const int32_t endTime, const DarkModeMode expectDarkMode) const 79 { 80 ExpectationSet expectSet; 81 LoadUserSettingDataGetInt32ValueTest(userId, darkMode, startTime, endTime, expectSet); 82 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 83 84 DarkModeManager& manager = DarkModeManager::GetInstance(); 85 bool isDarkMode = false; 86 EXPECT_EQ(manager.LoadUserSettingData(userId, true, isDarkMode), ERR_INVALID_OPERATION); 87 EXPECT_EQ(isDarkMode, false); 88 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 89 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 90 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 91 } 92 LoadUserSettingDataAllDayModeTest(const int32_t userId,const bool needUpdateCallback,const int32_t darkMode,const int32_t startTime,const int32_t endTime,const DarkModeMode expectDarkMode) const93 void LoadUserSettingDataAllDayModeTest(const int32_t userId, const bool needUpdateCallback, const int32_t darkMode, 94 const int32_t startTime, const int32_t endTime, const DarkModeMode expectDarkMode) const 95 { 96 ExpectationSet expectSet; 97 LoadUserSettingDataGetInt32ValueTest(userId, darkMode, startTime, endTime, expectSet); 98 99 bool expectIsDarkMode = expectDarkMode == DarkModeMode::DARK_MODE_ALWAYS_DARK; 100 DarkModeManager& manager = DarkModeManager::GetInstance(); 101 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 102 if (needUpdateCallback) { 103 expectSet += EXPECT_CALL(*this, UpdateCallback(expectIsDarkMode, userId)).Times(1).After(expectSet); 104 } else { 105 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 106 } 107 108 bool isDarkMode = !expectIsDarkMode; 109 EXPECT_EQ(manager.LoadUserSettingData(userId, needUpdateCallback, isDarkMode), ERR_OK); 110 EXPECT_EQ(isDarkMode, expectIsDarkMode); 111 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 112 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 113 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 114 } 115 LoadUserSettingDataCustomAutoModeSetTimerFailTest(const int32_t userId,const int32_t darkMode,const int32_t startTime,const int32_t endTime,const DarkModeMode expectDarkMode) const116 void LoadUserSettingDataCustomAutoModeSetTimerFailTest(const int32_t userId, const int32_t darkMode, 117 const int32_t startTime, const int32_t endTime, const DarkModeMode expectDarkMode) const 118 { 119 ExpectationSet expectSet; 120 LoadUserSettingDataGetInt32ValueTest(userId, darkMode, startTime, endTime, expectSet); 121 122 DarkModeManager& manager = DarkModeManager::GetInstance(); 123 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 124 .Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 125 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 126 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 127 128 bool isDarkMode = false; 129 EXPECT_EQ(manager.LoadUserSettingData(userId, true, isDarkMode), TEST_ERROR); 130 EXPECT_EQ(isDarkMode, false); 131 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 132 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 133 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 134 } 135 LoadUserSettingDataCustomAutoModeTest(const int32_t userId,const bool needUpdateCallback,const int32_t darkMode,const int32_t startTime,const int32_t endTime,const DarkModeMode expectDarkMode,const bool expectWithin) const136 void LoadUserSettingDataCustomAutoModeTest(const int32_t userId, const bool needUpdateCallback, 137 const int32_t darkMode, const int32_t startTime, const int32_t endTime, 138 const DarkModeMode expectDarkMode, const bool expectWithin) const 139 { 140 ExpectationSet expectSet; 141 LoadUserSettingDataGetInt32ValueTest(userId, darkMode, startTime, endTime, expectSet); 142 143 DarkModeManager& manager = DarkModeManager::GetInstance(); 144 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 145 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 146 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 147 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval(startTime, endTime)) 148 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 149 if (needUpdateCallback) { 150 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)).Times(1).After(expectSet); 151 } else { 152 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 153 } 154 155 bool isDarkMode = !expectWithin; 156 EXPECT_EQ(manager.LoadUserSettingData(userId, needUpdateCallback, isDarkMode), ERR_OK); 157 EXPECT_EQ(isDarkMode, expectWithin); 158 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 159 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 160 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 161 } 162 NotifyDarkModeUpdateTest(const int32_t userId,const DarkModeMode origMode,const bool isDarkMode,const bool expectCallSetStringValue) const163 void NotifyDarkModeUpdateTest(const int32_t userId, const DarkModeMode origMode, 164 const bool isDarkMode, const bool expectCallSetStringValue) const 165 { 166 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 167 DarkModeMode newMode = isDarkMode ? DarkModeMode::DARK_MODE_ALWAYS_DARK : DarkModeMode::DARK_MODE_ALWAYS_LIGHT; 168 if (expectCallSetStringValue) { 169 EXPECT_CALL(dataManager, MockSetStringValue(SETTING_DARK_MODE_MODE, std::to_string(newMode), userId, true)) 170 .Times(1).WillOnce(Return(ERR_OK)); 171 } else { 172 EXPECT_CALL(dataManager, MockSetStringValue(_, _, _, _)).Times(0); 173 } 174 175 DarkModeManager& manager = DarkModeManager::GetInstance(); 176 auto& state = manager.darkModeStates_[userId]; 177 state.settingMode = origMode; 178 manager.NotifyDarkModeUpdate(userId, isDarkMode); 179 } 180 OnSwitchUserTest(const int32_t userId,const int32_t origUserId,const bool registerObsFail) const181 void OnSwitchUserTest(const int32_t userId, const int32_t origUserId, const bool registerObsFail) const 182 { 183 DarkModeManager& manager = DarkModeManager::GetInstance(); 184 manager.settingDataObserversUserId_ = origUserId; 185 186 ExpectationSet expectSet; 187 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 188 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(true)); 189 if (origUserId != INVALID_USER_ID) { 190 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(origUserId)) 191 .Times(1).After(expectSet); 192 ExpectationSet input = expectSet; 193 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_MODE, origUserId)) 194 .Times(1).After(input).WillOnce(Return(ERR_OK)); 195 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_START_TIME, origUserId)) 196 .Times(1).After(input).WillOnce(Return(ERR_OK)); 197 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_END_TIME, origUserId)) 198 .Times(1).After(input).WillOnce(Return(ERR_OK)); 199 } 200 201 ExpectationSet input = expectSet; 202 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_MODE, _, userId)) 203 .Times(1).After(input).WillOnce(Return(registerObsFail ? TEST_ERROR : ERR_OK)); 204 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_START_TIME, _, userId)) 205 .Times(1).After(input).WillOnce(Return(ERR_OK)); 206 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_END_TIME, _, userId)) 207 .Times(1).After(input).WillOnce(Return(ERR_OK)); 208 209 EXPECT_EQ(manager.OnSwitchUser(userId), registerObsFail ? ERR_NO_INIT : ERR_OK); 210 EXPECT_EQ(manager.settingDataObserversUserId_, userId); 211 } 212 RestartTimerNoChangeTest(const int32_t userId,const DarkModeMode mode) const213 void RestartTimerNoChangeTest(const int32_t userId, const DarkModeMode mode) const 214 { 215 DarkModeManager& manager = DarkModeManager::GetInstance(); 216 manager.settingDataObserversUserId_ = userId; 217 manager.darkModeStates_[userId].settingMode = mode; 218 EXPECT_EQ(manager.RestartTimer(), ERR_OK); 219 } 220 RestartTimerTest(const int32_t userId,const int32_t startTime,const int32_t endTime,const bool expectWithin) const221 void RestartTimerTest(const int32_t userId, const int32_t startTime, const int32_t endTime, 222 const bool expectWithin) const 223 { 224 ExpectationSet expectSet; 225 DarkModeManager& manager = DarkModeManager::GetInstance(); 226 manager.settingDataObserversUserId_ = userId; 227 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 228 manager.darkModeStates_[userId].settingStartTime = startTime; 229 manager.darkModeStates_[userId].settingEndTime = endTime; 230 231 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 232 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval(startTime, endTime)) 233 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 234 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)).Times(1).After(expectSet); 235 expectSet += EXPECT_CALL(manager.alarmTimerManager_, RestartAllTimer()) 236 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 237 EXPECT_EQ(manager.RestartTimer(), ERR_OK); 238 } 239 ModeUpdateFuncFailTest(const int32_t userId,const DarkModeMode getDarkMode) const240 void ModeUpdateFuncFailTest(const int32_t userId, const DarkModeMode getDarkMode) const 241 { 242 DarkModeManager& manager = DarkModeManager::GetInstance(); 243 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 244 ExpectationSet expectSet; 245 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 246 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 247 248 auto checkSettingDarkModeMode = [getDarkMode](Unused, int32_t& value, Unused) { 249 value = getDarkMode; 250 return TEST_ERROR; 251 }; 252 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 253 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 254 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 255 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 256 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, DarkModeMode::DARK_MODE_INVALID); 257 } 258 ModeUpdateFuncAllDayTest(const int32_t userId,const DarkModeMode getDarkMode) const259 void ModeUpdateFuncAllDayTest(const int32_t userId, const DarkModeMode getDarkMode) const 260 { 261 DarkModeManager& manager = DarkModeManager::GetInstance(); 262 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 263 ExpectationSet expectSet; 264 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 265 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 266 267 auto checkSettingDarkModeMode = [getDarkMode](Unused, int32_t& value, Unused) { 268 value = getDarkMode; 269 return ERR_OK; 270 }; 271 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 272 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 273 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 274 expectSet += EXPECT_CALL(*this, UpdateCallback(getDarkMode == DarkModeMode::DARK_MODE_ALWAYS_DARK, userId)) 275 .Times(1).After(expectSet); 276 277 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 278 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, getDarkMode); 279 } 280 ModeUpdateFuncCustomAutoFailTest(const int32_t userId,const int32_t startTime,const int32_t endTime) const281 void ModeUpdateFuncCustomAutoFailTest(const int32_t userId, const int32_t startTime, const int32_t endTime) const 282 { 283 DarkModeManager& manager = DarkModeManager::GetInstance(); 284 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 285 manager.darkModeStates_[userId].settingStartTime = startTime; 286 manager.darkModeStates_[userId].settingEndTime = endTime; 287 288 ExpectationSet expectSet; 289 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 290 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 291 292 auto checkSettingDarkModeMode = [](Unused, int32_t& value, Unused) { 293 value = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 294 return ERR_OK; 295 }; 296 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 297 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 298 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 299 .Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 300 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 301 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 302 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 303 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 304 } 305 ModeUpdateFuncCustomAutoTest(const int32_t userId,const int32_t startTime,const int32_t endTime,const bool expectWithin) const306 void ModeUpdateFuncCustomAutoTest(const int32_t userId, const int32_t startTime, const int32_t endTime, 307 const bool expectWithin) const 308 { 309 DarkModeManager& manager = DarkModeManager::GetInstance(); 310 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 311 manager.darkModeStates_[userId].settingStartTime = startTime; 312 manager.darkModeStates_[userId].settingEndTime = endTime; 313 314 ExpectationSet expectSet; 315 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 316 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 317 318 auto checkSettingDarkModeMode = [](Unused, int32_t& value, Unused) { 319 value = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 320 return ERR_OK; 321 }; 322 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 323 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 324 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 325 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 326 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 327 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval(startTime, endTime)) 328 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 329 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)) 330 .Times(1).After(expectSet); 331 332 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 333 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 334 } 335 TimeUpdateFuncFailTest(const int32_t userId,const std::string & key,const int32_t expectValue,const int32_t code) const336 void TimeUpdateFuncFailTest(const int32_t userId, const std::string& key, 337 const int32_t expectValue, const int32_t code) const 338 { 339 DarkModeManager& manager = DarkModeManager::GetInstance(); 340 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 341 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_INVALID; 342 343 ExpectationSet expectSet; 344 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 345 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 346 347 auto checkSettingDarkModeTime = [expectValue, code](Unused, int32_t& value, Unused) { 348 if (code == ERR_OK) { 349 value = expectValue; 350 } 351 return code; 352 }; 353 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 354 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 355 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 356 updateFuncMap[key](key, userId); 357 if (key == SETTING_DARK_MODE_START_TIME) { 358 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, code == ERR_OK ? expectValue : -1); 359 } else { 360 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, code == ERR_OK ? expectValue : -1); 361 } 362 } 363 TimeUpdateFuncAllDayTest(const int32_t userId,DarkModeMode mode,const std::string & key,const int32_t expectValue) const364 void TimeUpdateFuncAllDayTest(const int32_t userId, DarkModeMode mode, const std::string& key, 365 const int32_t expectValue) const 366 { 367 DarkModeManager& manager = DarkModeManager::GetInstance(); 368 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 369 manager.darkModeStates_[userId].settingMode = mode; 370 371 ExpectationSet expectSet; 372 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 373 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 374 375 auto checkSettingDarkModeTime = [expectValue](Unused, int32_t& value, Unused) { 376 value = expectValue; 377 return ERR_OK; 378 }; 379 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 380 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 381 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 382 expectSet += EXPECT_CALL(*this, UpdateCallback(mode == DarkModeMode::DARK_MODE_ALWAYS_DARK, userId)) 383 .Times(1).After(expectSet); 384 updateFuncMap[key](key, userId); 385 if (key == SETTING_DARK_MODE_START_TIME) { 386 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, expectValue); 387 } else { 388 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, expectValue); 389 } 390 } 391 TimeUpdateFuncCustomAutoFailTest(const int32_t userId,const std::string & key,const int32_t expectValue,const int32_t otherValue) const392 void TimeUpdateFuncCustomAutoFailTest(const int32_t userId, const std::string& key, const int32_t expectValue, 393 const int32_t otherValue) const 394 { 395 DarkModeManager& manager = DarkModeManager::GetInstance(); 396 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 397 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 398 399 ExpectationSet expectSet; 400 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 401 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 402 403 auto checkSettingDarkModeTime = [expectValue](Unused, int32_t& value, Unused) { 404 value = expectValue; 405 return ERR_OK; 406 }; 407 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 408 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 409 int32_t startTime; 410 int32_t endTime; 411 if (key == SETTING_DARK_MODE_START_TIME) { 412 startTime = expectValue; 413 endTime = otherValue; 414 manager.darkModeStates_[userId].settingEndTime = otherValue; 415 } else { 416 startTime = otherValue; 417 endTime = expectValue; 418 manager.darkModeStates_[userId].settingStartTime = otherValue; 419 } 420 421 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 422 .Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 423 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 424 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 425 updateFuncMap[key](key, userId); 426 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 427 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 428 } 429 TimeUpdateFuncCustomAutoTest(const int32_t userId,const std::string & key,const int32_t expectValue,const int32_t otherValue,const bool expectWithin) const430 void TimeUpdateFuncCustomAutoTest(const int32_t userId, const std::string& key, const int32_t expectValue, 431 const int32_t otherValue, const bool expectWithin) const 432 { 433 DarkModeManager& manager = DarkModeManager::GetInstance(); 434 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 435 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 436 437 ExpectationSet expectSet; 438 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 439 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 440 441 auto checkSettingDarkModeTime = [expectValue](Unused, int32_t& value, Unused) { 442 value = expectValue; 443 return ERR_OK; 444 }; 445 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 446 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 447 int32_t startTime; 448 int32_t endTime; 449 if (key == SETTING_DARK_MODE_START_TIME) { 450 startTime = expectValue; 451 endTime = otherValue; 452 manager.darkModeStates_[userId].settingEndTime = otherValue; 453 } else { 454 startTime = otherValue; 455 endTime = expectValue; 456 manager.darkModeStates_[userId].settingStartTime = otherValue; 457 } 458 459 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 460 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 461 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 462 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval(startTime, endTime)) 463 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 464 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)) 465 .Times(1).After(expectSet); 466 updateFuncMap[key](key, userId); 467 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 468 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 469 } 470 TimerCallbackFailTest(const int32_t userId,const int32_t startTime,const int32_t endTime,const DarkModeMode stateMode,const int32_t stateStartTime,const int32_t stateEndTine) const471 void TimerCallbackFailTest(const int32_t userId, const int32_t startTime, const int32_t endTime, 472 const DarkModeMode stateMode, const int32_t stateStartTime, const int32_t stateEndTine) const 473 { 474 DarkModeManager& manager = DarkModeManager::GetInstance(); 475 manager.darkModeStates_[userId].settingMode = stateMode; 476 manager.darkModeStates_[userId].settingStartTime = stateStartTime; 477 manager.darkModeStates_[userId].settingEndTime = stateEndTine; 478 479 ExpectationSet expectSet; 480 std::function<void()> startCallbackFunc; 481 std::function<void()> endCallbackFunc; 482 auto checkSetScheduleTime = [&startCallbackFunc, &endCallbackFunc](Unused, Unused, Unused, 483 const std::function<void()>& startCallback, const std::function<void()>& endCallback) { 484 startCallbackFunc = startCallback; 485 endCallbackFunc = endCallback; 486 return ERR_OK; 487 }; 488 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 489 .Times(1).After(expectSet).WillOnce(Invoke(checkSetScheduleTime)); 490 EXPECT_EQ(manager.CreateOrUpdateTimers(startTime, endTime, userId), ERR_OK); 491 EXPECT_NE(startCallbackFunc, nullptr); 492 EXPECT_NE(endCallbackFunc, nullptr); 493 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 494 startCallbackFunc(); 495 endCallbackFunc(); 496 } 497 TimerCallbackTest(const int32_t userId,const int32_t startTime,const int32_t endTime) const498 void TimerCallbackTest(const int32_t userId, const int32_t startTime, const int32_t endTime) const 499 { 500 DarkModeManager& manager = DarkModeManager::GetInstance(); 501 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 502 manager.darkModeStates_[userId].settingStartTime = startTime; 503 manager.darkModeStates_[userId].settingEndTime = endTime; 504 505 ExpectationSet expectSet; 506 std::function<void()> startCallbackFunc; 507 std::function<void()> endCallbackFunc; 508 auto checkSetScheduleTime = [&startCallbackFunc, &endCallbackFunc](Unused, Unused, Unused, 509 const std::function<void()>& startCallback, const std::function<void()>& endCallback) { 510 startCallbackFunc = startCallback; 511 endCallbackFunc = endCallback; 512 return ERR_OK; 513 }; 514 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 515 .Times(1).After(expectSet).WillOnce(Invoke(checkSetScheduleTime)); 516 EXPECT_EQ(manager.CreateOrUpdateTimers(startTime, endTime, userId), ERR_OK); 517 EXPECT_NE(startCallbackFunc, nullptr); 518 EXPECT_NE(endCallbackFunc, nullptr); 519 520 expectSet += EXPECT_CALL(*this, UpdateCallback(true, userId)).Times(1).After(expectSet); 521 startCallbackFunc(); 522 expectSet += EXPECT_CALL(*this, UpdateCallback(false, userId)).Times(1).After(expectSet); 523 endCallbackFunc(); 524 } 525 526 MOCK_METHOD(void, UpdateCallback, (bool, int32_t), (const)); 527 528 private: LoadUserSettingDataGetInt32ValueTest(const int32_t userId,const int32_t darkMode,const int32_t startTime,const int32_t endTime,ExpectationSet & expectSet) const529 void LoadUserSettingDataGetInt32ValueTest(const int32_t userId, const int32_t darkMode, 530 const int32_t startTime, const int32_t endTime, ExpectationSet& expectSet) const 531 { 532 ExpectationSet input = expectSet; 533 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 534 auto checkSettingDarkModeMode = [darkMode](Unused, int32_t& value, Unused) { 535 value = darkMode; 536 return ERR_OK; 537 }; 538 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 539 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeMode)); 540 auto checkSettingDarkModeStartTime = [startTime](Unused, int32_t& value, Unused) { 541 value = startTime; 542 return ERR_OK; 543 }; 544 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_START_TIME, _, userId)) 545 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeStartTime)); 546 auto checkSettingDarkModeEndTime = [endTime](Unused, int32_t& value, Unused) { 547 value = endTime; 548 return ERR_OK; 549 }; 550 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_END_TIME, _, userId)) 551 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeEndTime)); 552 } 553 GetUpdateFuncMap(const int32_t userId,ExpectationSet & expectSet,std::map<std::string,std::function<void (const std::string &,int32_t)>> & updateFuncMap) const554 void GetUpdateFuncMap(const int32_t userId, ExpectationSet& expectSet, 555 std::map<std::string, std::function<void(const std::string&, int32_t)>>& updateFuncMap) const 556 { 557 DarkModeManager& manager = DarkModeManager::GetInstance(); 558 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 559 560 manager.settingDataObserversUserId_ = INVALID_USER_ID; 561 expectSet += EXPECT_CALL(settingDataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(true)); 562 auto checkRegisterObserver = [&updateFuncMap](const std::string& key, 563 const std::function<void(const std::string&, int32_t)>& updateFunc, Unused) { 564 updateFuncMap[key] = updateFunc; 565 return ERR_OK; 566 }; 567 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_MODE, _, userId)) 568 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 569 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_START_TIME, _, userId)) 570 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 571 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_END_TIME, _, userId)) 572 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 573 EXPECT_EQ(manager.OnSwitchUser(userId), ERR_OK); 574 EXPECT_EQ(manager.settingDataObserversUserId_, userId); 575 EXPECT_EQ(updateFuncMap.size(), SETTING_NUM); 576 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_MODE], nullptr); 577 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_START_TIME], nullptr); 578 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_END_TIME], nullptr); 579 } 580 }; 581 582 HWTEST_F(DarkModeManagerInitializeTest, InitializeTest_0100, TestSize.Level1) 583 { 584 DarkModeManager& manager = DarkModeManager::GetInstance(); 585 EXPECT_EQ(manager.settingDataObservers_.size(), 0); 586 EXPECT_EQ(manager.settingDataObserversUserId_, INVALID_USER_ID); 587 EXPECT_EQ(manager.darkModeStates_.size(), 0); 588 EXPECT_EQ(manager.updateCallback_, nullptr); 589 __anon202329321102(const bool isDarkMode, const int32_t userId) 590 EXPECT_EQ(manager.Initialize([this](const bool isDarkMode, const int32_t userId) { 591 UpdateCallback1(isDarkMode, userId); 592 }), ERR_OK); 593 EXPECT_EQ(manager.settingDataObservers_.size(), SETTING_NUM); 594 EXPECT_EQ(manager.settingDataObserversUserId_, INVALID_USER_ID); 595 EXPECT_EQ(manager.darkModeStates_.size(), 0); 596 EXPECT_NE(manager.updateCallback_, nullptr); 597 598 EXPECT_CALL(*this, UpdateCallback1(true, INVALID_USER_ID)).Times(1); 599 EXPECT_CALL(*this, UpdateCallback1(false, TEST_USER1)).Times(1); 600 EXPECT_CALL(*this, UpdateCallback1(true, TEST_USER100)).Times(1); 601 manager.updateCallback_(true, INVALID_USER_ID); 602 manager.updateCallback_(false, TEST_USER1); 603 manager.updateCallback_(true, TEST_USER100); 604 __anon202329321202(const bool isDarkMode, const int32_t userId) 605 EXPECT_EQ(manager.Initialize([this](const bool isDarkMode, const int32_t userId) { 606 UpdateCallback2(isDarkMode, userId); 607 }), ERR_OK); 608 EXPECT_EQ(manager.settingDataObservers_.size(), SETTING_NUM); 609 EXPECT_EQ(manager.settingDataObserversUserId_, INVALID_USER_ID); 610 EXPECT_EQ(manager.darkModeStates_.size(), 0); 611 EXPECT_NE(manager.updateCallback_, nullptr); 612 613 EXPECT_CALL(*this, UpdateCallback2(true, INVALID_USER_ID)).Times(1); 614 EXPECT_CALL(*this, UpdateCallback2(false, TEST_USER1)).Times(1); 615 EXPECT_CALL(*this, UpdateCallback2(true, TEST_USER100)).Times(1); 616 manager.updateCallback_(true, INVALID_USER_ID); 617 manager.updateCallback_(false, TEST_USER1); 618 manager.updateCallback_(true, TEST_USER100); 619 } 620 621 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0100, TestSize.Level1) 622 { 623 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, -2, -2, 1, DarkModeMode::DARK_MODE_INVALID); 624 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, -1, -1, 0, DarkModeMode::DARK_MODE_INVALID); 625 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, 3, 0, -1, DarkModeMode::DARK_MODE_INVALID); 626 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, 4, 1, -2, DarkModeMode::DARK_MODE_INVALID); 627 628 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, -2, -2, 1, DarkModeMode::DARK_MODE_INVALID); 629 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, -1, -1, 0, DarkModeMode::DARK_MODE_INVALID); 630 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, 3, 0, -1, DarkModeMode::DARK_MODE_INVALID); 631 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, 4, 1, -2, DarkModeMode::DARK_MODE_INVALID); 632 633 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, -2, -2, 1, DarkModeMode::DARK_MODE_INVALID); 634 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, -1, -1, 0, DarkModeMode::DARK_MODE_INVALID); 635 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, 3, 0, -1, DarkModeMode::DARK_MODE_INVALID); 636 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, 4, 1, -2, DarkModeMode::DARK_MODE_INVALID); 637 } 638 639 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0200, TestSize.Level1) 640 { 641 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, true, 0, -2, 1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 642 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, false, 0, -1, 0, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 643 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, true, 1, 0, -1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 644 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, false, 1, 1, -2, DarkModeMode::DARK_MODE_ALWAYS_DARK); 645 646 LoadUserSettingDataAllDayModeTest(TEST_USER1, true, 0, -2, 1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 647 LoadUserSettingDataAllDayModeTest(TEST_USER1, false, 0, -1, 0, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 648 LoadUserSettingDataAllDayModeTest(TEST_USER1, true, 1, 0, -1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 649 LoadUserSettingDataAllDayModeTest(TEST_USER1, false, 1, 1, -2, DarkModeMode::DARK_MODE_ALWAYS_DARK); 650 651 LoadUserSettingDataAllDayModeTest(TEST_USER100, true, 0, -2, 1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 652 LoadUserSettingDataAllDayModeTest(TEST_USER100, false, 0, -1, 0, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 653 LoadUserSettingDataAllDayModeTest(TEST_USER100, true, 1, 0, -1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 654 LoadUserSettingDataAllDayModeTest(TEST_USER100, false, 1, 1, -2, DarkModeMode::DARK_MODE_ALWAYS_DARK); 655 } 656 657 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0300, TestSize.Level1) 658 { 659 LoadUserSettingDataCustomAutoModeSetTimerFailTest(INVALID_USER_ID, 2, -2, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 660 LoadUserSettingDataCustomAutoModeSetTimerFailTest(TEST_USER1, 2, -1, 0, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 661 LoadUserSettingDataCustomAutoModeSetTimerFailTest(TEST_USER100, 2, 0, -1, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 662 } 663 664 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0400, TestSize.Level1) 665 { 666 LoadUserSettingDataCustomAutoModeTest(INVALID_USER_ID, true, 2, -2, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 667 LoadUserSettingDataCustomAutoModeTest(INVALID_USER_ID, false, 2, -1, 0, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 668 LoadUserSettingDataCustomAutoModeTest(INVALID_USER_ID, true, 2, 0, -1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 669 LoadUserSettingDataCustomAutoModeTest(INVALID_USER_ID, false, 2, 1, -2, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 670 671 LoadUserSettingDataCustomAutoModeTest(TEST_USER1, true, 2, -2, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 672 LoadUserSettingDataCustomAutoModeTest(TEST_USER1, false, 2, -1, 0, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 673 LoadUserSettingDataCustomAutoModeTest(TEST_USER1, true, 2, 0, -1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 674 LoadUserSettingDataCustomAutoModeTest(TEST_USER1, false, 2, 1, -2, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 675 676 LoadUserSettingDataCustomAutoModeTest(TEST_USER100, true, 2, -2, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 677 LoadUserSettingDataCustomAutoModeTest(TEST_USER100, false, 2, -1, 0, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 678 LoadUserSettingDataCustomAutoModeTest(TEST_USER100, true, 2, 0, -1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 679 LoadUserSettingDataCustomAutoModeTest(TEST_USER100, false, 2, 1, -2, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 680 } 681 682 HWTEST_F(DarkModeManagerTest, NotifyDarkModeUpdate_0100, TestSize.Level1) 683 { 684 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_INVALID, true, true); 685 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_INVALID, false, true); 686 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, true, true); 687 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, false, false); 688 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_DARK, true, false); 689 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_DARK, false, true); 690 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true, false); 691 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false, false); 692 } 693 694 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0100, TestSize.Level1) 695 { 696 ExpectationSet expectSet; 697 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 698 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(false)); 699 expectSet += EXPECT_CALL(dataManager, Initialize()).Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 700 DarkModeManager& manager = DarkModeManager::GetInstance(); 701 EXPECT_EQ(manager.OnSwitchUser(INVALID_USER_ID), ERR_NO_INIT); 702 } 703 704 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0200, TestSize.Level1) 705 { 706 ExpectationSet expectSet; 707 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 708 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(false)); 709 expectSet += EXPECT_CALL(dataManager, Initialize()).Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 710 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(false)); 711 DarkModeManager& manager = DarkModeManager::GetInstance(); 712 EXPECT_EQ(manager.OnSwitchUser(INVALID_USER_ID), ERR_NO_INIT); 713 } 714 715 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0300, TestSize.Level1) 716 { 717 ExpectationSet expectSet; 718 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 719 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(true)); 720 DarkModeManager& manager = DarkModeManager::GetInstance(); 721 EXPECT_EQ(manager.OnSwitchUser(INVALID_USER_ID), ERR_INVALID_OPERATION); 722 } 723 724 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0400, TestSize.Level1) 725 { 726 OnSwitchUserTest(TEST_USER1, TEST_USER1, true); 727 OnSwitchUserTest(TEST_USER100, TEST_USER100, true); 728 OnSwitchUserTest(TEST_USER101, TEST_USER101, true); 729 730 OnSwitchUserTest(TEST_USER1, TEST_USER1, false); 731 OnSwitchUserTest(TEST_USER100, TEST_USER100, false); 732 OnSwitchUserTest(TEST_USER101, TEST_USER101, false); 733 } 734 735 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0500, TestSize.Level1) 736 { 737 OnSwitchUserTest(TEST_USER1, INVALID_USER_ID, false); 738 OnSwitchUserTest(TEST_USER1, TEST_USER100, false); 739 OnSwitchUserTest(TEST_USER1, TEST_USER101, false); 740 OnSwitchUserTest(TEST_USER100, INVALID_USER_ID, false); 741 OnSwitchUserTest(TEST_USER100, TEST_USER1, false); 742 OnSwitchUserTest(TEST_USER100, TEST_USER101, false); 743 OnSwitchUserTest(TEST_USER101, INVALID_USER_ID, false); 744 OnSwitchUserTest(TEST_USER101, TEST_USER1, false); 745 OnSwitchUserTest(TEST_USER101, TEST_USER100, false); 746 747 OnSwitchUserTest(TEST_USER1, INVALID_USER_ID, true); 748 OnSwitchUserTest(TEST_USER1, TEST_USER100, true); 749 OnSwitchUserTest(TEST_USER1, TEST_USER101, true); 750 OnSwitchUserTest(TEST_USER100, INVALID_USER_ID, true); 751 OnSwitchUserTest(TEST_USER100, TEST_USER1, true); 752 OnSwitchUserTest(TEST_USER100, TEST_USER101, true); 753 OnSwitchUserTest(TEST_USER101, INVALID_USER_ID, true); 754 OnSwitchUserTest(TEST_USER101, TEST_USER1, true); 755 OnSwitchUserTest(TEST_USER101, TEST_USER100, true); 756 } 757 758 HWTEST_F(DarkModeManagerTest, RestartTimer_0100, TestSize.Level1) 759 { 760 RestartTimerNoChangeTest(TEST_USER1, DarkModeMode::DARK_MODE_INVALID); 761 RestartTimerNoChangeTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 762 RestartTimerNoChangeTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 763 RestartTimerNoChangeTest(TEST_USER100, DarkModeMode::DARK_MODE_INVALID); 764 RestartTimerNoChangeTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 765 RestartTimerNoChangeTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK); 766 RestartTimerNoChangeTest(TEST_USER101, DarkModeMode::DARK_MODE_INVALID); 767 RestartTimerNoChangeTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 768 RestartTimerNoChangeTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK); 769 } 770 771 HWTEST_F(DarkModeManagerTest, RestartTimer_0200, TestSize.Level1) 772 { 773 RestartTimerTest(TEST_USER1, -1, 4, true); 774 RestartTimerTest(TEST_USER1, 0, 3, false); 775 RestartTimerTest(TEST_USER100, 1, 2, true); 776 RestartTimerTest(TEST_USER100, 2, 1, false); 777 RestartTimerTest(TEST_USER101, 3, 0, true); 778 RestartTimerTest(TEST_USER101, 4, -1, false); 779 } 780 781 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0100, TestSize.Level1) 782 { 783 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_INVALID); 784 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 785 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 786 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 787 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_SIZE); 788 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_INVALID); 789 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK); 790 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 791 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 792 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_SIZE); 793 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_INVALID); 794 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK); 795 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 796 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 797 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_SIZE); 798 } 799 800 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0200, TestSize.Level1) 801 { 802 ModeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 803 ModeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 804 ModeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK); 805 ModeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 806 ModeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK); 807 ModeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 808 } 809 810 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0300, TestSize.Level1) 811 { 812 ModeUpdateFuncCustomAutoFailTest(TEST_USER1, 0, 5); 813 ModeUpdateFuncCustomAutoFailTest(TEST_USER1, 1, 4); 814 ModeUpdateFuncCustomAutoFailTest(TEST_USER100, 2, 3); 815 ModeUpdateFuncCustomAutoFailTest(TEST_USER100, 3, 2); 816 ModeUpdateFuncCustomAutoFailTest(TEST_USER101, 4, 1); 817 ModeUpdateFuncCustomAutoFailTest(TEST_USER101, 5, 0); 818 } 819 820 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0400, TestSize.Level1) 821 { 822 ModeUpdateFuncCustomAutoTest(TEST_USER1, 0, 5, true); 823 ModeUpdateFuncCustomAutoTest(TEST_USER1, 1, 4, false); 824 ModeUpdateFuncCustomAutoTest(TEST_USER100, 2, 3, true); 825 ModeUpdateFuncCustomAutoTest(TEST_USER100, 3, 2, false); 826 ModeUpdateFuncCustomAutoTest(TEST_USER101, 4, 1, true); 827 ModeUpdateFuncCustomAutoTest(TEST_USER101, 5, 0, false); 828 } 829 830 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0100, TestSize.Level1) 831 { 832 TimeUpdateFuncFailTest(TEST_USER1, SETTING_DARK_MODE_START_TIME, -1, ERR_OK); 833 TimeUpdateFuncFailTest(TEST_USER1, SETTING_DARK_MODE_END_TIME, 0, TEST_ERROR); 834 TimeUpdateFuncFailTest(TEST_USER100, SETTING_DARK_MODE_START_TIME, 1, ERR_OK); 835 TimeUpdateFuncFailTest(TEST_USER100, SETTING_DARK_MODE_END_TIME, 2, TEST_ERROR); 836 TimeUpdateFuncFailTest(TEST_USER101, SETTING_DARK_MODE_START_TIME, 3, ERR_OK); 837 TimeUpdateFuncFailTest(TEST_USER101, SETTING_DARK_MODE_END_TIME, 4, TEST_ERROR); 838 } 839 840 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0200, TestSize.Level1) 841 { 842 TimeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK, SETTING_DARK_MODE_START_TIME, -1); 843 TimeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, SETTING_DARK_MODE_END_TIME, 0); 844 TimeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK, SETTING_DARK_MODE_START_TIME, 1); 845 TimeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, SETTING_DARK_MODE_END_TIME, 2); 846 TimeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK, SETTING_DARK_MODE_START_TIME, 3); 847 TimeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, SETTING_DARK_MODE_END_TIME, 4); 848 } 849 850 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0300, TestSize.Level1) 851 { 852 TimeUpdateFuncCustomAutoFailTest(TEST_USER1, SETTING_DARK_MODE_START_TIME, -1, 4); 853 TimeUpdateFuncCustomAutoFailTest(TEST_USER1, SETTING_DARK_MODE_END_TIME, 0, 3); 854 TimeUpdateFuncCustomAutoFailTest(TEST_USER100, SETTING_DARK_MODE_START_TIME, 1, 2); 855 TimeUpdateFuncCustomAutoFailTest(TEST_USER100, SETTING_DARK_MODE_END_TIME, 2, 1); 856 TimeUpdateFuncCustomAutoFailTest(TEST_USER101, SETTING_DARK_MODE_START_TIME, 3, 0); 857 TimeUpdateFuncCustomAutoFailTest(TEST_USER101, SETTING_DARK_MODE_END_TIME, 4, -1); 858 } 859 860 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0400, TestSize.Level1) 861 { 862 TimeUpdateFuncCustomAutoTest(TEST_USER1, SETTING_DARK_MODE_START_TIME, -1, 4, true); 863 TimeUpdateFuncCustomAutoTest(TEST_USER1, SETTING_DARK_MODE_END_TIME, 0, 3, true); 864 TimeUpdateFuncCustomAutoTest(TEST_USER100, SETTING_DARK_MODE_START_TIME, 1, 2, true); 865 TimeUpdateFuncCustomAutoTest(TEST_USER100, SETTING_DARK_MODE_END_TIME, 2, 1, false); 866 TimeUpdateFuncCustomAutoTest(TEST_USER101, SETTING_DARK_MODE_START_TIME, 3, 0, false); 867 TimeUpdateFuncCustomAutoTest(TEST_USER101, SETTING_DARK_MODE_END_TIME, 4, -1, false); 868 } 869 870 HWTEST_F(DarkModeManagerTest, TimerCallback_0100, TestSize.Level1) 871 { 872 TimerCallbackFailTest(TEST_USER1, -1, 7, DarkModeMode::DARK_MODE_INVALID, -1, 7); 873 TimerCallbackFailTest(TEST_USER100, 0, 6, DarkModeMode::DARK_MODE_INVALID, 0, 6); 874 TimerCallbackFailTest(TEST_USER101, 1, 5, DarkModeMode::DARK_MODE_INVALID, 1, 5); 875 TimerCallbackFailTest(TEST_USER1, 2, 4, DarkModeMode::DARK_MODE_ALWAYS_DARK, 2, 4); 876 TimerCallbackFailTest(TEST_USER100, 3, 3, DarkModeMode::DARK_MODE_ALWAYS_DARK, 3, 3); 877 TimerCallbackFailTest(TEST_USER101, 4, 2, DarkModeMode::DARK_MODE_ALWAYS_DARK, 4, 2); 878 TimerCallbackFailTest(TEST_USER1, 5, 1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, 5, 1); 879 TimerCallbackFailTest(TEST_USER100, 6, 0, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, 6, 0); 880 TimerCallbackFailTest(TEST_USER101, 7, -1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, 7, -1); 881 882 TimerCallbackFailTest(TEST_USER1, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, 0, 1); 883 TimerCallbackFailTest(TEST_USER100, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, 0, 1); 884 TimerCallbackFailTest(TEST_USER101, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, 0, 1); 885 TimerCallbackFailTest(TEST_USER1, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, -1, 0); 886 TimerCallbackFailTest(TEST_USER100, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, -1, 0); 887 TimerCallbackFailTest(TEST_USER101, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, -1, 0); 888 } 889 890 HWTEST_F(DarkModeManagerTest, TimerCallback_0200, TestSize.Level1) 891 { 892 TimerCallbackTest(TEST_USER1, -1, 1); 893 TimerCallbackTest(TEST_USER100, 0, 0); 894 TimerCallbackTest(TEST_USER101, 1, -1); 895 } 896 } // namespace OHOS::ArkUi::UiAppearance 897