1 /*
2 * Copyright (C) 2022-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 <chrono>
17 #include <cstdio>
18 #include <gtest/gtest.h>
19 #include <iostream>
20 #include <sys/types.h>
21 #include <unistd.h>
22 #include <string>
23
24 #include "accesstoken_kit.h"
25 #include "syspara/parameter.h"
26 #include "system_ability_definition.h"
27 #include "ui_appearance_ability.h"
28 #include "ui_appearance_log.h"
29 #include "alarm_timer_manager.h"
30
31 using namespace testing::ext;
32 static constexpr int UISERVER_UID = 3050;
33
34 namespace OHOS {
35 namespace ArkUi::UiAppearance {
36
37 const int DAY_TO_SECOND = 24 * 60 * 60;
38 const int DAY_TO_MINUTE = 24 * 60;
39 const int SECOND_TO_MILLI = 1000;
40 const int MINUTE_TO_SECOND = 60;
41
42 class UiAppearanceAbilityTest : public UiAppearanceAbility {
43 public:
UiAppearanceAbilityTest()44 UiAppearanceAbilityTest() : UiAppearanceAbility(ARKUI_UI_APPEARANCE_SERVICE_ID, true) {}
~UiAppearanceAbilityTest()45 ~UiAppearanceAbilityTest() {}
OnStart()46 void OnStart() override
47 {
48 return;
49 }
50 };
51
52 class DarkModeTest : public testing::Test {
53 public:
54 static void SetUpTestCase(void);
55 static void TearDownTestCase(void);
56 void SetUp();
57 void TearDown();
58
GetUiAppearanceAbilityTest()59 static sptr<UiAppearanceAbilityTest> GetUiAppearanceAbilityTest()
60 {
61 return new UiAppearanceAbilityTest;
62 }
63
GetAlarmTimerManager()64 static std::shared_ptr<AlarmTimerManager> GetAlarmTimerManager()
65 {
66 return std::make_shared<AlarmTimerManager>();
67 }
68
69 private:
70 int userId_;
71 };
72
SetUpTestCase(void)73 void DarkModeTest::SetUpTestCase(void) {}
74
TearDownTestCase(void)75 void DarkModeTest::TearDownTestCase(void) {}
76
SetUp(void)77 void DarkModeTest::SetUp(void)
78 {
79 userId_ = geteuid();
80 seteuid(UISERVER_UID);
81 }
82
TearDown(void)83 void DarkModeTest::TearDown(void)
84 {
85 seteuid(userId_);
86 }
87
88 /**
89 * @tc.name: ui_appearance_test_001
90 * @tc.desc: Test SetDarkMode and GetDarkMode APIs when setting dark/light.
91 * @tc.type: FUNC
92 */
93 HWTEST_F(DarkModeTest, ui_appearance_test_001, TestSize.Level0)
94 {
95 LOGI("Test SetDarkMode and GetDarkMode APIs when setting dark/light.");
96
97 auto test = DarkModeTest::GetUiAppearanceAbilityTest();
98 int32_t result = -1;
99 test->SetDarkMode(DarkMode::ALWAYS_DARK, result);
100 EXPECT_EQ(result, 0);
101 int32_t mode = -1;
102 test->GetDarkMode(mode);
103 EXPECT_EQ(mode, DarkMode::ALWAYS_DARK);
104
105 test->SetDarkMode(DarkMode::ALWAYS_LIGHT, result);
106 EXPECT_EQ(result, 0);
107 test->GetDarkMode(mode);
108 EXPECT_EQ(mode, DarkMode::ALWAYS_LIGHT);
109 }
110
111 /**
112 * @tc.name: ui_appearance_test_002
113 * @tc.desc: Test SetDarkMode and GetDarkMode APIs when repeatedly setting dark/light.
114 * @tc.type: FUNC
115 */
116 HWTEST_F(DarkModeTest, ui_appearance_test_002, TestSize.Level0)
117 {
118 LOGI("Test SetDarkMode and GetDarkMode APIs when repeatedly setting dark/light.");
119
120 auto test = DarkModeTest::GetUiAppearanceAbilityTest();
121 int32_t result = -1;
122 test->SetDarkMode(DarkMode::ALWAYS_DARK, result);
123 EXPECT_EQ(result, UiAppearanceAbilityErrCode::SUCCEEDED);
124 int32_t mode = -1;
125 test->GetDarkMode(mode);
126 EXPECT_EQ(mode, DarkMode::ALWAYS_DARK);
127
128 test->SetDarkMode(DarkMode::ALWAYS_DARK, result);
129 EXPECT_EQ(result, UiAppearanceAbilityErrCode::SYS_ERR);
130 test->GetDarkMode(mode);
131 EXPECT_EQ(mode, DarkMode::ALWAYS_DARK);
132
133 test->SetDarkMode(DarkMode::ALWAYS_LIGHT, result);
134 EXPECT_EQ(result, UiAppearanceAbilityErrCode::SUCCEEDED);
135 test->GetDarkMode(mode);
136 EXPECT_EQ(mode, DarkMode::ALWAYS_LIGHT);
137
138 test->SetDarkMode(DarkMode::ALWAYS_LIGHT, result);
139 EXPECT_EQ(result, UiAppearanceAbilityErrCode::SYS_ERR);
140 test->GetDarkMode(mode);
141 EXPECT_EQ(mode, DarkMode::ALWAYS_LIGHT);
142 }
143
144 /**
145 * @tc.name: ui_appearance_test_003
146 * @tc.desc: Test the SetDarkMode API when setting an unexpected value
147 * @tc.type: FUNC
148 */
149 HWTEST_F(DarkModeTest, ui_appearance_test_003, TestSize.Level0)
150 {
151 LOGI("Test the SetDarkMode API when setting an unexpected value.");
152
153 int32_t result = -1;
154 DarkModeTest::GetUiAppearanceAbilityTest()->SetDarkMode(DarkMode::UNKNOWN, result);
155 EXPECT_NE(result, 0);
156 }
157
158 /**
159 * @tc.name: ui_appearance_test_004
160 * @tc.desc: Test the font API
161 * @tc.type: FUNC
162 */
163 HWTEST_F(DarkModeTest, ui_appearance_test_004, TestSize.Level0)
164 {
165 LOGI("Test the font API");
166
167 std::string fontScale;
168 int32_t result = -1;
169 DarkModeTest::GetUiAppearanceAbilityTest()->GetFontScale(fontScale, result);
170 EXPECT_EQ(result, 0);
171
172 std::string fontWeightScale;
173 DarkModeTest::GetUiAppearanceAbilityTest()->GetFontWeightScale(fontWeightScale, result);
174 EXPECT_EQ(result, 0);
175 }
176
177 /**
178 * @tc.name: ui_appearance_test_005
179 * @tc.desc: Test the alarm_timer_manager
180 * @tc.type: FUNC
181 */
182 HWTEST_F(DarkModeTest, ui_appearance_test_005, TestSize.Level0)
183 {
184 LOGI("Test the alarm_timer_manager");
185
186 bool result = AlarmTimerManager::IsValidScheduleTime(12, 10);
187 EXPECT_EQ(result, false);
188
189 result = AlarmTimerManager::IsValidScheduleTime(DAY_TO_MINUTE + 10, DAY_TO_MINUTE + 12);
190 EXPECT_EQ(result, false);
191
192 result = AlarmTimerManager::IsValidScheduleTime(10, DAY_TO_MINUTE + 12);
193 EXPECT_EQ(result, false);
194
195 result = AlarmTimerManager::IsValidScheduleTime(10, 12);
196 EXPECT_EQ(result, true);
197 }
198
199 /**
200 * @tc.name: ui_appearance_test_006
201 * @tc.desc: Test the alarm_timer_manager
202 * @tc.type: FUNC
203 */
204 HWTEST_F(DarkModeTest, ui_appearance_test_006, TestSize.Level0)
205 {
206 LOGI("Test the alarm_timer_manager");
207
208 std::array<uint64_t, TRIGGER_ARRAY_SIZE> triggerTimeInterval = {0, 0};
209 std::time_t timestamp = std::time(nullptr);
210 if (timestamp == static_cast<std::time_t>(-1)) {
211 LOGE("fail to get timestamp");
212 }
213 std::tm *nowTime = std::localtime(×tamp);
214 auto current = nowTime->tm_hour * 60 + nowTime->tm_min;
215 if (nowTime != nullptr) {
216 nowTime->tm_hour = 0;
217 nowTime->tm_min = 0;
218 nowTime->tm_sec = 0;
219 }
220 std::time_t now_zero = std::mktime(nowTime);
221 uint64_t zeroTimestamp = static_cast<uint64_t>(now_zero * SECOND_TO_MILLI);
222
223 uint64_t step = DAY_TO_SECOND * SECOND_TO_MILLI;
224
225 uint64_t startTimestamp = zeroTimestamp + (current + 1) * MINUTE_TO_SECOND * SECOND_TO_MILLI;
226 AlarmTimerManager::SetTimerTriggerTime(current + 1, current + 2, triggerTimeInterval);
227 EXPECT_EQ(triggerTimeInterval[0], startTimestamp);
228
229 startTimestamp = zeroTimestamp + (current - 1) * MINUTE_TO_SECOND * SECOND_TO_MILLI;
230 AlarmTimerManager::SetTimerTriggerTime(current - 1, current + 2, triggerTimeInterval);
231 EXPECT_EQ(triggerTimeInterval[0], startTimestamp + step);
232 }
233
234 /**
235 * @tc.name: ui_appearance_test_007
236 * @tc.desc: Test the alarm_timer_manager
237 * @tc.type: FUNC
238 */
239 HWTEST_F(DarkModeTest, ui_appearance_test_007, TestSize.Level0)
240 {
241 LOGI("Test the alarm_timer_manager");
242
243 auto uiAppearanceTimerManager = DarkModeTest::GetAlarmTimerManager();
244 int res = uiAppearanceTimerManager->SetScheduleTime(
__anon5d5322b10102()245 10, 12, 100, [](){}, [](){});
246 EXPECT_EQ(res, 0);
247
248 res = uiAppearanceTimerManager->RestartAllTimer();
249 EXPECT_EQ(res, 1);
250
251 uiAppearanceTimerManager->ClearTimerByUserId(100);
252 }
253
254
255 } // namespace ArkUi::UiAppearance
256 } // namespace OHOS
257