1 /* 2 * Copyright (c) 2024-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 <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 const std::string SETTING_DARK_MODE_SUN_SET = "settings.display.sun_set"; 36 const std::string SETTING_DARK_MODE_SUN_RISE = "settings.display.sun_rise"; 37 constexpr int32_t SETTING_NUM = 5; 38 constexpr int32_t TEST_USER100 = 100; 39 constexpr int32_t TEST_USER101 = 101; 40 constexpr int32_t TEST_USER1 = 1; 41 constexpr ErrCode TEST_ERROR = 123456; 42 constexpr int32_t TEST_DARK_MODE_STATE_NEGATIVE_TWO = -2; 43 constexpr int32_t TEST_DARK_MODE_STATE_NEGATIVE_ONE = -1; 44 constexpr int32_t TEST_DARK_MODE_STATE_ZERO = 0; 45 constexpr int32_t TEST_DARK_MODE_STATE_ONE = 1; 46 constexpr int32_t TEST_DARK_MODE_STATE_TWO = 2; 47 constexpr int32_t TEST_DARK_MODE_STATE_THREE = 3; 48 constexpr int32_t TEST_DARK_MODE_STATE_FOUR = 4; 49 constexpr int32_t TEST_DARK_MODE_STATE_FIVE = 5; 50 struct DarkModeState { 51 int32_t settingMode = -1; 52 int32_t settingStartTime = -1; 53 int32_t settingEndTime = -1; 54 int32_t settingSunsetTime = 1080; 55 int32_t settingSunriseTime = 1860; 56 }; 57 using DarkModeMode = DarkModeManager::DarkModeMode; 58 } 59 60 class DarkModeManagerInitializeTest : public Test { 61 protected: TearDown()62 void TearDown() override 63 { 64 DarkModeManager& manager = DarkModeManager::GetInstance(); 65 manager.settingDataObservers_.clear(); 66 manager.settingDataObserversUserId_ = INVALID_USER_ID; 67 manager.darkModeStates_.clear(); 68 manager.updateCallback_ = nullptr; 69 } 70 71 MOCK_METHOD(void, UpdateCallback1, (bool, int32_t), (const)); 72 MOCK_METHOD(void, UpdateCallback2, (bool, int32_t), (const)); 73 }; 74 75 class DarkModeManagerTest : public Test { 76 protected: SetUp()77 void SetUp() override 78 { 79 DarkModeManager& manager = DarkModeManager::GetInstance(); 80 EXPECT_EQ(manager.Initialize([this](const bool isDarkMode, const int32_t userId) { 81 UpdateCallback(isDarkMode, userId); 82 }), ERR_OK); 83 } 84 TearDown()85 void TearDown() override 86 { 87 DarkModeManager& manager = DarkModeManager::GetInstance(); 88 manager.settingDataObservers_.clear(); 89 manager.settingDataObserversUserId_ = INVALID_USER_ID; 90 manager.darkModeStates_.clear(); 91 manager.updateCallback_ = nullptr; 92 } 93 LoadUserSettingDataInvalidDarkModeTest(const int32_t userId,const DarkModeState darkModeState,const DarkModeMode expectDarkMode) const94 void LoadUserSettingDataInvalidDarkModeTest( 95 const int32_t userId, const DarkModeState darkModeState, const DarkModeMode expectDarkMode) const 96 { 97 ExpectationSet expectSet; 98 LoadUserSettingDataGetInt32ValueTest(userId, darkModeState, expectSet); 99 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 100 101 DarkModeManager& manager = DarkModeManager::GetInstance(); 102 bool isDarkMode = false; 103 EXPECT_EQ(manager.LoadUserSettingData(userId, true, isDarkMode, false), ERR_INVALID_OPERATION); 104 EXPECT_EQ(isDarkMode, false); 105 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 106 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, darkModeState.settingStartTime); 107 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, darkModeState.settingEndTime); 108 EXPECT_EQ(manager.darkModeStates_[userId].settingSunsetTime, darkModeState.settingSunsetTime); 109 EXPECT_EQ(manager.darkModeStates_[userId].settingSunriseTime, darkModeState.settingSunriseTime); 110 } 111 LoadUserSettingDataAllDayModeTest(const int32_t userId,const bool needUpdateCallback,const DarkModeState darkModeState,const DarkModeMode expectDarkMode) const112 void LoadUserSettingDataAllDayModeTest(const int32_t userId, const bool needUpdateCallback, 113 const DarkModeState darkModeState, const DarkModeMode expectDarkMode) const 114 { 115 ExpectationSet expectSet; 116 LoadUserSettingDataGetInt32ValueTest(userId, darkModeState, expectSet); 117 118 bool expectIsDarkMode = expectDarkMode == DarkModeMode::DARK_MODE_ALWAYS_DARK; 119 DarkModeManager& manager = DarkModeManager::GetInstance(); 120 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 121 if (needUpdateCallback) { 122 expectSet += EXPECT_CALL(*this, UpdateCallback(expectIsDarkMode, userId)).Times(1).After(expectSet); 123 } else { 124 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 125 } 126 127 bool isDarkMode = !expectIsDarkMode; 128 EXPECT_EQ(manager.LoadUserSettingData(userId, needUpdateCallback, isDarkMode, false), ERR_OK); 129 EXPECT_EQ(isDarkMode, expectIsDarkMode); 130 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 131 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, darkModeState.settingStartTime); 132 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, darkModeState.settingEndTime); 133 EXPECT_EQ(manager.darkModeStates_[userId].settingSunsetTime, darkModeState.settingSunsetTime); 134 EXPECT_EQ(manager.darkModeStates_[userId].settingSunriseTime, darkModeState.settingSunriseTime); 135 } 136 LoadUserSettingDataCustomAutoModeSetTimerFailTest(const int32_t userId,const DarkModeState darkModeState,const DarkModeMode expectDarkMode) const137 void LoadUserSettingDataCustomAutoModeSetTimerFailTest( 138 const int32_t userId, const DarkModeState darkModeState, const DarkModeMode expectDarkMode) const 139 { 140 ExpectationSet expectSet; 141 LoadUserSettingDataGetInt32ValueTest(userId, darkModeState, expectSet); 142 143 DarkModeManager& manager = DarkModeManager::GetInstance(); 144 if (expectDarkMode == DarkModeMode::DARK_MODE_CUSTOM_AUTO) { 145 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime( 146 darkModeState.settingStartTime, darkModeState.settingEndTime, userId, _, _)) 147 .Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 148 } else { 149 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime( 150 darkModeState.settingSunsetTime, darkModeState.settingSunriseTime, userId, _, _)) 151 .Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 152 } 153 154 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 155 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 156 157 bool isDarkMode = false; 158 EXPECT_EQ(manager.LoadUserSettingData(userId, true, isDarkMode, false), TEST_ERROR); 159 EXPECT_EQ(isDarkMode, false); 160 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 161 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, darkModeState.settingStartTime); 162 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, darkModeState.settingEndTime); 163 EXPECT_EQ(manager.darkModeStates_[userId].settingSunsetTime, darkModeState.settingSunsetTime); 164 EXPECT_EQ(manager.darkModeStates_[userId].settingSunriseTime, darkModeState.settingSunriseTime); 165 } 166 LoadUserSettingDataCustomAutoModeTest(const int32_t userId,const bool needUpdateCallback,const DarkModeState darkModeState,const DarkModeMode expectDarkMode,const bool expectWithin) const167 void LoadUserSettingDataCustomAutoModeTest(const int32_t userId, const bool needUpdateCallback, 168 const DarkModeState darkModeState, const DarkModeMode expectDarkMode, const bool expectWithin) const 169 { 170 ExpectationSet expectSet; 171 LoadUserSettingDataGetInt32ValueTest(userId, darkModeState, expectSet); 172 173 DarkModeManager& manager = DarkModeManager::GetInstance(); 174 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 175 if (expectDarkMode == DarkModeMode::DARK_MODE_CUSTOM_AUTO) { 176 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime( 177 darkModeState.settingStartTime, darkModeState.settingEndTime, userId, _, _)) 178 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 179 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval( 180 darkModeState.settingStartTime, darkModeState.settingEndTime)) 181 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 182 } else { 183 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime( 184 darkModeState.settingSunsetTime, darkModeState.settingSunriseTime, userId, _, _)) 185 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 186 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval( 187 darkModeState.settingSunsetTime, darkModeState.settingSunriseTime)) 188 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 189 } 190 191 if (needUpdateCallback) { 192 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)).Times(1).After(expectSet); 193 } else { 194 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 195 } 196 197 bool isDarkMode = !expectWithin; 198 EXPECT_EQ(manager.LoadUserSettingData(userId, needUpdateCallback, isDarkMode, false), ERR_OK); 199 EXPECT_EQ(isDarkMode, expectWithin); 200 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, expectDarkMode); 201 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, darkModeState.settingStartTime); 202 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, darkModeState.settingEndTime); 203 EXPECT_EQ(manager.darkModeStates_[userId].settingSunsetTime, darkModeState.settingSunsetTime); 204 EXPECT_EQ(manager.darkModeStates_[userId].settingSunriseTime, darkModeState.settingSunriseTime); 205 } 206 NotifyDarkModeUpdateTest(const int32_t userId,const DarkModeMode origMode,const bool isDarkMode,const bool expectCallSetStringValue) const207 void NotifyDarkModeUpdateTest(const int32_t userId, const DarkModeMode origMode, 208 const bool isDarkMode, const bool expectCallSetStringValue) const 209 { 210 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 211 DarkModeMode newMode = isDarkMode ? DarkModeMode::DARK_MODE_ALWAYS_DARK : DarkModeMode::DARK_MODE_ALWAYS_LIGHT; 212 if (expectCallSetStringValue) { 213 EXPECT_CALL(dataManager, MockSetStringValue(SETTING_DARK_MODE_MODE, std::to_string(newMode), userId, true)) 214 .Times(1).WillOnce(Return(ERR_OK)); 215 } else { 216 EXPECT_CALL(dataManager, MockSetStringValue(_, _, _, _)).Times(0); 217 } 218 219 DarkModeManager& manager = DarkModeManager::GetInstance(); 220 auto& state = manager.darkModeStates_[userId]; 221 state.settingMode = origMode; 222 manager.NotifyDarkModeUpdate(userId, isDarkMode); 223 } 224 OnSwitchUserTest(const int32_t userId,const int32_t origUserId,const bool registerObsFail) const225 void OnSwitchUserTest(const int32_t userId, const int32_t origUserId, const bool registerObsFail) const 226 { 227 DarkModeManager& manager = DarkModeManager::GetInstance(); 228 manager.settingDataObserversUserId_ = origUserId; 229 230 ExpectationSet expectSet; 231 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 232 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(true)); 233 if (origUserId != INVALID_USER_ID) { 234 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(origUserId)) 235 .Times(1).After(expectSet); 236 ExpectationSet input = expectSet; 237 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_MODE, origUserId)) 238 .Times(1).After(input).WillOnce(Return(ERR_OK)); 239 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_START_TIME, origUserId)) 240 .Times(1).After(input).WillOnce(Return(ERR_OK)); 241 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_END_TIME, origUserId)) 242 .Times(1).After(input).WillOnce(Return(ERR_OK)); 243 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_SUN_SET, origUserId)) 244 .Times(1).After(input).WillOnce(Return(ERR_OK)); 245 expectSet += EXPECT_CALL(dataManager, MockUnregisterObserver(SETTING_DARK_MODE_SUN_RISE, origUserId)) 246 .Times(1).After(input).WillOnce(Return(ERR_OK)); 247 } 248 249 ExpectationSet input = expectSet; 250 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_MODE, _, userId)) 251 .Times(1).After(input).WillOnce(Return(registerObsFail ? TEST_ERROR : ERR_OK)); 252 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_START_TIME, _, userId)) 253 .Times(1).After(input).WillOnce(Return(ERR_OK)); 254 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_END_TIME, _, userId)) 255 .Times(1).After(input).WillOnce(Return(ERR_OK)); 256 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_SUN_SET, _, userId)) 257 .Times(1).After(input).WillOnce(Return(ERR_OK)); 258 expectSet += EXPECT_CALL(dataManager, MockRegisterObserver(SETTING_DARK_MODE_SUN_RISE, _, userId)) 259 .Times(1).After(input).WillOnce(Return(ERR_OK)); 260 261 EXPECT_EQ(manager.OnSwitchUser(userId), registerObsFail ? ERR_NO_INIT : ERR_OK); 262 EXPECT_EQ(manager.settingDataObserversUserId_, userId); 263 } 264 RestartTimerNoChangeTest(const int32_t userId,const DarkModeMode mode) const265 void RestartTimerNoChangeTest(const int32_t userId, const DarkModeMode mode) const 266 { 267 DarkModeManager& manager = DarkModeManager::GetInstance(); 268 manager.settingDataObserversUserId_ = userId; 269 manager.darkModeStates_[userId].settingMode = mode; 270 EXPECT_EQ(manager.RestartTimer(), ERR_OK); 271 } 272 RestartTimerTest(const int32_t userId,const int32_t startTime,const int32_t endTime,const bool expectWithin) const273 void RestartTimerTest(const int32_t userId, const int32_t startTime, const int32_t endTime, 274 const bool expectWithin) const 275 { 276 ExpectationSet expectSet; 277 DarkModeManager& manager = DarkModeManager::GetInstance(); 278 manager.settingDataObserversUserId_ = userId; 279 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 280 manager.darkModeStates_[userId].settingStartTime = startTime; 281 manager.darkModeStates_[userId].settingEndTime = endTime; 282 283 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 284 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval(startTime, endTime)) 285 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 286 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)).Times(1).After(expectSet); 287 expectSet += EXPECT_CALL(manager.alarmTimerManager_, RestartAllTimer()) 288 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 289 EXPECT_EQ(manager.RestartTimer(), ERR_OK); 290 } 291 ModeUpdateFuncFailTest(const int32_t userId,const DarkModeMode getDarkMode) const292 void ModeUpdateFuncFailTest(const int32_t userId, const DarkModeMode getDarkMode) const 293 { 294 DarkModeManager& manager = DarkModeManager::GetInstance(); 295 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 296 ExpectationSet expectSet; 297 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 298 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 299 300 auto checkSettingDarkModeMode = [getDarkMode](Unused, int32_t& value, Unused) { 301 value = getDarkMode; 302 return TEST_ERROR; 303 }; 304 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 305 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 306 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 307 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 308 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, DarkModeMode::DARK_MODE_INVALID); 309 } 310 ModeUpdateFuncAllDayTest(const int32_t userId,const DarkModeMode getDarkMode) const311 void ModeUpdateFuncAllDayTest(const int32_t userId, const DarkModeMode getDarkMode) const 312 { 313 DarkModeManager& manager = DarkModeManager::GetInstance(); 314 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 315 ExpectationSet expectSet; 316 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 317 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 318 319 auto checkSettingDarkModeMode = [getDarkMode](Unused, int32_t& value, Unused) { 320 value = getDarkMode; 321 return ERR_OK; 322 }; 323 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 324 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 325 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 326 expectSet += EXPECT_CALL(*this, UpdateCallback(getDarkMode == DarkModeMode::DARK_MODE_ALWAYS_DARK, userId)) 327 .Times(1).After(expectSet); 328 329 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 330 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, getDarkMode); 331 } 332 ModeUpdateFuncCustomAutoFailTest(const int32_t userId,const int32_t startTime,const int32_t endTime) const333 void ModeUpdateFuncCustomAutoFailTest(const int32_t userId, const int32_t startTime, const int32_t endTime) const 334 { 335 DarkModeManager& manager = DarkModeManager::GetInstance(); 336 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 337 manager.darkModeStates_[userId].settingStartTime = startTime; 338 manager.darkModeStates_[userId].settingEndTime = endTime; 339 340 ExpectationSet expectSet; 341 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 342 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 343 344 auto checkSettingDarkModeMode = [](Unused, int32_t& value, Unused) { 345 value = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 346 return ERR_OK; 347 }; 348 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 349 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 350 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 351 .Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 352 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 353 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 354 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 355 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 356 } 357 ModeUpdateFuncCustomAutoTest(const int32_t userId,const int32_t startTime,const int32_t endTime,const bool expectWithin) const358 void ModeUpdateFuncCustomAutoTest(const int32_t userId, const int32_t startTime, const int32_t endTime, 359 const bool expectWithin) const 360 { 361 DarkModeManager& manager = DarkModeManager::GetInstance(); 362 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 363 manager.darkModeStates_[userId].settingStartTime = startTime; 364 manager.darkModeStates_[userId].settingEndTime = endTime; 365 366 ExpectationSet expectSet; 367 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 368 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 369 370 auto checkSettingDarkModeMode = [](Unused, int32_t& value, Unused) { 371 value = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 372 return ERR_OK; 373 }; 374 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 375 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeMode)); 376 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 377 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 378 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 379 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval(startTime, endTime)) 380 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 381 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)) 382 .Times(1).After(expectSet); 383 384 updateFuncMap[SETTING_DARK_MODE_MODE](SETTING_DARK_MODE_MODE, userId); 385 EXPECT_EQ(manager.darkModeStates_[userId].settingMode, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 386 } 387 TimeUpdateFuncFailTest(const int32_t userId,const std::string & key,const int32_t expectValue,const int32_t code) const388 void TimeUpdateFuncFailTest(const int32_t userId, const std::string& key, 389 const int32_t expectValue, const int32_t code) const 390 { 391 DarkModeManager& manager = DarkModeManager::GetInstance(); 392 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 393 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_INVALID; 394 395 ExpectationSet expectSet; 396 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 397 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 398 399 auto checkSettingDarkModeTime = [expectValue, code](Unused, int32_t& value, Unused) { 400 if (code == ERR_OK) { 401 value = expectValue; 402 } 403 return code; 404 }; 405 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 406 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 407 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 408 updateFuncMap[key](key, userId); 409 if (key == SETTING_DARK_MODE_START_TIME) { 410 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, code == ERR_OK ? expectValue : -1); 411 } else { 412 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, code == ERR_OK ? expectValue : -1); 413 } 414 } 415 TimeUpdateFuncAllDayTest(const int32_t userId,DarkModeMode mode,const std::string & key,const int32_t expectValue) const416 void TimeUpdateFuncAllDayTest(const int32_t userId, DarkModeMode mode, const std::string& key, 417 const int32_t expectValue) const 418 { 419 DarkModeManager& manager = DarkModeManager::GetInstance(); 420 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 421 manager.darkModeStates_[userId].settingMode = mode; 422 423 ExpectationSet expectSet; 424 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 425 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 426 427 auto checkSettingDarkModeTime = [expectValue](Unused, int32_t& value, Unused) { 428 value = expectValue; 429 return ERR_OK; 430 }; 431 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 432 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 433 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 434 expectSet += EXPECT_CALL(*this, UpdateCallback(mode == DarkModeMode::DARK_MODE_ALWAYS_DARK, userId)) 435 .Times(1).After(expectSet); 436 updateFuncMap[key](key, userId); 437 if (key == SETTING_DARK_MODE_START_TIME) { 438 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, expectValue); 439 } else { 440 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, expectValue); 441 } 442 } 443 TimeUpdateFuncCustomAutoFailTest(const int32_t userId,const std::string & key,const int32_t expectValue,const int32_t otherValue) const444 void TimeUpdateFuncCustomAutoFailTest(const int32_t userId, const std::string& key, const int32_t expectValue, 445 const int32_t otherValue) const 446 { 447 DarkModeManager& manager = DarkModeManager::GetInstance(); 448 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 449 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 450 451 ExpectationSet expectSet; 452 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 453 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 454 455 auto checkSettingDarkModeTime = [expectValue](Unused, int32_t& value, Unused) { 456 value = expectValue; 457 return ERR_OK; 458 }; 459 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 460 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 461 int32_t startTime; 462 int32_t endTime; 463 if (key == SETTING_DARK_MODE_START_TIME) { 464 startTime = expectValue; 465 endTime = otherValue; 466 manager.darkModeStates_[userId].settingEndTime = otherValue; 467 } else { 468 startTime = otherValue; 469 endTime = expectValue; 470 manager.darkModeStates_[userId].settingStartTime = otherValue; 471 } 472 473 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 474 .Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 475 expectSet += EXPECT_CALL(manager.alarmTimerManager_, ClearTimerByUserId(userId)).Times(1).After(expectSet); 476 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 477 updateFuncMap[key](key, userId); 478 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 479 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 480 } 481 TimeUpdateFuncCustomAutoTest(const int32_t userId,const std::string & key,const int32_t expectValue,const int32_t otherValue,const bool expectWithin) const482 void TimeUpdateFuncCustomAutoTest(const int32_t userId, const std::string& key, const int32_t expectValue, 483 const int32_t otherValue, const bool expectWithin) const 484 { 485 DarkModeManager& manager = DarkModeManager::GetInstance(); 486 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 487 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 488 489 ExpectationSet expectSet; 490 std::map<std::string, std::function<void(const std::string&, int32_t)>> updateFuncMap; 491 GetUpdateFuncMap(userId, expectSet, updateFuncMap); 492 493 auto checkSettingDarkModeTime = [expectValue](Unused, int32_t& value, Unused) { 494 value = expectValue; 495 return ERR_OK; 496 }; 497 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(key, _, userId)) 498 .Times(1).After(expectSet).WillOnce(Invoke(checkSettingDarkModeTime)); 499 int32_t startTime; 500 int32_t endTime; 501 if (key == SETTING_DARK_MODE_START_TIME) { 502 startTime = expectValue; 503 endTime = otherValue; 504 manager.darkModeStates_[userId].settingEndTime = otherValue; 505 } else { 506 startTime = otherValue; 507 endTime = expectValue; 508 manager.darkModeStates_[userId].settingStartTime = otherValue; 509 } 510 511 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 512 .Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 513 AlarmTimerManager& alarmTimerManagerStaticInstance = AlarmTimerManager::GetInstance(); 514 expectSet += EXPECT_CALL(alarmTimerManagerStaticInstance, MockIsWithinTimeInterval(startTime, endTime)) 515 .Times(1).After(expectSet).WillOnce(Return(expectWithin)); 516 expectSet += EXPECT_CALL(*this, UpdateCallback(expectWithin, userId)) 517 .Times(1).After(expectSet); 518 updateFuncMap[key](key, userId); 519 EXPECT_EQ(manager.darkModeStates_[userId].settingStartTime, startTime); 520 EXPECT_EQ(manager.darkModeStates_[userId].settingEndTime, endTime); 521 } 522 TimerCallbackFailTest(const int32_t userId,const int32_t startTime,const int32_t endTime,const DarkModeMode stateMode,const int32_t stateStartTime,const int32_t stateEndTine) const523 void TimerCallbackFailTest(const int32_t userId, const int32_t startTime, const int32_t endTime, 524 const DarkModeMode stateMode, const int32_t stateStartTime, const int32_t stateEndTine) const 525 { 526 DarkModeManager& manager = DarkModeManager::GetInstance(); 527 manager.darkModeStates_[userId].settingMode = stateMode; 528 manager.darkModeStates_[userId].settingStartTime = stateStartTime; 529 manager.darkModeStates_[userId].settingEndTime = stateEndTine; 530 531 ExpectationSet expectSet; 532 std::function<void()> startCallbackFunc; 533 std::function<void()> endCallbackFunc; 534 auto checkSetScheduleTime = [&startCallbackFunc, &endCallbackFunc](Unused, Unused, Unused, 535 const std::function<void()>& startCallback, const std::function<void()>& endCallback) { 536 startCallbackFunc = startCallback; 537 endCallbackFunc = endCallback; 538 return ERR_OK; 539 }; 540 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 541 .Times(1).After(expectSet).WillOnce(Invoke(checkSetScheduleTime)); 542 EXPECT_EQ(manager.CreateOrUpdateTimers(startTime, endTime, userId), ERR_OK); 543 EXPECT_NE(startCallbackFunc, nullptr); 544 EXPECT_NE(endCallbackFunc, nullptr); 545 EXPECT_CALL(*this, UpdateCallback(_, _)).Times(0); 546 startCallbackFunc(); 547 endCallbackFunc(); 548 } 549 TimerCallbackTest(const int32_t userId,const int32_t startTime,const int32_t endTime) const550 void TimerCallbackTest(const int32_t userId, const int32_t startTime, const int32_t endTime) const 551 { 552 DarkModeManager& manager = DarkModeManager::GetInstance(); 553 manager.darkModeStates_[userId].settingMode = DarkModeMode::DARK_MODE_CUSTOM_AUTO; 554 manager.darkModeStates_[userId].settingStartTime = startTime; 555 manager.darkModeStates_[userId].settingEndTime = endTime; 556 557 ExpectationSet expectSet; 558 std::function<void()> startCallbackFunc; 559 std::function<void()> endCallbackFunc; 560 auto checkSetScheduleTime = [&startCallbackFunc, &endCallbackFunc](Unused, Unused, Unused, 561 const std::function<void()>& startCallback, const std::function<void()>& endCallback) { 562 startCallbackFunc = startCallback; 563 endCallbackFunc = endCallback; 564 return ERR_OK; 565 }; 566 expectSet += EXPECT_CALL(manager.alarmTimerManager_, SetScheduleTime(startTime, endTime, userId, _, _)) 567 .Times(1).After(expectSet).WillOnce(Invoke(checkSetScheduleTime)); 568 EXPECT_EQ(manager.CreateOrUpdateTimers(startTime, endTime, userId), ERR_OK); 569 EXPECT_NE(startCallbackFunc, nullptr); 570 EXPECT_NE(endCallbackFunc, nullptr); 571 572 expectSet += EXPECT_CALL(*this, UpdateCallback(true, userId)).Times(1).After(expectSet); 573 startCallbackFunc(); 574 expectSet += EXPECT_CALL(*this, UpdateCallback(false, userId)).Times(1).After(expectSet); 575 endCallbackFunc(); 576 } 577 578 MOCK_METHOD(void, UpdateCallback, (bool, int32_t), (const)); 579 580 private: LoadUserSettingDataGetInt32ValueTest(const int32_t userId,const DarkModeState darkModeState,ExpectationSet & expectSet) const581 void LoadUserSettingDataGetInt32ValueTest( 582 const int32_t userId, const DarkModeState darkModeState, ExpectationSet& expectSet) const 583 { 584 ExpectationSet input = expectSet; 585 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 586 auto checkSettingDarkModeMode = [darkModeState](Unused, int32_t& value, Unused) { 587 value = darkModeState.settingMode; 588 return ERR_OK; 589 }; 590 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_MODE, _, userId)) 591 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeMode)); 592 auto checkSettingDarkModeStartTime = [darkModeState](Unused, int32_t& value, Unused) { 593 value = darkModeState.settingStartTime; 594 return ERR_OK; 595 }; 596 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_START_TIME, _, userId)) 597 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeStartTime)); 598 auto checkSettingDarkModeEndTime = [darkModeState](Unused, int32_t& value, Unused) { 599 value = darkModeState.settingEndTime; 600 return ERR_OK; 601 }; 602 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_END_TIME, _, userId)) 603 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeEndTime)); 604 auto checkSettingDarkModeSunsetTime = [darkModeState](Unused, int32_t& value, Unused) { 605 value = darkModeState.settingSunsetTime; 606 return ERR_OK; 607 }; 608 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_SUN_SET, _, userId)) 609 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeSunsetTime)); 610 auto checkSettingDarkModeSunriseTime = [darkModeState](Unused, int32_t& value, Unused) { 611 value = darkModeState.settingSunriseTime; 612 return ERR_OK; 613 }; 614 expectSet += EXPECT_CALL(settingDataManager, MockGetInt32ValueStrictly(SETTING_DARK_MODE_SUN_RISE, _, userId)) 615 .Times(1).After(input).WillOnce(Invoke(checkSettingDarkModeSunriseTime)); 616 } 617 GetUpdateFuncMap(const int32_t userId,ExpectationSet & expectSet,std::map<std::string,std::function<void (const std::string &,int32_t)>> & updateFuncMap) const618 void GetUpdateFuncMap(const int32_t userId, ExpectationSet& expectSet, 619 std::map<std::string, std::function<void(const std::string&, int32_t)>>& updateFuncMap) const 620 { 621 DarkModeManager& manager = DarkModeManager::GetInstance(); 622 SettingDataManager& settingDataManager = SettingDataManager::GetInstance(); 623 624 manager.settingDataObserversUserId_ = INVALID_USER_ID; 625 expectSet += EXPECT_CALL(settingDataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(true)); 626 auto checkRegisterObserver = [&updateFuncMap](const std::string& key, 627 const std::function<void(const std::string&, int32_t)>& updateFunc, Unused) { 628 updateFuncMap[key] = updateFunc; 629 return ERR_OK; 630 }; 631 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_MODE, _, userId)) 632 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 633 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_START_TIME, _, userId)) 634 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 635 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_END_TIME, _, userId)) 636 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 637 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_SUN_SET, _, userId)) 638 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 639 expectSet += EXPECT_CALL(settingDataManager, MockRegisterObserver(SETTING_DARK_MODE_SUN_RISE, _, userId)) 640 .Times(1).WillOnce(Invoke(checkRegisterObserver)); 641 EXPECT_EQ(manager.OnSwitchUser(userId), ERR_OK); 642 EXPECT_EQ(manager.settingDataObserversUserId_, userId); 643 EXPECT_EQ(updateFuncMap.size(), SETTING_NUM); 644 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_MODE], nullptr); 645 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_START_TIME], nullptr); 646 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_END_TIME], nullptr); 647 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_SUN_SET], nullptr); 648 EXPECT_NE(updateFuncMap[SETTING_DARK_MODE_SUN_RISE], nullptr); 649 } 650 }; 651 652 HWTEST_F(DarkModeManagerInitializeTest, InitializeTest_0100, TestSize.Level1) 653 { 654 DarkModeManager& manager = DarkModeManager::GetInstance(); 655 EXPECT_EQ(manager.settingDataObservers_.size(), 0); 656 EXPECT_EQ(manager.settingDataObserversUserId_, INVALID_USER_ID); 657 EXPECT_EQ(manager.darkModeStates_.size(), 0); 658 EXPECT_EQ(manager.updateCallback_, nullptr); 659 __anon34f781941302(const bool isDarkMode, const int32_t userId) 660 EXPECT_EQ(manager.Initialize([this](const bool isDarkMode, const int32_t userId) { 661 UpdateCallback1(isDarkMode, userId); 662 }), ERR_OK); 663 EXPECT_EQ(manager.settingDataObservers_.size(), SETTING_NUM); 664 EXPECT_EQ(manager.settingDataObserversUserId_, INVALID_USER_ID); 665 EXPECT_EQ(manager.darkModeStates_.size(), 0); 666 EXPECT_NE(manager.updateCallback_, nullptr); 667 668 EXPECT_CALL(*this, UpdateCallback1(true, INVALID_USER_ID)).Times(1); 669 EXPECT_CALL(*this, UpdateCallback1(false, TEST_USER1)).Times(1); 670 EXPECT_CALL(*this, UpdateCallback1(true, TEST_USER100)).Times(1); 671 manager.updateCallback_(true, INVALID_USER_ID); 672 manager.updateCallback_(false, TEST_USER1); 673 manager.updateCallback_(true, TEST_USER100); 674 __anon34f781941402(const bool isDarkMode, const int32_t userId) 675 EXPECT_EQ(manager.Initialize([this](const bool isDarkMode, const int32_t userId) { 676 UpdateCallback2(isDarkMode, userId); 677 }), ERR_OK); 678 EXPECT_EQ(manager.settingDataObservers_.size(), SETTING_NUM); 679 EXPECT_EQ(manager.settingDataObserversUserId_, INVALID_USER_ID); 680 EXPECT_EQ(manager.darkModeStates_.size(), 0); 681 EXPECT_NE(manager.updateCallback_, nullptr); 682 683 EXPECT_CALL(*this, UpdateCallback2(true, INVALID_USER_ID)).Times(1); 684 EXPECT_CALL(*this, UpdateCallback2(false, TEST_USER1)).Times(1); 685 EXPECT_CALL(*this, UpdateCallback2(true, TEST_USER100)).Times(1); 686 manager.updateCallback_(true, INVALID_USER_ID); 687 manager.updateCallback_(false, TEST_USER1); 688 manager.updateCallback_(true, TEST_USER100); 689 } 690 691 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0100, TestSize.Level1) 692 { 693 DarkModeState darkModeState; 694 darkModeState.settingMode = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 695 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 696 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ONE; 697 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 698 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ONE; 699 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, darkModeState, DarkModeMode::DARK_MODE_INVALID); 700 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, darkModeState, DarkModeMode::DARK_MODE_INVALID); 701 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, darkModeState, DarkModeMode::DARK_MODE_INVALID); 702 703 darkModeState.settingMode = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 704 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 705 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ZERO; 706 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 707 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ZERO; 708 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, darkModeState, DarkModeMode::DARK_MODE_INVALID); 709 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, darkModeState, DarkModeMode::DARK_MODE_INVALID); 710 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, darkModeState, DarkModeMode::DARK_MODE_INVALID); 711 712 darkModeState.settingMode = TEST_DARK_MODE_STATE_FOUR; 713 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ZERO; 714 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 715 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ZERO; 716 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 717 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, darkModeState, DarkModeMode::DARK_MODE_INVALID); 718 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, darkModeState, DarkModeMode::DARK_MODE_INVALID); 719 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, darkModeState, DarkModeMode::DARK_MODE_INVALID); 720 721 darkModeState.settingMode = TEST_DARK_MODE_STATE_FIVE; 722 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ONE; 723 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 724 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ONE; 725 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 726 LoadUserSettingDataInvalidDarkModeTest(INVALID_USER_ID, darkModeState, DarkModeMode::DARK_MODE_INVALID); 727 LoadUserSettingDataInvalidDarkModeTest(TEST_USER1, darkModeState, DarkModeMode::DARK_MODE_INVALID); 728 LoadUserSettingDataInvalidDarkModeTest(TEST_USER100, darkModeState, DarkModeMode::DARK_MODE_INVALID); 729 } 730 731 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0200, TestSize.Level1) 732 { 733 DarkModeState darkModeState; 734 darkModeState.settingMode = TEST_DARK_MODE_STATE_ZERO; 735 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 736 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ONE; 737 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 738 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ONE; 739 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, true, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 740 LoadUserSettingDataAllDayModeTest(TEST_USER1, true, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 741 LoadUserSettingDataAllDayModeTest(TEST_USER100, true, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 742 743 darkModeState.settingMode = TEST_DARK_MODE_STATE_ZERO; 744 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 745 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ZERO; 746 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 747 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ZERO; 748 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, false, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 749 LoadUserSettingDataAllDayModeTest(TEST_USER1, false, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 750 LoadUserSettingDataAllDayModeTest(TEST_USER100, false, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 751 752 darkModeState.settingMode = TEST_DARK_MODE_STATE_ONE; 753 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ZERO; 754 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 755 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ZERO; 756 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 757 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, true, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_DARK); 758 LoadUserSettingDataAllDayModeTest(TEST_USER1, true, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_DARK); 759 LoadUserSettingDataAllDayModeTest(TEST_USER100, true, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_DARK); 760 761 darkModeState.settingMode = TEST_DARK_MODE_STATE_ONE; 762 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ONE; 763 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 764 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ONE; 765 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 766 LoadUserSettingDataAllDayModeTest(INVALID_USER_ID, false, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_DARK); 767 LoadUserSettingDataAllDayModeTest(TEST_USER1, false, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_DARK); 768 LoadUserSettingDataAllDayModeTest(TEST_USER100, false, darkModeState, DarkModeMode::DARK_MODE_ALWAYS_DARK); 769 } 770 771 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0300, TestSize.Level1) 772 { 773 DarkModeState darkModeState; 774 darkModeState.settingMode = TEST_DARK_MODE_STATE_TWO; 775 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 776 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ONE; 777 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 778 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ONE; 779 LoadUserSettingDataCustomAutoModeSetTimerFailTest( 780 INVALID_USER_ID, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 781 darkModeState.settingMode = TEST_DARK_MODE_STATE_THREE; 782 LoadUserSettingDataCustomAutoModeSetTimerFailTest( 783 INVALID_USER_ID, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET); 784 785 darkModeState.settingMode = TEST_DARK_MODE_STATE_TWO; 786 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 787 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ZERO; 788 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 789 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ZERO; 790 LoadUserSettingDataCustomAutoModeSetTimerFailTest( 791 TEST_USER1, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 792 darkModeState.settingMode = TEST_DARK_MODE_STATE_THREE; 793 LoadUserSettingDataCustomAutoModeSetTimerFailTest( 794 TEST_USER1, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET); 795 796 darkModeState.settingMode = TEST_DARK_MODE_STATE_TWO; 797 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ZERO; 798 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 799 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ZERO; 800 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 801 LoadUserSettingDataCustomAutoModeSetTimerFailTest( 802 TEST_USER100, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 803 darkModeState.settingMode = TEST_DARK_MODE_STATE_THREE; 804 LoadUserSettingDataCustomAutoModeSetTimerFailTest( 805 TEST_USER100, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET); 806 } 807 808 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0400, TestSize.Level1) 809 { 810 DarkModeState darkModeState; 811 darkModeState.settingMode = TEST_DARK_MODE_STATE_TWO; 812 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 813 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ONE; 814 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 815 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ONE; 816 LoadUserSettingDataCustomAutoModeTest( 817 INVALID_USER_ID, true, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 818 LoadUserSettingDataCustomAutoModeTest( 819 TEST_USER1, true, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 820 LoadUserSettingDataCustomAutoModeTest( 821 TEST_USER100, true, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 822 823 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 824 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ZERO; 825 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 826 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ZERO; 827 LoadUserSettingDataCustomAutoModeTest( 828 INVALID_USER_ID, false, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 829 LoadUserSettingDataCustomAutoModeTest( 830 TEST_USER1, false, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 831 LoadUserSettingDataCustomAutoModeTest( 832 TEST_USER100, false, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true); 833 834 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ZERO; 835 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 836 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ZERO; 837 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 838 LoadUserSettingDataCustomAutoModeTest( 839 INVALID_USER_ID, true, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 840 LoadUserSettingDataCustomAutoModeTest( 841 TEST_USER1, true, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 842 LoadUserSettingDataCustomAutoModeTest( 843 TEST_USER100, true, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 844 845 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ONE; 846 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 847 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ONE; 848 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 849 LoadUserSettingDataCustomAutoModeTest( 850 INVALID_USER_ID, false, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 851 LoadUserSettingDataCustomAutoModeTest( 852 TEST_USER1, false, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 853 LoadUserSettingDataCustomAutoModeTest( 854 TEST_USER100, false, darkModeState, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false); 855 } 856 857 HWTEST_F(DarkModeManagerTest, LoadUserSettingData_0500, TestSize.Level1) 858 { 859 DarkModeState darkModeState; 860 darkModeState.settingMode = TEST_DARK_MODE_STATE_THREE; 861 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 862 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ONE; 863 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 864 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ONE; 865 LoadUserSettingDataCustomAutoModeTest( 866 INVALID_USER_ID, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, true); 867 LoadUserSettingDataCustomAutoModeTest( 868 TEST_USER1, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, true); 869 LoadUserSettingDataCustomAutoModeTest( 870 TEST_USER100, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, true); 871 872 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 873 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_ZERO; 874 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 875 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_ZERO; 876 LoadUserSettingDataCustomAutoModeTest( 877 INVALID_USER_ID, false, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, true); 878 LoadUserSettingDataCustomAutoModeTest( 879 TEST_USER1, false, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, true); 880 LoadUserSettingDataCustomAutoModeTest( 881 TEST_USER100, false, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, true); 882 883 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ZERO; 884 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 885 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ZERO; 886 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_ONE; 887 LoadUserSettingDataCustomAutoModeTest( 888 INVALID_USER_ID, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, false); 889 LoadUserSettingDataCustomAutoModeTest( 890 TEST_USER1, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, false); 891 LoadUserSettingDataCustomAutoModeTest( 892 TEST_USER100, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, false); 893 894 darkModeState.settingStartTime = TEST_DARK_MODE_STATE_ONE; 895 darkModeState.settingEndTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 896 darkModeState.settingSunsetTime = TEST_DARK_MODE_STATE_ONE; 897 darkModeState.settingSunriseTime = TEST_DARK_MODE_STATE_NEGATIVE_TWO; 898 LoadUserSettingDataCustomAutoModeTest( 899 INVALID_USER_ID, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, false); 900 LoadUserSettingDataCustomAutoModeTest( 901 TEST_USER1, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, false); 902 LoadUserSettingDataCustomAutoModeTest( 903 TEST_USER100, true, darkModeState, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, false); 904 } 905 906 HWTEST_F(DarkModeManagerTest, NotifyDarkModeUpdate_0100, TestSize.Level1) 907 { 908 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_INVALID, true, true); 909 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_INVALID, false, true); 910 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, true, true); 911 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, false, false); 912 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_DARK, true, false); 913 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_ALWAYS_DARK, false, true); 914 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_CUSTOM_AUTO, true, false); 915 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_CUSTOM_AUTO, false, false); 916 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, true, false); 917 NotifyDarkModeUpdateTest(INVALID_USER_ID, DarkModeMode::DARK_MODE_SUNRISE_SUNSET, false, false); 918 } 919 920 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0100, TestSize.Level1) 921 { 922 ExpectationSet expectSet; 923 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 924 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(false)); 925 expectSet += EXPECT_CALL(dataManager, Initialize()).Times(1).After(expectSet).WillOnce(Return(TEST_ERROR)); 926 DarkModeManager& manager = DarkModeManager::GetInstance(); 927 EXPECT_EQ(manager.OnSwitchUser(INVALID_USER_ID), ERR_NO_INIT); 928 } 929 930 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0200, TestSize.Level1) 931 { 932 ExpectationSet expectSet; 933 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 934 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(false)); 935 expectSet += EXPECT_CALL(dataManager, Initialize()).Times(1).After(expectSet).WillOnce(Return(ERR_OK)); 936 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(false)); 937 DarkModeManager& manager = DarkModeManager::GetInstance(); 938 EXPECT_EQ(manager.OnSwitchUser(INVALID_USER_ID), ERR_NO_INIT); 939 } 940 941 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0300, TestSize.Level1) 942 { 943 ExpectationSet expectSet; 944 SettingDataManager& dataManager = SettingDataManager::GetInstance(); 945 expectSet += EXPECT_CALL(dataManager, IsInitialized()).Times(1).After(expectSet).WillOnce(Return(true)); 946 DarkModeManager& manager = DarkModeManager::GetInstance(); 947 EXPECT_EQ(manager.OnSwitchUser(INVALID_USER_ID), ERR_INVALID_OPERATION); 948 } 949 950 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0400, TestSize.Level1) 951 { 952 OnSwitchUserTest(TEST_USER1, TEST_USER1, true); 953 OnSwitchUserTest(TEST_USER100, TEST_USER100, true); 954 OnSwitchUserTest(TEST_USER101, TEST_USER101, true); 955 956 OnSwitchUserTest(TEST_USER1, TEST_USER1, false); 957 OnSwitchUserTest(TEST_USER100, TEST_USER100, false); 958 OnSwitchUserTest(TEST_USER101, TEST_USER101, false); 959 } 960 961 HWTEST_F(DarkModeManagerTest, OnSwitchUser_0500, TestSize.Level1) 962 { 963 OnSwitchUserTest(TEST_USER1, INVALID_USER_ID, false); 964 OnSwitchUserTest(TEST_USER1, TEST_USER100, false); 965 OnSwitchUserTest(TEST_USER1, TEST_USER101, false); 966 OnSwitchUserTest(TEST_USER100, INVALID_USER_ID, false); 967 OnSwitchUserTest(TEST_USER100, TEST_USER1, false); 968 OnSwitchUserTest(TEST_USER100, TEST_USER101, false); 969 OnSwitchUserTest(TEST_USER101, INVALID_USER_ID, false); 970 OnSwitchUserTest(TEST_USER101, TEST_USER1, false); 971 OnSwitchUserTest(TEST_USER101, TEST_USER100, false); 972 973 OnSwitchUserTest(TEST_USER1, INVALID_USER_ID, true); 974 OnSwitchUserTest(TEST_USER1, TEST_USER100, true); 975 OnSwitchUserTest(TEST_USER1, TEST_USER101, true); 976 OnSwitchUserTest(TEST_USER100, INVALID_USER_ID, true); 977 OnSwitchUserTest(TEST_USER100, TEST_USER1, true); 978 OnSwitchUserTest(TEST_USER100, TEST_USER101, true); 979 OnSwitchUserTest(TEST_USER101, INVALID_USER_ID, true); 980 OnSwitchUserTest(TEST_USER101, TEST_USER1, true); 981 OnSwitchUserTest(TEST_USER101, TEST_USER100, true); 982 } 983 984 HWTEST_F(DarkModeManagerTest, RestartTimer_0100, TestSize.Level1) 985 { 986 RestartTimerNoChangeTest(TEST_USER1, DarkModeMode::DARK_MODE_INVALID); 987 RestartTimerNoChangeTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 988 RestartTimerNoChangeTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 989 RestartTimerNoChangeTest(TEST_USER100, DarkModeMode::DARK_MODE_INVALID); 990 RestartTimerNoChangeTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 991 RestartTimerNoChangeTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK); 992 RestartTimerNoChangeTest(TEST_USER101, DarkModeMode::DARK_MODE_INVALID); 993 RestartTimerNoChangeTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 994 RestartTimerNoChangeTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK); 995 } 996 997 HWTEST_F(DarkModeManagerTest, RestartTimer_0200, TestSize.Level1) 998 { 999 RestartTimerTest(TEST_USER1, -1, 4, true); 1000 RestartTimerTest(TEST_USER1, 0, 3, false); 1001 RestartTimerTest(TEST_USER100, 1, 2, true); 1002 RestartTimerTest(TEST_USER100, 2, 1, false); 1003 RestartTimerTest(TEST_USER101, 3, 0, true); 1004 RestartTimerTest(TEST_USER101, 4, -1, false); 1005 } 1006 1007 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0100, TestSize.Level1) 1008 { 1009 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_INVALID); 1010 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 1011 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 1012 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 1013 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_SUNRISE_SUNSET); 1014 ModeUpdateFuncFailTest(TEST_USER1, DarkModeMode::DARK_MODE_SIZE); 1015 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_INVALID); 1016 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK); 1017 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 1018 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 1019 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_SUNRISE_SUNSET); 1020 ModeUpdateFuncFailTest(TEST_USER100, DarkModeMode::DARK_MODE_SIZE); 1021 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_INVALID); 1022 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK); 1023 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 1024 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_CUSTOM_AUTO); 1025 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_SUNRISE_SUNSET); 1026 ModeUpdateFuncFailTest(TEST_USER101, DarkModeMode::DARK_MODE_SIZE); 1027 } 1028 1029 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0200, TestSize.Level1) 1030 { 1031 ModeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK); 1032 ModeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 1033 ModeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK); 1034 ModeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 1035 ModeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK); 1036 ModeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT); 1037 } 1038 1039 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0300, TestSize.Level1) 1040 { 1041 ModeUpdateFuncCustomAutoFailTest(TEST_USER1, 0, 5); 1042 ModeUpdateFuncCustomAutoFailTest(TEST_USER1, 1, 4); 1043 ModeUpdateFuncCustomAutoFailTest(TEST_USER100, 2, 3); 1044 ModeUpdateFuncCustomAutoFailTest(TEST_USER100, 3, 2); 1045 ModeUpdateFuncCustomAutoFailTest(TEST_USER101, 4, 1); 1046 ModeUpdateFuncCustomAutoFailTest(TEST_USER101, 5, 0); 1047 } 1048 1049 HWTEST_F(DarkModeManagerTest, ModeUpdateFunc_0400, TestSize.Level1) 1050 { 1051 ModeUpdateFuncCustomAutoTest(TEST_USER1, 0, 5, true); 1052 ModeUpdateFuncCustomAutoTest(TEST_USER1, 1, 4, false); 1053 ModeUpdateFuncCustomAutoTest(TEST_USER100, 2, 3, true); 1054 ModeUpdateFuncCustomAutoTest(TEST_USER100, 3, 2, false); 1055 ModeUpdateFuncCustomAutoTest(TEST_USER101, 4, 1, true); 1056 ModeUpdateFuncCustomAutoTest(TEST_USER101, 5, 0, false); 1057 } 1058 1059 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0100, TestSize.Level1) 1060 { 1061 TimeUpdateFuncFailTest(TEST_USER1, SETTING_DARK_MODE_START_TIME, -1, ERR_OK); 1062 TimeUpdateFuncFailTest(TEST_USER1, SETTING_DARK_MODE_END_TIME, 0, TEST_ERROR); 1063 TimeUpdateFuncFailTest(TEST_USER100, SETTING_DARK_MODE_START_TIME, 1, ERR_OK); 1064 TimeUpdateFuncFailTest(TEST_USER100, SETTING_DARK_MODE_END_TIME, 2, TEST_ERROR); 1065 TimeUpdateFuncFailTest(TEST_USER101, SETTING_DARK_MODE_START_TIME, 3, ERR_OK); 1066 TimeUpdateFuncFailTest(TEST_USER101, SETTING_DARK_MODE_END_TIME, 4, TEST_ERROR); 1067 } 1068 1069 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0200, TestSize.Level1) 1070 { 1071 TimeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_DARK, SETTING_DARK_MODE_START_TIME, -1); 1072 TimeUpdateFuncAllDayTest(TEST_USER1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, SETTING_DARK_MODE_END_TIME, 0); 1073 TimeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_DARK, SETTING_DARK_MODE_START_TIME, 1); 1074 TimeUpdateFuncAllDayTest(TEST_USER100, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, SETTING_DARK_MODE_END_TIME, 2); 1075 TimeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_DARK, SETTING_DARK_MODE_START_TIME, 3); 1076 TimeUpdateFuncAllDayTest(TEST_USER101, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, SETTING_DARK_MODE_END_TIME, 4); 1077 } 1078 1079 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0300, TestSize.Level1) 1080 { 1081 TimeUpdateFuncCustomAutoFailTest(TEST_USER1, SETTING_DARK_MODE_START_TIME, -1, 4); 1082 TimeUpdateFuncCustomAutoFailTest(TEST_USER1, SETTING_DARK_MODE_END_TIME, 0, 3); 1083 TimeUpdateFuncCustomAutoFailTest(TEST_USER100, SETTING_DARK_MODE_START_TIME, 1, 2); 1084 TimeUpdateFuncCustomAutoFailTest(TEST_USER100, SETTING_DARK_MODE_END_TIME, 2, 1); 1085 TimeUpdateFuncCustomAutoFailTest(TEST_USER101, SETTING_DARK_MODE_START_TIME, 3, 0); 1086 TimeUpdateFuncCustomAutoFailTest(TEST_USER101, SETTING_DARK_MODE_END_TIME, 4, -1); 1087 } 1088 1089 HWTEST_F(DarkModeManagerTest, StartTimeUpdateFunc_0400, TestSize.Level1) 1090 { 1091 TimeUpdateFuncCustomAutoTest(TEST_USER1, SETTING_DARK_MODE_START_TIME, -1, 4, true); 1092 TimeUpdateFuncCustomAutoTest(TEST_USER1, SETTING_DARK_MODE_END_TIME, 0, 3, true); 1093 TimeUpdateFuncCustomAutoTest(TEST_USER100, SETTING_DARK_MODE_START_TIME, 1, 2, true); 1094 TimeUpdateFuncCustomAutoTest(TEST_USER100, SETTING_DARK_MODE_END_TIME, 2, 1, false); 1095 TimeUpdateFuncCustomAutoTest(TEST_USER101, SETTING_DARK_MODE_START_TIME, 3, 0, false); 1096 TimeUpdateFuncCustomAutoTest(TEST_USER101, SETTING_DARK_MODE_END_TIME, 4, -1, false); 1097 } 1098 1099 HWTEST_F(DarkModeManagerTest, TimerCallback_0100, TestSize.Level1) 1100 { 1101 TimerCallbackFailTest(TEST_USER1, -1, 7, DarkModeMode::DARK_MODE_INVALID, -1, 7); 1102 TimerCallbackFailTest(TEST_USER100, 0, 6, DarkModeMode::DARK_MODE_INVALID, 0, 6); 1103 TimerCallbackFailTest(TEST_USER101, 1, 5, DarkModeMode::DARK_MODE_INVALID, 1, 5); 1104 TimerCallbackFailTest(TEST_USER1, 2, 4, DarkModeMode::DARK_MODE_ALWAYS_DARK, 2, 4); 1105 TimerCallbackFailTest(TEST_USER100, 3, 3, DarkModeMode::DARK_MODE_ALWAYS_DARK, 3, 3); 1106 TimerCallbackFailTest(TEST_USER101, 4, 2, DarkModeMode::DARK_MODE_ALWAYS_DARK, 4, 2); 1107 TimerCallbackFailTest(TEST_USER1, 5, 1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, 5, 1); 1108 TimerCallbackFailTest(TEST_USER100, 6, 0, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, 6, 0); 1109 TimerCallbackFailTest(TEST_USER101, 7, -1, DarkModeMode::DARK_MODE_ALWAYS_LIGHT, 7, -1); 1110 1111 TimerCallbackFailTest(TEST_USER1, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, 0, 1); 1112 TimerCallbackFailTest(TEST_USER100, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, 0, 1); 1113 TimerCallbackFailTest(TEST_USER101, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, 0, 1); 1114 TimerCallbackFailTest(TEST_USER1, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, -1, 0); 1115 TimerCallbackFailTest(TEST_USER100, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, -1, 0); 1116 TimerCallbackFailTest(TEST_USER101, -1, 1, DarkModeMode::DARK_MODE_CUSTOM_AUTO, -1, 0); 1117 } 1118 1119 HWTEST_F(DarkModeManagerTest, TimerCallback_0200, TestSize.Level1) 1120 { 1121 TimerCallbackTest(TEST_USER1, -1, 1); 1122 TimerCallbackTest(TEST_USER100, 0, 0); 1123 TimerCallbackTest(TEST_USER101, 1, -1); 1124 } 1125 } // namespace OHOS::ArkUi::UiAppearance 1126