1 /*
2 * Copyright (c) 2022 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 <ostream>
18 #include <securec.h>
19 #include <cstdint>
20 #include "refbase.h"
21 #include "sync_fence.h"
22
23 using namespace testing;
24 using namespace testing::ext;
25
26 namespace OHOS {
27 class SyncFenceTest : public testing::Test {
28 public:
29 static void SetUpTestCase();
30 static void TearDownTestCase();
31 };
32
SetUpTestCase()33 void SyncFenceTest::SetUpTestCase()
34 {
35 }
36
TearDownTestCase()37 void SyncFenceTest::TearDownTestCase()
38 {
39 }
40
41 /*
42 * Function: IsValid
43 * Type: Function
44 * Rank: Important(2)
45 * EnvConditions: N/A
46 * CaseDescription: 1. call IsValid
47 * 2. check ret
48 */
49 HWTEST_F(SyncFenceTest, IsValid001, Function | MediumTest | Level2)
50 {
51 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
52 bool valid = syncTimeline_->IsValid();
53 if (valid) {
54 ASSERT_EQ(valid, true);
55 } else {
56 ASSERT_EQ(valid, false);
57 }
58 }
59
60 /*
61 * Function: IsValid, GenerateFence
62 * Type: Function
63 * Rank: Important(2)
64 * EnvConditions: N/A
65 * CaseDescription: 1. call GenerateFence
66 * 2. check ret
67 */
68 HWTEST_F(SyncFenceTest, GenerateFence001, Function | MediumTest | Level2)
69 {
70 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
71 bool valid = syncTimeline_->IsValid();
72 if (valid) {
73 ASSERT_EQ(valid, true);
74 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 1);
75 SyncFence syncFence(fd);
76 ASSERT_GE(fd, 0);
77 } else {
78 ASSERT_EQ(valid, false);
79 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 1);
80 ASSERT_EQ(fd, -1);
81 int32_t ret = syncTimeline_->IncreaseSyncPoint(1);
82 ASSERT_EQ(ret, -1);
83 }
84 }
85
86 /*
87 * Function: IsValid, GenerateFence, SyncFileReadTimestamp
88 * Type: Function
89 * Rank: Important(2)
90 * EnvConditions: N/A
91 * CaseDescription: 1. call GenerateFence
92 * 2. check ret
93 */
94 HWTEST_F(SyncFenceTest, GetFenceInfo001, Function | MediumTest | Level2)
95 {
96 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
97 bool valid = syncTimeline_->IsValid();
98 if (valid) {
99 ASSERT_EQ(valid, true);
100 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 1);
101 SyncFence syncFence(fd);
102 ASSERT_GE(fd, 0);
103 int64_t timestamp = syncFence.SyncFileReadTimestamp();
104 ASSERT_EQ(timestamp, SyncFence::FENCE_PENDING_TIMESTAMP);
105 auto ret = syncTimeline_->IncreaseSyncPoint(1);
106 ASSERT_EQ(ret, 0);
107 timestamp = syncFence.SyncFileReadTimestamp();
108 ASSERT_GT(timestamp, 0);
109 } else {
110 ASSERT_EQ(valid, false);
111 }
112 }
113
114 /*
115 * Function: IsValid, GenerateFence, IncreaseSyncPoint, GetStatus
116 * Type: Function
117 * Rank: Important(2)
118 * EnvConditions: N/A
119 * CaseDescription: 1. call IsValid, GenerateFence, IncreaseSyncPoint, GetStatus
120 * 2. check ret
121 */
122 HWTEST_F(SyncFenceTest, OneTimeLineGetStatus001, Function | MediumTest | Level2)
123 {
124 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
125 bool valid = syncTimeline_->IsValid();
126 if (valid) {
127 ASSERT_EQ(valid, true);
128 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 1);
129 SyncFence syncFence(fd);
130 ASSERT_GE(fd, 0);
131 FenceStatus st = syncFence.GetStatus();
132 ASSERT_EQ(st, FenceStatus::ACTIVE);
133 auto ret = syncTimeline_->IncreaseSyncPoint(1);
134 ASSERT_EQ(ret, 0);
135 st = syncFence.GetStatus();
136 ASSERT_EQ(st, FenceStatus::SIGNALED);
137 // go 2 even futher, still signal status
138 syncTimeline_->IncreaseSyncPoint(2);
139 ASSERT_EQ(ret, 0);
140 st = syncFence.GetStatus();
141 ASSERT_EQ(st, FenceStatus::SIGNALED);
142 } else {
143 ASSERT_EQ(valid, false);
144 }
145 }
146
147 /*
148 * Function: IsValid, GenerateFence, Wait, GetStatus
149 * Type: Function
150 * Rank: Important(2)
151 * EnvConditions: N/A
152 * CaseDescription: 1. call IsValid, GenerateFence, Wait, GetStatus
153 * 2. check ret
154 */
155 HWTEST_F(SyncFenceTest, OneTimeLineWait001, Function | MediumTest | Level2)
156 {
157 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
158 bool valid = syncTimeline_->IsValid();
159 if (valid) {
160 ASSERT_EQ(valid, true);
161 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 3);
162 SyncFence syncFence(fd);
163 ASSERT_GE(fd, 0);
164
165 // increase timeline from 0 -> 1
166 auto ret = syncTimeline_->IncreaseSyncPoint(1);
167 ASSERT_EQ(ret, 0);
168 // wait on fence until timeout
169 ret = syncFence.Wait(0);
170 ASSERT_LT(ret, 0);
171 ASSERT_EQ(errno, ETIME);
172 auto st = syncFence.GetStatus();
173 ASSERT_EQ(st, FenceStatus::ACTIVE);
174 // increase 2 timeline from 1 -> 3, signal the fence
175 ret = syncTimeline_->IncreaseSyncPoint(2);
176 ASSERT_EQ(ret, 0);
177 // wait succ
178 ret = syncFence.Wait(0);
179 ASSERT_EQ(ret, 0);
180 st = syncFence.GetStatus();
181 ASSERT_EQ(st, FenceStatus::SIGNALED);
182 // go 5 even futher, still signal status
183 ret = syncTimeline_->IncreaseSyncPoint(5);
184 ASSERT_EQ(ret, 0);
185 ret = syncFence.Wait(0);
186 ASSERT_EQ(ret, 0);
187 st = syncFence.GetStatus();
188 ASSERT_EQ(st, FenceStatus::SIGNALED);
189 } else {
190 ASSERT_EQ(valid, false);
191 }
192 }
193
194 /*
195 * Function: IsValid, GenerateFence, MergeFence
196 * Type: Function
197 * Rank: Important(2)
198 * EnvConditions: N/A
199 * CaseDescription: 1. call IsValid, GenerateFence, MergeFence
200 * 2. check ret
201 */
202 HWTEST_F(SyncFenceTest, OneTimeLineMerge001, Function | MediumTest | Level2)
203 {
204 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
205 bool valid = syncTimeline_->IsValid();
206 if (valid) {
207 ASSERT_EQ(valid, true);
208 int32_t fd1 = syncTimeline_->GenerateFence("test sw_sync_fence1", 1);
209 sptr<SyncFence> syncFence1 = new SyncFence(fd1);
210 ASSERT_GE(fd1, 0);
211 // timeline generate fence2 target 5 seq.no
212 int32_t fd2 = syncTimeline_->GenerateFence("test sw_sync_fence2", 5);
213 sptr<SyncFence> syncFence2 = new SyncFence(fd2);
214 ASSERT_GE(fd2, 0);
215
216 sptr<SyncFence> fdMerged = SyncFence::MergeFence("merged sw_fence", syncFence1, syncFence2);
217 ASSERT_GE(fdMerged->Get(), 0);
218 auto st = fdMerged->GetStatus();
219 ASSERT_EQ(st, FenceStatus::ACTIVE);
220
221 // increase 1 timeline from 0 -> 1
222 auto ret = syncTimeline_->IncreaseSyncPoint(1);
223 ASSERT_EQ(ret, 0);
224 st = fdMerged->GetStatus();
225 ASSERT_EQ(st, FenceStatus::ACTIVE);
226 // increase 4 timeline from 1 -> 5, signal fence
227 ret = syncTimeline_->IncreaseSyncPoint(4);
228 ASSERT_EQ(ret, 0);
229 st = fdMerged->GetStatus();
230 ASSERT_EQ(st, FenceStatus::SIGNALED);
231 } else {
232 ASSERT_EQ(valid, false);
233 }
234 }
235
236 /*
237 * Function: IsValid, GenerateFence, MergeFence
238 * Type: Function
239 * Rank: Important(2)
240 * EnvConditions: N/A
241 * CaseDescription: 1. call IsValid, GenerateFence, MergeFence
242 * 2. check ret
243 */
244 HWTEST_F(SyncFenceTest, MultiTimeLineMerge001, Function | MediumTest | Level2)
245 {
246 sptr<SyncTimeline> syncTimeline1_ = new SyncTimeline();
247 bool valid = syncTimeline1_->IsValid();
248 if (!valid) {
249 ASSERT_EQ(valid, false);
250 return;
251 }
252 sptr<SyncTimeline> syncTimeline2_ = new SyncTimeline();
253 valid = syncTimeline2_->IsValid();
254 if (valid) {
255 ASSERT_EQ(valid, true);
256 // timeline1 generate fence1 target 1 seq.no
257 int32_t fd1 = syncTimeline1_->GenerateFence("test sw_sync_fence1", 1);
258 sptr<SyncFence> syncFence1 = new SyncFence(fd1);
259 ASSERT_GE(fd1, 0);
260 // timeline2 generate fence2 target 5 seq.no
261 int32_t fd2 = syncTimeline2_->GenerateFence("test sw_sync_fence2", 5);
262 sptr<SyncFence> syncFence2 = new SyncFence(fd2);
263 ASSERT_GE(fd2, 0);
264
265 sptr<SyncFence> fdMerged = SyncFence::MergeFence("merged sw_fence", syncFence1, syncFence2);
266 ASSERT_GE(fdMerged->Get(), 0);
267 auto st = fdMerged->GetStatus();
268 ASSERT_EQ(st, FenceStatus::ACTIVE);
269 // timeline1 increase 1 timeline from 0 -> 1, signal fence fence1
270 auto ret = syncTimeline1_->IncreaseSyncPoint(1);
271 ASSERT_EQ(ret, 0);
272 st = fdMerged->GetStatus();
273 ASSERT_EQ(st, FenceStatus::ACTIVE);
274 // timeline2 increase 5 timeline from 0 -> 5, signal fence fence2
275 ret = syncTimeline2_->IncreaseSyncPoint(5);
276 ASSERT_EQ(ret, 0);
277 st = fdMerged->GetStatus();
278 ASSERT_EQ(st, FenceStatus::SIGNALED);
279 } else {
280 ASSERT_EQ(valid, false);
281 }
282 }
283
284 /*
285 * Function: IsValid, Dup, Get
286 * Type: Function
287 * Rank: Important(2)
288 * EnvConditions: N/A
289 * CaseDescription: 1. call GenerateFence, IsValid, Dup, Get
290 * 2. check ret
291 */
292 HWTEST_F(SyncFenceTest, IsValidGetDup001, Function | MediumTest | Level2)
293 {
294 sptr<SyncTimeline> syncTimeline = new SyncTimeline();
295 bool valid = syncTimeline->IsValid();
296 if (valid) {
297 ASSERT_EQ(valid, true);
298 int32_t fd = syncTimeline->GenerateFence("test sw_sync_fence", 1);
299 SyncFence syncFence(fd);
300 ASSERT_GE(fd, 0);
301 bool fenceValid = syncFence.IsValid();
302 ASSERT_EQ(fenceValid, true);
303 int32_t getFd = syncFence.Get();
304 ASSERT_EQ(getFd, fd);
305 int32_t dupFenceFd = syncFence.Dup();
306 ASSERT_GE(dupFenceFd, 0);
307 } else {
308 ASSERT_EQ(valid, false);
309 }
310 }
311 } // namespace OHOS