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 }
80 }
81
82 /*
83 * Function: IsValid, GenerateFence, SyncFileReadTimestamp
84 * Type: Function
85 * Rank: Important(2)
86 * EnvConditions: N/A
87 * CaseDescription: 1. call GenerateFence
88 * 2. check ret
89 */
90 HWTEST_F(SyncFenceTest, GetFenceInfo001, Function | MediumTest | Level2)
91 {
92 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
93 bool valid = syncTimeline_->IsValid();
94 if (valid) {
95 ASSERT_EQ(valid, true);
96 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 1);
97 SyncFence syncFence(fd);
98 ASSERT_GE(fd, 0);
99 int64_t timestamp = syncFence.SyncFileReadTimestamp();
100 ASSERT_EQ(timestamp, SyncFence::FENCE_PENDING_TIMESTAMP);
101 auto ret = syncTimeline_->IncreaseSyncPoint(1);
102 ASSERT_EQ(ret, 0);
103 timestamp = syncFence.SyncFileReadTimestamp();
104 ASSERT_GT(timestamp, 0);
105 } else {
106 ASSERT_EQ(valid, false);
107 }
108 }
109
110 /*
111 * Function: IsValid, GenerateFence, IncreaseSyncPoint, GetStatus
112 * Type: Function
113 * Rank: Important(2)
114 * EnvConditions: N/A
115 * CaseDescription: 1. call IsValid, GenerateFence, IncreaseSyncPoint, GetStatus
116 * 2. check ret
117 */
118 HWTEST_F(SyncFenceTest, OneTimeLineGetStatus001, Function | MediumTest | Level2)
119 {
120 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
121 bool valid = syncTimeline_->IsValid();
122 if (valid) {
123 ASSERT_EQ(valid, true);
124 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 1);
125 SyncFence syncFence(fd);
126 ASSERT_GE(fd, 0);
127 FenceStatus st = syncFence.GetStatus();
128 ASSERT_EQ(st, FenceStatus::ACTIVE);
129 auto ret = syncTimeline_->IncreaseSyncPoint(1);
130 ASSERT_EQ(ret, 0);
131 st = syncFence.GetStatus();
132 ASSERT_EQ(st, FenceStatus::SIGNALED);
133 // go 2 even futher, still signal status
134 syncTimeline_->IncreaseSyncPoint(2);
135 ASSERT_EQ(ret, 0);
136 st = syncFence.GetStatus();
137 ASSERT_EQ(st, FenceStatus::SIGNALED);
138 } else {
139 ASSERT_EQ(valid, false);
140 }
141 }
142
143 /*
144 * Function: IsValid, GenerateFence, Wait, GetStatus
145 * Type: Function
146 * Rank: Important(2)
147 * EnvConditions: N/A
148 * CaseDescription: 1. call IsValid, GenerateFence, Wait, GetStatus
149 * 2. check ret
150 */
151 HWTEST_F(SyncFenceTest, OneTimeLineWait001, Function | MediumTest | Level2)
152 {
153 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
154 bool valid = syncTimeline_->IsValid();
155 if (valid) {
156 ASSERT_EQ(valid, true);
157 int32_t fd = syncTimeline_->GenerateFence("test sw_sync_fence", 3);
158 SyncFence syncFence(fd);
159 ASSERT_GE(fd, 0);
160
161 // increase timeline from 0 -> 1
162 auto ret = syncTimeline_->IncreaseSyncPoint(1);
163 ASSERT_EQ(ret, 0);
164 // wait on fence until timeout
165 ret = syncFence.Wait(0);
166 ASSERT_LT(ret, 0);
167 ASSERT_EQ(errno, ETIME);
168 auto st = syncFence.GetStatus();
169 ASSERT_EQ(st, FenceStatus::ACTIVE);
170 // increase 2 timeline from 1 -> 3, signal the fence
171 ret = syncTimeline_->IncreaseSyncPoint(2);
172 ASSERT_EQ(ret, 0);
173 // wait succ
174 ret = syncFence.Wait(0);
175 ASSERT_EQ(ret, 0);
176 st = syncFence.GetStatus();
177 ASSERT_EQ(st, FenceStatus::SIGNALED);
178 // go 5 even futher, still signal status
179 ret = syncTimeline_->IncreaseSyncPoint(5);
180 ASSERT_EQ(ret, 0);
181 ret = syncFence.Wait(0);
182 ASSERT_EQ(ret, 0);
183 st = syncFence.GetStatus();
184 ASSERT_EQ(st, FenceStatus::SIGNALED);
185 } else {
186 ASSERT_EQ(valid, false);
187 }
188 }
189
190 /*
191 * Function: IsValid, GenerateFence, MergeFence
192 * Type: Function
193 * Rank: Important(2)
194 * EnvConditions: N/A
195 * CaseDescription: 1. call IsValid, GenerateFence, MergeFence
196 * 2. check ret
197 */
198 HWTEST_F(SyncFenceTest, OneTimeLineMerge001, Function | MediumTest | Level2)
199 {
200 sptr<SyncTimeline> syncTimeline_ = new SyncTimeline();
201 bool valid = syncTimeline_->IsValid();
202 if (valid) {
203 ASSERT_EQ(valid, true);
204 int32_t fd1 = syncTimeline_->GenerateFence("test sw_sync_fence1", 1);
205 sptr<SyncFence> syncFence1 = new SyncFence(fd1);
206 ASSERT_GE(fd1, 0);
207 // timeline generate fence2 target 5 seq.no
208 int32_t fd2 = syncTimeline_->GenerateFence("test sw_sync_fence2", 5);
209 sptr<SyncFence> syncFence2 = new SyncFence(fd2);
210 ASSERT_GE(fd2, 0);
211
212 sptr<SyncFence> fdMerged = SyncFence::MergeFence("merged sw_fence", syncFence1, syncFence2);
213 ASSERT_GE(fdMerged->Get(), 0);
214 auto st = fdMerged->GetStatus();
215 ASSERT_EQ(st, FenceStatus::ACTIVE);
216
217 // increase 1 timeline from 0 -> 1
218 auto ret = syncTimeline_->IncreaseSyncPoint(1);
219 ASSERT_EQ(ret, 0);
220 st = fdMerged->GetStatus();
221 ASSERT_EQ(st, FenceStatus::ACTIVE);
222 // increase 4 timeline from 1 -> 5, signal fence
223 ret = syncTimeline_->IncreaseSyncPoint(4);
224 ASSERT_EQ(ret, 0);
225 st = fdMerged->GetStatus();
226 ASSERT_EQ(st, FenceStatus::SIGNALED);
227 } else {
228 ASSERT_EQ(valid, false);
229 }
230 }
231
232 /*
233 * Function: IsValid, GenerateFence, MergeFence
234 * Type: Function
235 * Rank: Important(2)
236 * EnvConditions: N/A
237 * CaseDescription: 1. call IsValid, GenerateFence, MergeFence
238 * 2. check ret
239 */
240 HWTEST_F(SyncFenceTest, MultiTimeLineMerge001, Function | MediumTest | Level2)
241 {
242 sptr<SyncTimeline> syncTimeline1_ = new SyncTimeline();
243 bool valid = syncTimeline1_->IsValid();
244 if (!valid) {
245 ASSERT_EQ(valid, false);
246 return;
247 }
248 sptr<SyncTimeline> syncTimeline2_ = new SyncTimeline();
249 valid = syncTimeline2_->IsValid();
250 if (valid) {
251 ASSERT_EQ(valid, true);
252 // timeline1 generate fence1 target 1 seq.no
253 int32_t fd1 = syncTimeline1_->GenerateFence("test sw_sync_fence1", 1);
254 sptr<SyncFence> syncFence1 = new SyncFence(fd1);
255 ASSERT_GE(fd1, 0);
256 // timeline2 generate fence2 target 5 seq.no
257 int32_t fd2 = syncTimeline2_->GenerateFence("test sw_sync_fence2", 5);
258 sptr<SyncFence> syncFence2 = new SyncFence(fd2);
259 ASSERT_GE(fd2, 0);
260
261 sptr<SyncFence> fdMerged = SyncFence::MergeFence("merged sw_fence", syncFence1, syncFence2);
262 ASSERT_GE(fdMerged->Get(), 0);
263 auto st = fdMerged->GetStatus();
264 ASSERT_EQ(st, FenceStatus::ACTIVE);
265 // timeline1 increase 1 timeline from 0 -> 1, signal fence fence1
266 auto ret = syncTimeline1_->IncreaseSyncPoint(1);
267 ASSERT_EQ(ret, 0);
268 st = fdMerged->GetStatus();
269 ASSERT_EQ(st, FenceStatus::ACTIVE);
270 // timeline2 increase 5 timeline from 0 -> 5, signal fence fence2
271 ret = syncTimeline2_->IncreaseSyncPoint(5);
272 ASSERT_EQ(ret, 0);
273 st = fdMerged->GetStatus();
274 ASSERT_EQ(st, FenceStatus::SIGNALED);
275 } else {
276 ASSERT_EQ(valid, false);
277 }
278 }
279 } // namespace OHOS