1 /*
2  * Copyright (c) 2022-2023 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 "display_log.h"
18 #include "mock_brightness_manager_interface.h"
19 
20 using namespace testing;
21 using namespace testing::ext;
22 using namespace OHOS;
23 using namespace OHOS::DisplayPowerMgr;
24 using namespace std;
25 
26 namespace {
27     const double NO_DISCOUNT = 1.00;
28     const uint32_t MAX_DEFAULT_BRIGHTNESS_LEVEL = 255;
29     const uint32_t MIN_DEFAULT_BRIGHTNESS_LEVEL = 1;
30     const uint32_t TEST_MODE = 1;
31     const uint32_t NORMAL_MODE = 2;
32     const uint32_t DEFAULT_WAITING_TIME = 1200000;
33     const uint32_t INIT_WAITING_TIME = 3000000;
34 }
35 
36 BrightnessManagerExt g_BrightnessManagerExt;
37 
38 class BrightnessManagerExtTest : public Test {};
39 
40 namespace {
41 HWTEST_F(BrightnessManagerExtTest, NoInit, TestSize.Level0)
42 {
43     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerNoInit001: fun is start");
44     bool retBool = g_BrightnessManagerExt.AutoAdjustBrightness(true);
45     EXPECT_FALSE(retBool);
46 
47     retBool = g_BrightnessManagerExt.SetBrightness(90);
48     EXPECT_FALSE(retBool);
49 
50     retBool = g_BrightnessManagerExt.DiscountBrightness(0.8);
51     EXPECT_FALSE(retBool);
52 
53     double discount = g_BrightnessManagerExt.GetDiscount();
54     EXPECT_EQ(1.0, discount);
55 
56     g_BrightnessManagerExt.SetScreenOnBrightness();
57 
58     uint32_t value = g_BrightnessManagerExt.GetScreenOnBrightness();
59     EXPECT_EQ(0, value);
60 
61     g_BrightnessManagerExt.ClearOffset();
62 
63     retBool = g_BrightnessManagerExt.OverrideBrightness(255);
64     usleep(DEFAULT_WAITING_TIME);
65     EXPECT_FALSE(retBool);
66 
67     retBool = g_BrightnessManagerExt.RestoreBrightness();
68     usleep(DEFAULT_WAITING_TIME);
69     EXPECT_FALSE(retBool);
70 
71     retBool = g_BrightnessManagerExt.BoostBrightness(10000);
72     EXPECT_FALSE(retBool);
73 
74     usleep(DEFAULT_WAITING_TIME);
75     retBool = g_BrightnessManagerExt.CancelBoostBrightness();
76     EXPECT_FALSE(retBool);
77 
78     uint32_t brightness = g_BrightnessManagerExt.GetBrightness();
79     EXPECT_EQ(0, brightness);
80 
81     usleep(DEFAULT_WAITING_TIME);
82     uint32_t deviceBrightness = g_BrightnessManagerExt.GetDeviceBrightness();
83     EXPECT_EQ(0, value);
84 
85     retBool = g_BrightnessManagerExt.IsBrightnessOverridden();
86     EXPECT_FALSE(retBool);
87 
88     retBool = g_BrightnessManagerExt.IsBrightnessBoosted();
89     EXPECT_FALSE(retBool);
90 
91     uint32_t currentDisplayId = g_BrightnessManagerExt.GetCurrentDisplayId(0);
92     EXPECT_EQ(0, currentDisplayId);
93 
94     retBool = g_BrightnessManagerExt.SetBrightness(100);
95     EXPECT_FALSE(retBool);
96 
97     retBool = g_BrightnessManagerExt.SetMaxBrightnessNit(100);
98     EXPECT_FALSE(retBool);
99     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerNoInit001: fun is end");
100 }
101 
102 HWTEST_F(BrightnessManagerExtTest, MockInit001, TestSize.Level0)
103 {
104     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerMockInit001: fun is start");
105     // 打桩
106     MockInitBrightnessManagerExt(g_BrightnessManagerExt);
107     MockClearValues();
108 
109     g_BrightnessManagerExt.SetDisplayState(0, DisplayState::DISPLAY_OFF);
110 
111     MockSetValue(1.0);
112     usleep(DEFAULT_WAITING_TIME);
113     bool retBool = g_BrightnessManagerExt.AutoAdjustBrightness(true);
114     MockClearValues();
115     EXPECT_TRUE(retBool);
116 
117     MockSetValue(2.0);
118     usleep(DEFAULT_WAITING_TIME);
119     retBool = g_BrightnessManagerExt.SetBrightness(0, 0, true);
120     MockClearValues();
121     EXPECT_TRUE(retBool);
122 
123     MockSetValue(3.0);
124     usleep(DEFAULT_WAITING_TIME);
125     retBool = g_BrightnessManagerExt.DiscountBrightness(91.0);
126     MockClearValues();
127     EXPECT_TRUE(retBool);
128 
129     MockSetValue(4.0);
130     usleep(DEFAULT_WAITING_TIME);
131     auto ret = g_BrightnessManagerExt.GetDiscount();
132     MockClearValues();
133     EXPECT_EQ(ret, 4.0);
134 
135     g_BrightnessManagerExt.SetScreenOnBrightness();
136 
137     MockSetValue(5.0);
138     usleep(DEFAULT_WAITING_TIME);
139     int onBrightness= g_BrightnessManagerExt.GetScreenOnBrightness();
140     MockClearValues();
141     EXPECT_EQ(onBrightness, 5);
142 
143     g_BrightnessManagerExt.ClearOffset();
144 
145     MockSetValue(6.0);
146     usleep(DEFAULT_WAITING_TIME);
147     retBool = g_BrightnessManagerExt.OverrideBrightness(0, 0);
148     MockClearValues();
149     EXPECT_TRUE(retBool);
150 
151     MockSetValue(7.0);
152     usleep(DEFAULT_WAITING_TIME);
153     retBool = g_BrightnessManagerExt.RestoreBrightness(0);
154     MockClearValues();
155     EXPECT_TRUE(retBool);
156     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerMockInit001: fun is end");
157 }
158 
159 HWTEST_F(BrightnessManagerExtTest, MockInit002, TestSize.Level0)
160 {
161     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerMockInit002: fun is start");
162     MockSetValue(8.0);
163     usleep(DEFAULT_WAITING_TIME);
164     bool retBool = g_BrightnessManagerExt.BoostBrightness(0, 0);
165     MockClearValues();
166     EXPECT_TRUE(retBool);
167 
168     MockSetValue(9.0);
169     usleep(DEFAULT_WAITING_TIME);
170     retBool = g_BrightnessManagerExt.CancelBoostBrightness(0);
171     MockClearValues();
172     EXPECT_TRUE(retBool);
173 
174     MockSetValue(10.0);
175     usleep(DEFAULT_WAITING_TIME);
176     int brightness= g_BrightnessManagerExt.GetBrightness();
177     MockClearValues();
178     EXPECT_EQ(brightness, 10);
179 
180     MockSetValue(11.0);
181     usleep(DEFAULT_WAITING_TIME);
182     int deviceBrightness= g_BrightnessManagerExt.GetDeviceBrightness();
183     MockClearValues();
184     EXPECT_EQ(deviceBrightness, 11);
185 
186     MockSetValue(12.0);
187     usleep(DEFAULT_WAITING_TIME);
188     retBool = g_BrightnessManagerExt.IsBrightnessOverridden();
189     MockClearValues();
190     EXPECT_TRUE(retBool);
191 
192     MockSetValue(13.0);
193     usleep(DEFAULT_WAITING_TIME);
194     retBool = g_BrightnessManagerExt.IsBrightnessBoosted();
195     MockClearValues();
196     EXPECT_TRUE(retBool);
197 
198     MockSetValue(14.0);
199     usleep(DEFAULT_WAITING_TIME);
200     int currentDisplayId= g_BrightnessManagerExt.GetCurrentDisplayId(1);
201     MockClearValues();
202     EXPECT_EQ(currentDisplayId, 14);
203 
204     MockSetValue(15.0);
205     usleep(DEFAULT_WAITING_TIME);
206     retBool = g_BrightnessManagerExt.SetMaxBrightness(1.0);
207     MockClearValues();
208     EXPECT_TRUE(retBool);
209 
210     g_BrightnessManagerExt.SetDisplayId(1);
211 
212     MockSetValue(16.0);
213     usleep(DEFAULT_WAITING_TIME);
214     retBool = g_BrightnessManagerExt.SetMaxBrightnessNit(1.0);
215     MockClearValues();
216     EXPECT_TRUE(retBool);
217     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerMockInit002: fun is end");
218 }
219 
220 HWTEST_F(BrightnessManagerExtTest, Init, TestSize.Level0)
221 {
222     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerExtInit001: fun is start");
223     MockDeInitBrightnessManagerExt(g_BrightnessManagerExt);
224     MockClearValues();
225     g_BrightnessManagerExt.Init(MIN_DEFAULT_BRIGHTNESS_LEVEL, MAX_DEFAULT_BRIGHTNESS_LEVEL);
226     usleep(INIT_WAITING_TIME);
227     DISPLAY_HILOGI(LABEL_TEST, "BrightnessManagerExtInit001: fun is end");
228 }
229 
230 } // namespace