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
18 #include "frame_sched.h"
19 #include "sync_fence.h"
20
21 using namespace testing;
22 using namespace testing::ext;
23
24 namespace OHOS {
25 class FrameSchedTest : public testing::Test {
26 public:
27 static void SetUpTestCase();
28 static void TearDownTestCase();
29 };
30
SetUpTestCase()31 void FrameSchedTest::SetUpTestCase()
32 {
33 }
34
TearDownTestCase()35 void FrameSchedTest::TearDownTestCase()
36 {
37 }
38
39 /*
40 * Function: SetFrameParam
41 * Type: Function
42 * Rank: Important(2)
43 * EnvConditions: N/A
44 * CaseDescription: 1. call SetFrameParam
45 * 2. check ret
46 */
47 HWTEST_F(FrameSchedTest, SetFrameParam001, Function | MediumTest | Level2)
48 {
49 Rosen::FrameSched frameSched_;
50 EXPECT_EQ(frameSched_.setFrameParamFunc_, nullptr);
51 frameSched_.SetFrameParam(0, 0, 0, 0);
52 }
53
54 /*
55 * Function: SendFenceId
56 * Type: Function
57 * Rank: Important(2)
58 * EnvConditions: N/A
59 * CaseDescription: 1. call SendFenceId
60 * 2. check ret
61 */
62 HWTEST_F(FrameSchedTest, SendFenceId001, Function | MediumTest | Level2)
63 {
64 Rosen::FrameSched frameSched_;
65 uint32_t fenceId = 1;
66 frameSched_.sendFenceIdFunc_ = nullptr;
67 frameSched_.schedSoLoaded_ = false;
68 frameSched_.SendFenceId(fenceId);
69 EXPECT_EQ(frameSched_.sendFenceIdFunc_, nullptr);
70 frameSched_.schedSoLoaded_ = true;
71 frameSched_.SendFenceId(fenceId);
72 EXPECT_EQ(frameSched_.sendFenceIdFunc_, nullptr);
73 frameSched_.LoadLibrary();
74 frameSched_.schedSoLoaded_ = false;
75 frameSched_.SendFenceId(fenceId);
76 EXPECT_NE(frameSched_.sendFenceIdFunc_, nullptr);
77 frameSched_.schedSoLoaded_ = true;
78 frameSched_.SendFenceId(fenceId);
79 EXPECT_NE(frameSched_.sendFenceIdFunc_, nullptr);
80 }
81
82 /*
83 * Function: MonitorGpuStart
84 * Type: Function
85 * Rank: Important(2)
86 * EnvConditions: N/A
87 * CaseDescription: 1. call MonitorGpuStart
88 * 2. check ret
89 */
90 HWTEST_F(FrameSchedTest, MonitorGpuStart001, Function | MediumTest | Level2)
91 {
92 Rosen::FrameSched frameSched_;
93 uint32_t fenceId = 1;
94 frameSched_.monitorGpuStartFunc_ = nullptr;
95 frameSched_.schedSoLoaded_ = false;
96 frameSched_.MonitorGpuStart(fenceId);
97 EXPECT_EQ(frameSched_.monitorGpuStartFunc_, nullptr);
98 frameSched_.schedSoLoaded_ = true;
99 frameSched_.MonitorGpuStart(fenceId);
100 EXPECT_EQ(frameSched_.monitorGpuStartFunc_, nullptr);
101 frameSched_.LoadLibrary();
102 frameSched_.schedSoLoaded_ = false;
103 frameSched_.MonitorGpuStart(fenceId);
104 EXPECT_NE(frameSched_.monitorGpuStartFunc_, nullptr);
105 frameSched_.schedSoLoaded_ = true;
106 frameSched_.MonitorGpuStart(fenceId);
107 EXPECT_NE(frameSched_.monitorGpuStartFunc_, nullptr);
108 }
109
110 /*
111 * Function: MonitorGpuEnd
112 * Type: Function
113 * Rank: Important(2)
114 * EnvConditions: N/A
115 * CaseDescription: 1. call MonitorGpuEnd
116 * 2. check ret
117 */
118 HWTEST_F(FrameSchedTest, MonitorGpuEnd001, Function | MediumTest | Level2)
119 {
120 Rosen::FrameSched frameSched_;
121 frameSched_.monitorGpuEndFunc_ = nullptr;
122 frameSched_.schedSoLoaded_ = false;
123 frameSched_.MonitorGpuEnd();
124 EXPECT_EQ(frameSched_.monitorGpuEndFunc_, nullptr);
125 frameSched_.schedSoLoaded_ = true;
126 frameSched_.MonitorGpuEnd();
127 EXPECT_EQ(frameSched_.monitorGpuEndFunc_, nullptr);
128 frameSched_.LoadLibrary();
129 frameSched_.schedSoLoaded_ = false;
130 frameSched_.MonitorGpuEnd();
131 EXPECT_NE(frameSched_.monitorGpuEndFunc_, nullptr);
132 frameSched_.schedSoLoaded_ = true;
133 frameSched_.MonitorGpuEnd();
134 EXPECT_NE(frameSched_.monitorGpuEndFunc_, nullptr);
135 }
136
137 /*
138 * Function: IsScbScene
139 * Type: Function
140 * Rank: Important(2)
141 * EnvConditions: N/A
142 * CaseDescription: 1. call IsScbScene
143 * 2. check ret
144 */
145 HWTEST_F(FrameSchedTest, IsScbScene001, Function | MediumTest | Level2)
146 {
147 Rosen::FrameSched frameSched_;
148 frameSched_.isScbSceneFunc_ = nullptr;
149 frameSched_.schedSoLoaded_ = false;
150 frameSched_.IsScbScene();
151 EXPECT_EQ(frameSched_.isScbSceneFunc_, nullptr);
152 frameSched_.schedSoLoaded_ = true;
153 frameSched_.IsScbScene();
154 EXPECT_EQ(frameSched_.isScbSceneFunc_, nullptr);
155 frameSched_.LoadLibrary();
156 frameSched_.schedSoLoaded_ = false;
157 frameSched_.IsScbScene();
158 EXPECT_NE(frameSched_.isScbSceneFunc_, nullptr);
159 frameSched_.schedSoLoaded_ = true;
160 frameSched_.IsScbScene();
161 EXPECT_NE(frameSched_.isScbSceneFunc_, nullptr);
162 }
163
164 /*
165 * Function: SyncMerge
166 * Type: Function
167 * Rank: Important(2)
168 * EnvConditions: N/A
169 * CaseDescription: 1. call SyncMerge
170 * 2. check ret
171 */
172 HWTEST_F(FrameSchedTest, SyncMergeTest001, Function | MediumTest | Level2)
173 {
174 int32_t newFenceFd = -1;
175 ASSERT_EQ(SyncFence::SyncMerge("SyncMergeTest001", 1, -1, newFenceFd), -1);
176 ASSERT_EQ(newFenceFd, -1);
177
178 sptr<SyncFence> fence = new SyncFence(0);
179 ASSERT_EQ(fence->GetStatus(), FenceStatus::ERROR);
180
181 sptr<SyncFence> fence1 = new SyncFence(-1);
182 EXPECT_EQ(fence1->GetStatus(), ERROR);
183 }
184
185 /*
186 * Function: LoadLibrary
187 * Type: Function
188 * Rank: Important(2)
189 * EnvConditions: N/A
190 * CaseDescription: 1. call LoadLibrary
191 * 2. check ret
192 */
193 HWTEST_F(FrameSchedTest, LoadLibrary001, Function | MediumTest | Level2)
194 {
195 auto frameSched = new Rosen::FrameSched();
196 frameSched->schedSoLoaded_ = false;
197 bool res = frameSched->LoadLibrary();
198 EXPECT_TRUE(res);
199
200 frameSched->schedSoLoaded_ = true;
201 res = frameSched->LoadLibrary();
202 EXPECT_TRUE(res);
203
204 delete frameSched;
205 }
206
207 /*
208 * Function: CloseLibrary
209 * Type: Function
210 * Rank: Important(2)
211 * EnvConditions: N/A
212 * CaseDescription: 1. call CloseLibrary
213 * 2. check ret
214 */
215 HWTEST_F(FrameSchedTest, CloseLibrary001, Function | MediumTest | Level2)
216 {
217 auto frameSched = new Rosen::FrameSched();
218 frameSched->schedHandle_ = nullptr;
219 frameSched->schedSoLoaded_ = true;
220 frameSched->CloseLibrary();
221 EXPECT_FALSE(frameSched->schedSoLoaded_);
222 delete frameSched;
223 }
224
225 /*
226 * Function: LoadSymbol
227 * Type: Function
228 * Rank: Important(2)
229 * EnvConditions: N/A
230 * CaseDescription: 1. call LoadSymbol
231 * 2. check ret
232 */
233 HWTEST_F(FrameSchedTest, LoadSymbol001, Function | MediumTest | Level2)
234 {
235 auto frameSched = new Rosen::FrameSched();
236 frameSched->schedSoLoaded_ = false;
237 auto res = frameSched->LoadSymbol("LoadSymbol001");
238 EXPECT_EQ(res, nullptr);
239 delete frameSched;
240 }
241
242 /*
243 * Function: Init
244 * Type: Function
245 * Rank: Important(2)
246 * EnvConditions: N/A
247 * CaseDescription: 1. call Init
248 * 2. check ret
249 */
250 HWTEST_F(FrameSchedTest, Init001, Function | MediumTest | Level2)
251 {
252 auto frameSched = new Rosen::FrameSched();
253 frameSched->initFunc_ = nullptr;
254 frameSched->Init();
255 EXPECT_NE(frameSched->initFunc_, nullptr);
256 delete frameSched;
257 }
258 }