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 "sync_fence_tracker.h"
19
20 using namespace testing;
21 using namespace testing::ext;
22
23 namespace OHOS {
24 class SyncFenceTrackerTest : public testing::Test {
25 public:
26 static void SetUpTestCase();
27 static void TearDownTestCase();
28 };
29
SetUpTestCase()30 void SyncFenceTrackerTest::SetUpTestCase()
31 {
32 }
33
TearDownTestCase()34 void SyncFenceTrackerTest::TearDownTestCase()
35 {
36 }
37
38 /*
39 * Function: TrackFence
40 * Type: Function
41 * Rank: Important(2)
42 * EnvConditions: N/A
43 * CaseDescription: 1. call TrackFence
44 * 2. check ret
45 */
46 HWTEST_F(SyncFenceTrackerTest, TrackFenceTest001, Function | MediumTest | Level2)
47 {
48 auto tracker = new SyncFenceTracker("TrackFenceTest001");
49 sptr<SyncFence> fence = new SyncFence(0);
50 tracker->TrackFence(nullptr, true);
51 EXPECT_EQ(tracker->fencesQueued_.load(), 0);
52
53 tracker->TrackFence(fence, true);
54 EXPECT_EQ(tracker->fencesQueued_.load(), 1);
55
56 tracker->isGpuFence_ = true;
57 tracker->TrackFence(fence, true);
58 EXPECT_EQ(tracker->fencesQueued_.load(), 2);
59
60 tracker->TrackFence(fence, false);
61 EXPECT_EQ(tracker->fencesQueued_.load(), 2);
62
63 tracker->isGpuFence_ = false;
64 tracker->TrackFence(fence, true);
65 EXPECT_EQ(tracker->fencesQueued_.load(), 3);
66
67 tracker->TrackFence(fence, false);
68 EXPECT_EQ(tracker->fencesQueued_.load(), 4);
69 delete tracker;
70 }
71
72 /*
73 * Function: TrackFence
74 * Type: Function
75 * Rank: Important(2)
76 * EnvConditions: N/A
77 * CaseDescription: 1. call TrackFence
78 * 2. check ret
79 */
80 HWTEST_F(SyncFenceTrackerTest, TrackFenceTest002, Function | MediumTest | Level2)
81 {
82 auto tracker = new SyncFenceTracker("Acquire Fence");
83 sptr<SyncFence> fence = new SyncFence(0);
84 tracker->TrackFence(nullptr, true);
85 EXPECT_EQ(tracker->fencesQueued_.load(), 0);
86
87 tracker->isGpuFreq_ = true;
88 tracker->TrackFence(fence, true);
89 EXPECT_EQ(tracker->fencesQueued_.load(), 1);
90
91 tracker->isGpuFreq_ = false;
92 tracker->TrackFence(fence, false);
93 EXPECT_EQ(tracker->fencesQueued_.load(), 1);
94 delete tracker;
95 }
96
97 /*
98 * Function: CheckGpuSubhealthEventLimit
99 * Type: Function
100 * Rank: Important(2)
101 * EnvConditions: N/A
102 * CaseDescription: 1. call CheckGpuSubhealthEventLimit
103 * 2. check ret
104 */
105 HWTEST_F(SyncFenceTrackerTest, CheckGpuSubhealthEventLimit001, Function | MediumTest | Level2)
106 {
107 auto tracker = new SyncFenceTracker("CheckGpuSubhealthEventLimit001");
108 tracker->gpuSubhealthEventNum_ = 0;
109 ASSERT_EQ(tracker->CheckGpuSubhealthEventLimit(), true);
110 tracker->gpuSubhealthEventDay_ = 0;
111 ASSERT_EQ(tracker->CheckGpuSubhealthEventLimit(), true);
112 tracker->gpuSubhealthEventNum_ = 1;
113 tracker->gpuSubhealthEventDay_ = 0xFFFFFFF;
114 ASSERT_EQ(tracker->CheckGpuSubhealthEventLimit(), true);
115 tracker->gpuSubhealthEventDay_ = 0xFFFFFFF;
116 tracker->gpuSubhealthEventNum_ = 0xFFFFFFF;
117 ASSERT_EQ(tracker->CheckGpuSubhealthEventLimit(), false);
118 delete tracker;
119 }
120
121 /*
122 * Function: GetFrameRate
123 * Type: Function
124 * Rank: Important(2)
125 * EnvConditions: N/A
126 * CaseDescription: 1. call GetFrameRate
127 * 2. check ret
128 */
129 HWTEST_F(SyncFenceTrackerTest, GetFrameRate001, Function | MediumTest | Level2)
130 {
131 auto tracker = new SyncFenceTracker("GetFrameRate001");
132 int32_t frameRate = tracker->GetFrameRate();
133 EXPECT_EQ(frameRate, 0);
134
135 for (int32_t i = 0; i < 2; i++) {
136 tracker->frameStartTimes_->push(1);
137 }
138 frameRate = tracker->GetFrameRate();
139 EXPECT_EQ(frameRate, 0);
140
141 tracker->frameStartTimes_->push(2);
142 frameRate = tracker->GetFrameRate();
143 EXPECT_EQ(frameRate, 2000);
144
145 delete tracker;
146 }
147
148 /*
149 * Function: ReportEventGpuSubhealth
150 * Type: Function
151 * Rank: Important(2)
152 * EnvConditions: N/A
153 * CaseDescription: 1. call ReportEventGpuSubhealth
154 * 2. check ret
155 */
156 HWTEST_F(SyncFenceTrackerTest, ReportEventGpuSubhealth001, Function | MediumTest | Level2)
157 {
158 auto tracker = new SyncFenceTracker("ReportEventGpuSubhealth001");
159 EXPECT_NE(tracker->handler_, nullptr);
160 tracker->ReportEventGpuSubhealth(0);
161 tracker->handler_ = nullptr;
162 tracker->ReportEventGpuSubhealth(0);
163 delete tracker;
164 }
165
166 /*
167 * Function: WaitFence
168 * Type: Function
169 * Rank: Important(2)
170 * EnvConditions: N/A
171 * CaseDescription: 1. call WaitFence
172 * 2. check ret
173 */
174 HWTEST_F(SyncFenceTrackerTest, WaitFence001, Function | MediumTest | Level2)
175 {
176 auto tracker = new SyncFenceTracker("WaitFence001");
177 auto fence = SyncFence::INVALID_FENCE;
178
179 tracker->isGpuFence_ = true;
180 tracker->isGpuEnable_ = true;
181 int32_t retCode = tracker->WaitFence(fence);
182 EXPECT_EQ(retCode, -1);
183
184 tracker->isGpuFence_ = true;
185 tracker->isGpuEnable_ = false;
186 tracker->WaitFence(fence);
187 EXPECT_EQ(retCode, -1);
188
189 tracker->isGpuFence_ = false;
190 tracker->isGpuEnable_ = true;
191 tracker->WaitFence(fence);
192 EXPECT_EQ(retCode, -1);
193
194 tracker->isGpuFence_ = false;
195 tracker->isGpuEnable_ = false;
196 tracker->WaitFence(fence);
197 EXPECT_EQ(retCode, -1);
198
199 delete tracker;
200 }
201
202 /*
203 * Function: SetBlurSize
204 * Type: Function
205 * Rank: Important(2)
206 * EnvConditions: N/A
207 * CaseDescription: 1. call SetBlurSize
208 * 2. check ret
209 */
210 HWTEST_F(SyncFenceTrackerTest, SetBlurSize001, Function | MediumTest | Level2)
211 {
212 auto tracker = new SyncFenceTracker("SetBlurSize001");
213 EXPECT_NE(tracker->handler_, nullptr);
214 tracker->SetBlurSize(0);
215 tracker->handler_ = nullptr;
216 tracker->SetBlurSize(0);
217 delete tracker;
218 }
219
220 /*
221 * Function: SetContainerNodeNum
222 * Type: Function
223 * Rank: Important(2)
224 * EnvConditions: N/A
225 * CaseDescription: 1. call SetContainerNodeNum
226 * 2. check ret
227 */
228 HWTEST_F(SyncFenceTrackerTest, SetContainerNodeNum001, Function | MediumTest | Level2)
229 {
230 auto tracker = new SyncFenceTracker("SetContainerNodeNum001");
231 tracker->isGpuEnable_ = true;
232 tracker->processedNodeNum_ = 0;
233 tracker->SetContainerNodeNum(1);
234 EXPECT_EQ(tracker->processedNodeNum_, 1);
235
236 tracker->isGpuEnable_ = false;
237 tracker->SetContainerNodeNum(1);
238 EXPECT_EQ(tracker->processedNodeNum_, 1);
239
240 delete tracker;
241 }
242 }