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 <cstdint>
17 #include <gtest/gtest.h>
18 #include <hilog/log.h>
19 #include <memory>
20 #include <unistd.h>
21 #include <iostream>
22 
23 #include "transaction/rs_interfaces.h"
24 
25 using namespace testing::ext;
26 
27 namespace OHOS {
28 namespace Rosen {
29 class RSVirtualScreenRefreshRateTest : public testing::Test {
30 public:
31     static constexpr HiviewDFX::HiLogLabel LOG_LABEL = { LOG_CORE, 0, "RSVirtualScreenRefreshRateTest" };
32 
SetUpTestCase()33     static void SetUpTestCase()
34     {
35         rsInterfaces = &(RSInterfaces::GetInstance());
36     }
37 
TearDownTestCase()38     static void TearDownTestCase()
39     {
40         rsInterfaces = nullptr;
41     }
42 
43     static inline RSInterfaces* rsInterfaces = nullptr;
44 };
45 
46 /*
47 * Function: SetVirtualScreenRefreshRate
48 * Type: Function
49 * Rank: Important(1)
50 * EnvConditions: N/A
51 * CaseDescription: 1. SetVirtualScreenRefreshRate UINT32_MAX
52 */
53 HWTEST_F(RSVirtualScreenRefreshRateTest, SetVirtualScreenRefreshRate001, Function | SmallTest | Level1)
54 {
55     auto csurface = IConsumerSurface::Create();
56     EXPECT_NE(csurface, nullptr);
57     auto producer = csurface->GetProducer();
58     auto psurface = Surface::CreateSurfaceAsProducer(producer);
59     uint32_t defaultWidth = 720; // 720px
60     uint32_t defaultHeight = 1280; // 1280px
61     EXPECT_NE(psurface, nullptr);
62 
63     ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen(
64         "virtualScreen01", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1);
65     EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID);
66 
67     uint32_t maxRefreshRate = UINT32_MAX;
68     uint32_t actualRefreshRate = 0;
69     std::cout << "Set virtualScreenId:" << virtualScreenId << ", maxRefreshRate:" << maxRefreshRate << std::endl;
70     int32_t ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, maxRefreshRate, actualRefreshRate);
71     EXPECT_EQ(actualRefreshRate, 120);
72     EXPECT_EQ(ret, StatusCode::SUCCESS);
73 
74     // recover
75     ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, 60, actualRefreshRate); // 60hz
76     EXPECT_EQ(actualRefreshRate, 60); // 60hz
77     EXPECT_EQ(ret, StatusCode::SUCCESS);
78 }
79 
80 /*
81 * Function: SetVirtualScreenRefreshRate
82 * Type: Function
83 * Rank: Important(1)
84 * EnvConditions: N/A
85 * CaseDescription: 1. SetVirtualScreenRefreshRate 0
86 */
87 HWTEST_F(RSVirtualScreenRefreshRateTest, SetVirtualScreenRefreshRate002, Function | SmallTest | Level1)
88 {
89     auto csurface = IConsumerSurface::Create();
90     EXPECT_NE(csurface, nullptr);
91     auto producer = csurface->GetProducer();
92     auto psurface = Surface::CreateSurfaceAsProducer(producer);
93     uint32_t defaultWidth = 720; // 720px
94     uint32_t defaultHeight = 1280; // 1280px
95     EXPECT_NE(psurface, nullptr);
96 
97     ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen(
98         "virtualScreen01", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1);
99     EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID);
100 
101     uint32_t maxRefreshRate = 0;
102     uint32_t actualRefreshRate = 0;
103     std::cout << "Set virtualScreenId:" << virtualScreenId << ", maxRefreshRate:" << maxRefreshRate << std::endl;
104     int32_t ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, maxRefreshRate, actualRefreshRate);
105     EXPECT_EQ(actualRefreshRate, 0);
106     EXPECT_NE(ret, StatusCode::SUCCESS);
107 
108     // recover
109     ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, 60, actualRefreshRate); // 60hz
110     EXPECT_EQ(actualRefreshRate, 60); // 60hz
111     EXPECT_EQ(ret, StatusCode::SUCCESS);
112 }
113 
114 /*
115 * Function: SetVirtualScreenRefreshRate
116 * Type: Function
117 * Rank: Important(1)
118 * EnvConditions: N/A
119 * CaseDescription: 1. SetVirtualScreenRefreshRate 61
120 */
121 HWTEST_F(RSVirtualScreenRefreshRateTest, SetVirtualScreenRefreshRate003, Function | SmallTest | Level1)
122 {
123     auto csurface = IConsumerSurface::Create();
124     EXPECT_NE(csurface, nullptr);
125     auto producer = csurface->GetProducer();
126     auto psurface = Surface::CreateSurfaceAsProducer(producer);
127     uint32_t defaultWidth = 720; // 720px
128     uint32_t defaultHeight = 1280; // 1280px
129     EXPECT_NE(psurface, nullptr);
130 
131     ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen(
132         "virtualScreen01", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1);
133     EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID);
134 
135     uint32_t maxRefreshRate = 61; // 61hz
136     uint32_t actualRefreshRate = 0;
137     std::cout << "Set virtualScreenId:" << virtualScreenId << ", maxRefreshRate:" << maxRefreshRate << std::endl;
138     int32_t ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, maxRefreshRate, actualRefreshRate);
139     EXPECT_EQ(actualRefreshRate, 61);
140     EXPECT_EQ(ret, StatusCode::SUCCESS);
141 
142     // recover
143     ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, 60, actualRefreshRate); // 60hz
144     EXPECT_EQ(actualRefreshRate, 60); // 60hz
145     EXPECT_EQ(ret, StatusCode::SUCCESS);
146 }
147 
148 /*
149 * Function: SetVirtualScreenRefreshRate
150 * Type: Function
151 * Rank: Important(1)
152 * EnvConditions: N/A
153 * CaseDescription: 1. SetVirtualScreenRefreshRate 1~60
154 */
155 HWTEST_F(RSVirtualScreenRefreshRateTest, SetVirtualScreenRefreshRate004, Function | SmallTest | Level1)
156 {
157     auto csurface = IConsumerSurface::Create();
158     EXPECT_NE(csurface, nullptr);
159     auto producer = csurface->GetProducer();
160     auto psurface = Surface::CreateSurfaceAsProducer(producer);
161     uint32_t defaultWidth = 720; // 720px
162     uint32_t defaultHeight = 1280; // 1280px
163     EXPECT_NE(psurface, nullptr);
164 
165     ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen(
166         "virtualScreen01", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1);
167     EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID);
168 
169     for (uint32_t maxRefreshRate = 1; maxRefreshRate <= 60; maxRefreshRate++) { // 60hz
170         uint32_t actualRefreshRate = 0;
171         std::cout << "Set virtualScreenId:" << virtualScreenId << ", maxRefreshRate:" << maxRefreshRate << std::endl;
172         int32_t ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, maxRefreshRate, actualRefreshRate);
173         EXPECT_EQ(ret, StatusCode::SUCCESS);
174         EXPECT_EQ(actualRefreshRate, maxRefreshRate);
175     }
176 
177     // recover
178     uint32_t actualRefreshRate = 0;
179     int32_t ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, 60, actualRefreshRate); // 60hz
180     EXPECT_EQ(actualRefreshRate, 60); // 60hz
181     EXPECT_EQ(ret, StatusCode::SUCCESS);
182 }
183 
184 /*
185 * Function: SetVirtualScreenRefreshRate
186 * Type: Function
187 * Rank: Important(1)
188 * EnvConditions: N/A
189 * CaseDescription: 1. SetVirtualScreenRefreshRate with physical screen id
190 */
191 HWTEST_F(RSVirtualScreenRefreshRateTest, SetVirtualScreenRefreshRate005, Function | SmallTest | Level1)
192 {
193     ScreenId defaultScreenId = rsInterfaces->GetDefaultScreenId();
194     EXPECT_NE(defaultScreenId, INVALID_SCREEN_ID);
195     uint32_t maxRefreshRate = 30; // 30hz
196     uint32_t actualRefreshRate = 0;
197     std::cout << "Set defaultScreenId:" << defaultScreenId << ", maxRefreshRate:" << maxRefreshRate << std::endl;
198     int32_t ret = rsInterfaces->SetVirtualScreenRefreshRate(defaultScreenId, maxRefreshRate, actualRefreshRate);
199     EXPECT_EQ(ret, StatusCode::SCREEN_NOT_FOUND);
200     EXPECT_EQ(actualRefreshRate, 0);
201 }
202 
203 /*
204 * Function: SetVirtualScreenRefreshRate
205 * Type: Function
206 * Rank: Important(1)
207 * EnvConditions: N/A
208 * CaseDescription: 1. SetVirtualScreenRefreshRate UINT32_MAX+1
209 */
210 HWTEST_F(RSVirtualScreenRefreshRateTest, SetVirtualScreenRefreshRate006, Function | SmallTest | Level1)
211 {
212     auto csurface = IConsumerSurface::Create();
213     EXPECT_NE(csurface, nullptr);
214     auto producer = csurface->GetProducer();
215     auto psurface = Surface::CreateSurfaceAsProducer(producer);
216     uint32_t defaultWidth = 720; // 720px
217     uint32_t defaultHeight = 1280; // 1280px
218     EXPECT_NE(psurface, nullptr);
219 
220     ScreenId virtualScreenId = rsInterfaces->CreateVirtualScreen(
221         "virtualScreen01", defaultWidth, defaultHeight, psurface, INVALID_SCREEN_ID, -1);
222     EXPECT_NE(virtualScreenId, INVALID_SCREEN_ID);
223 
224     uint32_t maxRefreshRate = UINT32_MAX + 1;
225     uint32_t actualRefreshRate = 0;
226     std::cout << "Set virtualScreenId:" << virtualScreenId << ", maxRefreshRate:" << maxRefreshRate << std::endl;
227     int32_t ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, maxRefreshRate, actualRefreshRate);
228     EXPECT_EQ(actualRefreshRate, 0);
229     EXPECT_NE(ret, StatusCode::SUCCESS);
230 
231     // recover
232     ret = rsInterfaces->SetVirtualScreenRefreshRate(virtualScreenId, 60, actualRefreshRate); // 60hz
233     EXPECT_EQ(actualRefreshRate, 60); // 60hz
234     EXPECT_EQ(ret, StatusCode::SUCCESS);
235 }
236 } // namespace Rosen
237 } // namespace OHOS
238