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#include <errno.h>
16#include <pthread.h>
17#include "pthread_util.h"
18
19extern int __pthread_cond_timedwait_time64(pthread_cond_t *__restrict,
20                            pthread_mutex_t *__restrict, const struct timespec *__restrict);
21
22// pthread_cond_clockwait
23static pthread_mutex_t c_mtx1 = PTHREAD_MUTEX_INITIALIZER;
24static pthread_cond_t c_cond1 = PTHREAD_COND_INITIALIZER;
25static pthread_mutex_t c_mtx2 = PTHREAD_MUTEX_INITIALIZER;
26static pthread_mutex_t c_mtx10 = PTHREAD_MUTEX_INITIALIZER;
27static pthread_cond_t c_cond2 = PTHREAD_COND_INITIALIZER;
28static pthread_mutex_t c_mtx3 = PTHREAD_MUTEX_INITIALIZER;
29static pthread_cond_t c_cond3 = PTHREAD_COND_INITIALIZER;
30static pthread_mutex_t c_mtx4 = PTHREAD_MUTEX_INITIALIZER;
31static pthread_cond_t c_cond4 = PTHREAD_COND_INITIALIZER;
32static pthread_mutex_t c_mtx5 = PTHREAD_MUTEX_INITIALIZER;
33static pthread_cond_t c_cond5 = PTHREAD_COND_INITIALIZER;
34static pthread_mutex_t c_mtx6 = PTHREAD_MUTEX_INITIALIZER;
35static pthread_cond_t c_cond6 = PTHREAD_COND_INITIALIZER;
36// pthread_cond_timedwait_monotonic_np
37static pthread_mutex_t m_mtx1 = PTHREAD_MUTEX_INITIALIZER;
38static pthread_cond_t m_cond1 = PTHREAD_COND_INITIALIZER;
39static pthread_mutex_t m_mtx2 = PTHREAD_MUTEX_INITIALIZER;
40static pthread_cond_t m_cond2 = PTHREAD_COND_INITIALIZER;
41static pthread_mutex_t m_mtx3 = PTHREAD_MUTEX_INITIALIZER;
42static pthread_cond_t m_cond3 = PTHREAD_COND_INITIALIZER;
43// pthread_cond_timeout_np
44static pthread_mutex_t u_mtx1 = PTHREAD_MUTEX_INITIALIZER;
45static pthread_cond_t u_cond1 = PTHREAD_COND_INITIALIZER;
46static pthread_mutex_t u_mtx2 = PTHREAD_MUTEX_INITIALIZER;
47static pthread_cond_t u_cond2 = PTHREAD_COND_INITIALIZER;
48
49/**
50 * @tc.number    : pthread_cond_timedwait_0010
51 * @tc.desc      : Test whether the pthread_cond_timedwait is normal
52 * @tc.level     : Level 0
53 */
54void pthread_cond_timedwait_0010(void)
55{
56    pthread_condattr_t a;
57    EXPECT_EQ(pthread_condattr_init(&a), 0);
58    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
59    EXPECT_EQ(pthread_cond_init(&cond, &a), 0);
60    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
61    struct timespec ts = {0};
62    EXPECT_EQ(pthread_mutex_lock(&mutex), 0);
63    EXPECT_EQ(clock_gettime(CLOCK_REALTIME, &ts), 0);
64
65    ts.tv_nsec += SLEEP_10_MS*MS_PER_S*MS_PER_S;
66    if (ts.tv_nsec >= MS_PER_S*MS_PER_S*MS_PER_S) {
67        ts.tv_nsec -= MS_PER_S*MS_PER_S*MS_PER_S;
68        ts.tv_sec += 1;
69    }
70    EXPECT_EQ(pthread_cond_timedwait(&cond, &mutex, &ts), ETIMEDOUT);
71    EXPECT_EQ(pthread_mutex_unlock(&mutex), 0);
72    EXPECT_EQ(pthread_cond_destroy(&cond), 0);
73    EXPECT_EQ(pthread_mutex_destroy(&mutex), 0);
74}
75
76/**
77 * @tc.number    : pthread_cond_timedwait_0020
78 * @tc.desc      : Test for pthread_cond_timedwait exceptions
79 * @tc.level     : Level 2
80 */
81void pthread_cond_timedwait_0020(void)
82{
83    pthread_condattr_t a;
84    EXPECT_EQ(pthread_condattr_init(&a), 0);
85    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
86    EXPECT_EQ(pthread_cond_init(&cond, &a), 0);
87    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
88    struct timespec ts = {0};
89    EXPECT_EQ(pthread_mutex_lock(&mutex), 0);
90    EXPECT_EQ(clock_gettime(CLOCK_REALTIME, &ts), 0);
91
92    ts.tv_nsec = NSEC_PER_SEC;
93    EXPECT_EQ(pthread_cond_timedwait(&cond, &mutex, &ts), EINVAL);
94    EXPECT_EQ(pthread_mutex_unlock(&mutex), 0);
95    EXPECT_EQ(pthread_cond_destroy(&cond), 0);
96    EXPECT_EQ(pthread_mutex_destroy(&mutex), 0);
97}
98
99/**
100 * @tc.number    : pthread_cond_timedwait_time64_0010
101 * @tc.desc      : Test whether the pthread_cond_timedwait is normal
102 * @tc.level     : Level 0
103 */
104void pthread_cond_timedwait_time64_0010(void)
105{
106    pthread_condattr_t a;
107    EXPECT_EQ(pthread_condattr_init(&a), 0);
108    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
109    EXPECT_EQ(pthread_cond_init(&cond, &a), 0);
110    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
111    struct timespec ts = {0};
112    EXPECT_EQ(pthread_mutex_lock(&mutex), 0);
113    EXPECT_EQ(clock_gettime(CLOCK_REALTIME, &ts), 0);
114
115    ts.tv_nsec += SLEEP_10_MS*MS_PER_S*MS_PER_S;
116    if (ts.tv_nsec >= MS_PER_S*MS_PER_S*MS_PER_S) {
117        ts.tv_nsec -= MS_PER_S*MS_PER_S*MS_PER_S;
118        ts.tv_sec += 1;
119    }
120    EXPECT_EQ(__pthread_cond_timedwait_time64(&cond, &mutex, &ts), ETIMEDOUT);
121    EXPECT_EQ(pthread_mutex_unlock(&mutex), 0);
122    EXPECT_EQ(pthread_cond_destroy(&cond), 0);
123    EXPECT_EQ(pthread_mutex_destroy(&mutex), 0);
124}
125
126/**
127 * @tc.number    : pthread_cond_timedwait_monotonic_np_0010
128 * @tc.desc      : Test whether the pthread_cond_timedwait_monotonic_np is normal
129 * @tc.level     : Level 0
130 */
131void pthread_cond_timedwait_monotonic_np_0010(void)
132{
133    pthread_cond_t cond;
134    pthread_mutex_t mutex;
135    struct timespec ts = {0};
136    EXPECT_EQ(pthread_cond_init(&cond, 0), 0);
137    EXPECT_EQ(pthread_mutex_init(&mutex, 0), 0);
138
139    EXPECT_EQ(clock_gettime(CLOCK_MONOTONIC, &ts), 0);
140    ts.tv_nsec += SLEEP_10_MS*MS_PER_S*MS_PER_S;
141    if (ts.tv_nsec >= MS_PER_S*MS_PER_S*MS_PER_S) {
142        ts.tv_nsec -= MS_PER_S*MS_PER_S*MS_PER_S;
143        ts.tv_sec += 1;
144    }
145    EXPECT_EQ(pthread_cond_timedwait_monotonic_np(&cond, &mutex, &ts), ETIMEDOUT);
146    EXPECT_EQ(pthread_mutex_unlock(&mutex), 0);
147    EXPECT_EQ(pthread_cond_destroy(&cond), 0);
148    EXPECT_EQ(pthread_mutex_destroy(&mutex), 0);
149}
150
151/**
152 * @tc.number    : pthread_cond_timedwait_monotonic_np_0020
153 * @tc.desc      : Test whether the pthread_cond_timedwait_monotonic_np is invalid
154 * @tc.level     : Level 2
155 */
156void pthread_cond_timedwait_monotonic_np_0020(void)
157{
158    pthread_cond_t *cond = (pthread_cond_t *)NULL;
159    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
160    struct timespec ts = {0};
161    EXPECT_EQ(pthread_cond_timedwait_monotonic_np(cond, &mutex, &ts), EINVAL);
162}
163
164/**
165 * @tc.number    : pthread_cond_timeout_np_0010
166 * @tc.desc      : Test whether the pthread_cond_timeout_np is normal
167 * @tc.level     : Level 0
168 */
169void pthread_cond_timeout_np_0010(void)
170{
171    unsigned int ms = SLEEP_100_MS;
172    pthread_condattr_t a;
173    EXPECT_EQ(pthread_condattr_init(&a), 0);
174    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
175    EXPECT_EQ(pthread_cond_init(&cond, &a), 0);
176    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
177    EXPECT_EQ(pthread_cond_timeout_np(&cond, &mutex, ms), ETIMEDOUT);
178    EXPECT_EQ(pthread_mutex_unlock(&mutex), 0);
179    EXPECT_EQ(pthread_cond_destroy(&cond), 0);
180    EXPECT_EQ(pthread_mutex_destroy(&mutex), 0);
181}
182
183/**
184 * @tc.number    : pthread_cond_clockwait_0010
185 * @tc.desc      : Test multiple cases of pthread_cond_clockwait
186 * @tc.level     : Level 2
187 */
188void pthread_cond_clockwait_0010(void)
189{
190    pthread_condattr_t a;
191    EXPECT_EQ(pthread_condattr_init(&a), 0);
192    pthread_cond_t cond = PTHREAD_COND_INITIALIZER;
193    EXPECT_EQ(pthread_cond_init(&cond, &a), 0);
194    pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
195    struct timespec ts = {0};
196
197    ts.tv_nsec += SLEEP_10_MS*MS_PER_S*MS_PER_S;
198    if (ts.tv_nsec >= MS_PER_S*MS_PER_S*MS_PER_S) {
199        ts.tv_nsec -= MS_PER_S*MS_PER_S*MS_PER_S;
200        ts.tv_sec += 1;
201    }
202    clockid_t clock_id = CLOCK_REALTIME;
203    EXPECT_EQ(pthread_cond_clockwait(&cond, &mutex, clock_id, &ts), ETIMEDOUT);
204    clock_id = CLOCK_MONOTONIC;
205    EXPECT_EQ(pthread_cond_clockwait(&cond, &mutex, clock_id, &ts), ETIMEDOUT);
206    clock_id = CLOCK_PROCESS_CPUTIME_ID;
207    EXPECT_EQ(pthread_cond_clockwait(&cond, &mutex, clock_id, &ts), EINVAL);
208    EXPECT_EQ(pthread_mutex_unlock(&mutex), 0);
209    EXPECT_EQ(pthread_cond_destroy(&cond), 0);
210    EXPECT_EQ(pthread_mutex_destroy(&mutex), 0);
211}
212
213/**
214 * @tc.number    : pthread_cond_timedwait_Time_0010
215 * @tc.desc      : Whether the interface is normal when the time is not set
216 * @tc.level     : Level 0
217 */
218void pthread_cond_timedwait_Time_0010(void)
219{
220    pthread_cond_t cond;
221    pthread_mutex_t mutex;
222    struct timespec ts;
223    EXPECT_EQ(pthread_cond_init(&cond, 0), 0);
224    EXPECT_EQ(pthread_mutex_init(&mutex, 0), 0);
225
226    EXPECT_EQ(pthread_cond_timedwait_monotonic_np(&cond, &mutex, &ts), ETIMEDOUT);
227
228    EXPECT_EQ(pthread_mutex_unlock(&mutex), 0);
229    EXPECT_EQ(pthread_cond_destroy(&cond), 0);
230    EXPECT_EQ(pthread_mutex_destroy(&mutex), 0);
231}
232
233static void *ClockWaitTimedwait1(void *arg)
234{
235    Msleep(SLEEP_50_MS);
236    EXPECT_EQ(pthread_mutex_lock(&c_mtx1), 0);
237    EXPECT_EQ(pthread_mutex_unlock(&c_mtx1), 0);
238    EXPECT_EQ(pthread_cond_signal(&c_cond1), 0);
239    return arg;
240}
241
242static void *ClockWaitTimedwait2(void *arg)
243{
244    const unsigned int nsecPerSec = NSEC_PER_SEC;
245    const unsigned int nsecPer100Ms = NSEC_PER_100MS;
246    struct timespec ts = {0};
247    EXPECT_EQ(pthread_mutex_lock(&c_mtx1), 0);
248
249    clock_gettime(CLOCK_REALTIME, &ts);
250    ts.tv_sec = ts.tv_sec + (ts.tv_nsec + nsecPer100Ms) / nsecPerSec;
251    ts.tv_nsec = (ts.tv_nsec + nsecPer100Ms) % nsecPerSec;
252
253    clockid_t clock_id = CLOCK_REALTIME;
254    EXPECT_EQ(pthread_cond_clockwait(&c_cond1, &c_mtx1, clock_id, &ts), 0);
255    EXPECT_EQ(pthread_mutex_unlock(&c_mtx1), 0);
256    return arg;
257}
258
259/**
260 * @tc.number    : clockwait_timedwait_0010
261 * @tc.desc      : Test the case of pthread_cond_clockwait timewait by CLOCK_REALTIME
262 * @tc.level     : Level 1
263 */
264void clockwait_timedwait_0010(void)
265{
266    pthread_t tid1;
267    pthread_t tid2;
268    EXPECT_EQ(pthread_create(&tid1, NULL, ClockWaitTimedwait1, NULL), 0);
269    EXPECT_EQ(pthread_create(&tid2, NULL, ClockWaitTimedwait2, NULL), 0);
270    Msleep(SLEEP_100_MS);
271    pthread_join(tid1, NULL);
272    pthread_join(tid2, NULL);
273    EXPECT_EQ(pthread_cond_destroy(&c_cond1), 0);
274    EXPECT_EQ(pthread_mutex_destroy(&c_mtx1), 0);
275}
276
277static void *ClockWaitTimeOut(void *arg)
278{
279    struct timespec ts = {0};
280    struct timespec tsNow = {0};
281    EXPECT_EQ(pthread_mutex_lock(&c_mtx2), 0);
282
283    clockid_t clock_id = CLOCK_REALTIME;
284    GetDelayedTimeByClockid(&ts, SLEEP_100_MS, clock_id);
285    EXPECT_EQ(pthread_cond_clockwait(&c_cond2, &c_mtx2, clock_id, &ts), ETIMEDOUT);
286    clock_gettime(CLOCK_REALTIME, &tsNow);
287
288    int timeDiff = GetTimeDiff(tsNow, ts);
289    EXPECT_GE(timeDiff, 0);
290    EXPECT_LE(timeDiff, SLEEP_20_MS);
291
292    EXPECT_EQ(pthread_mutex_unlock(&c_mtx2), 0);
293    return arg;
294}
295
296/**
297 * @tc.number    : clockwait_timedwait_0020
298 * @tc.desc      : Test the case of pthread_cond_clockwait timeout by CLOCK_REALTIME
299 * @tc.level     : Level 1
300 */
301void clockwait_timedwait_0020(void)
302{
303    pthread_t tid;
304    EXPECT_EQ(pthread_create(&tid, NULL, ClockWaitTimeOut, NULL), 0);
305    Msleep(SLEEP_200_MS);
306    pthread_join(tid, NULL);
307    EXPECT_EQ(pthread_cond_destroy(&c_cond2), 0);
308    EXPECT_EQ(pthread_mutex_destroy(&c_mtx2), 0);
309}
310
311static void *ClockWaitTimedwait3(void *arg)
312{
313    Msleep(SLEEP_50_MS);
314    EXPECT_EQ(pthread_mutex_lock(&c_mtx3), 0);
315    EXPECT_EQ(pthread_mutex_unlock(&c_mtx3), 0);
316    EXPECT_EQ(pthread_cond_signal(&c_cond3), 0);
317    return arg;
318}
319
320static void *ClockWaitTimedwait4(void *arg)
321{
322    const unsigned int nsecPerSec = NSEC_PER_SEC;
323    const unsigned int nsecPer100Ms = NSEC_PER_100MS;
324    struct timespec ts = {0};
325    EXPECT_EQ(pthread_mutex_lock(&c_mtx3), 0);
326
327    clock_gettime(CLOCK_MONOTONIC, &ts);
328    ts.tv_sec = ts.tv_sec + (ts.tv_nsec + nsecPer100Ms) / nsecPerSec;
329    ts.tv_nsec = (ts.tv_nsec + nsecPer100Ms) % nsecPerSec;
330
331    clockid_t clock_id = CLOCK_MONOTONIC;
332    EXPECT_EQ(pthread_cond_clockwait(&c_cond3, &c_mtx3, clock_id, &ts), 0);
333    EXPECT_EQ(pthread_mutex_unlock(&c_mtx3), 0);
334    return arg;
335}
336
337/**
338 * @tc.number    : clockwait_timedwait_0030
339 * @tc.desc      : Test the case of pthread_cond_clockwait timewait by CLOCK_MONOTONIC
340 * @tc.level     : Level 1
341 */
342void clockwait_timedwait_0030(void)
343{
344    pthread_t tid1;
345    pthread_t tid2;
346    EXPECT_EQ(pthread_create(&tid1, NULL, ClockWaitTimedwait3, NULL), 0);
347    EXPECT_EQ(pthread_create(&tid2, NULL, ClockWaitTimedwait4, NULL), 0);
348    Msleep(SLEEP_100_MS);
349    pthread_join(tid1, NULL);
350    pthread_join(tid2, NULL);
351    EXPECT_EQ(pthread_cond_destroy(&c_cond3), 0);
352    EXPECT_EQ(pthread_mutex_destroy(&c_mtx3), 0);
353}
354
355static void *ClockWaitTimeOut2(void *arg)
356{
357    struct timespec ts = {0};
358    struct timespec tsNow = {0};
359    EXPECT_EQ(pthread_mutex_lock(&c_mtx10), 0);
360
361    clockid_t clock_id = CLOCK_MONOTONIC;
362    GetDelayedTimeByClockid(&ts, SLEEP_100_MS, clock_id);
363    EXPECT_EQ(pthread_cond_clockwait(&c_cond2, &c_mtx10, clock_id, &ts), ETIMEDOUT);
364    clock_gettime(CLOCK_MONOTONIC, &tsNow);
365
366    int timeDiff = GetTimeDiff(tsNow, ts);
367    EXPECT_GE(timeDiff, 0);
368    EXPECT_LE(timeDiff, SLEEP_20_MS);
369
370    EXPECT_EQ(pthread_mutex_unlock(&c_mtx10), 0);
371    return arg;
372}
373
374/**
375 * @tc.number    : clockwait_timedwait_0040
376 * @tc.desc      : Test the case of pthread_cond_clockwait timeout by CLOCK_MONOTONIC
377 * @tc.level     : Level 1
378 */
379void clockwait_timedwait_0040(void)
380{
381    pthread_t tid;
382    EXPECT_EQ(pthread_create(&tid, NULL, ClockWaitTimeOut2, NULL), 0);
383    Msleep(SLEEP_200_MS);
384    pthread_join(tid, NULL);
385    EXPECT_EQ(pthread_cond_destroy(&c_cond2), 0);
386    EXPECT_EQ(pthread_mutex_destroy(&c_mtx10), 0);
387}
388
389static void *ClockWaitTimeMismatch(void *arg)
390{
391    const unsigned int nsecPerSec = NSEC_PER_SEC;
392    const unsigned int nsecPer100Ms = NSEC_PER_100MS;
393    struct timespec ts = {0};
394    EXPECT_EQ(pthread_mutex_lock(&c_mtx4), 0);
395
396    clock_gettime(CLOCK_MONOTONIC, &ts);
397    ts.tv_sec = ts.tv_sec + (ts.tv_nsec + nsecPer100Ms) / nsecPerSec;
398    ts.tv_nsec = (ts.tv_nsec + nsecPer100Ms) % nsecPerSec;
399
400    clockid_t clock_id = CLOCK_REALTIME;
401    EXPECT_EQ(pthread_cond_clockwait(&c_cond4, &c_mtx4, clock_id, &ts), ETIMEDOUT);
402
403    EXPECT_EQ(pthread_mutex_unlock(&c_mtx4), 0);
404    return arg;
405}
406
407static void *ClockWaitTimeMismatch1(void *arg)
408{
409    Msleep(SLEEP_50_MS);
410    EXPECT_EQ(pthread_mutex_lock(&c_mtx5), 0);
411    EXPECT_EQ(pthread_mutex_unlock(&c_mtx5), 0);
412    EXPECT_EQ(pthread_cond_signal(&c_cond5), 0);
413    return arg;
414}
415
416static void *ClockWaitTimeMismatch2(void *arg)
417{
418    const unsigned int nsecPerSec = NSEC_PER_SEC;
419    const unsigned int nsecPer100Ms = NSEC_PER_100MS;
420    struct timespec ts = {0};
421    EXPECT_EQ(pthread_mutex_lock(&c_mtx5), 0);
422
423    clock_gettime(CLOCK_REALTIME, &ts);
424    ts.tv_sec = ts.tv_sec + (ts.tv_nsec + nsecPer100Ms) / nsecPerSec;
425    ts.tv_nsec = (ts.tv_nsec + nsecPer100Ms) % nsecPerSec;
426
427    clockid_t clock_id = CLOCK_REALTIME;
428    EXPECT_EQ(pthread_cond_clockwait(&c_cond5, &c_mtx5, clock_id, &ts), 0);
429
430    EXPECT_EQ(pthread_mutex_unlock(&c_mtx5), 0);
431    return arg;
432}
433
434/**
435 * @tc.number    : clockwait_timedwait_0050
436 * @tc.desc      : Test the case of pthread_cond_clockwait time mismatch
437 * @tc.level     : Level 2
438 */
439void clockwait_timedwait_0050(void)
440{
441    pthread_t tid;
442    pthread_t tid1;
443    pthread_t tid2;
444    EXPECT_EQ(pthread_create(&tid1, NULL, ClockWaitTimeMismatch1, NULL), 0);
445    EXPECT_EQ(pthread_create(&tid2, NULL, ClockWaitTimeMismatch2, NULL), 0);
446    EXPECT_EQ(pthread_create(&tid, NULL, ClockWaitTimeMismatch, NULL), 0);
447    Msleep(SLEEP_200_MS);
448    pthread_join(tid1, NULL);
449    pthread_join(tid2, NULL);
450    pthread_join(tid, NULL);
451    EXPECT_EQ(pthread_cond_destroy(&c_cond4), 0);
452    EXPECT_EQ(pthread_mutex_destroy(&c_mtx4), 0);
453    EXPECT_EQ(pthread_cond_destroy(&c_cond5), 0);
454    EXPECT_EQ(pthread_mutex_destroy(&c_mtx5), 0);
455}
456
457static void *ClockWaitTimeMismatch3(void *arg)
458{
459    struct timespec ts = {0};
460    struct timespec tsNow = {0};
461    EXPECT_EQ(pthread_mutex_lock(&c_mtx6), 0);
462    Msleep(SLEEP_20_MS);
463    GetDelayedTimeByClockid(&ts, SLEEP_100_MS, CLOCK_REALTIME);
464    clock_gettime(CLOCK_REALTIME, &tsNow);
465    tsNow.tv_sec += 1;
466    EXPECT_EQ(clock_settime(CLOCK_REALTIME, &tsNow), 0);
467    EXPECT_EQ(pthread_cond_clockwait(&c_cond6, &c_mtx6, CLOCK_REALTIME, &ts), ETIMEDOUT);
468
469    clock_gettime(CLOCK_REALTIME, &tsNow);
470    tsNow.tv_sec -= 1;
471    clock_settime(CLOCK_REALTIME, &tsNow);
472    EXPECT_EQ(pthread_mutex_unlock(&c_mtx6), 0);
473
474    return arg;
475}
476
477/**
478 * @tc.number    : clockwait_timedwait_0060
479 * @tc.desc      : A case for testing the CLOCK_REALTIME feature of pthread_cond_clockwait.
480 * @tc.level     : Level 1
481 */
482void clockwait_timedwait_0060(void)
483{
484    pthread_t tid;
485    EXPECT_EQ(pthread_create(&tid, NULL, ClockWaitTimeMismatch3, NULL), 0);
486    Msleep(SLEEP_200_MS);
487    pthread_join(tid, NULL);
488    EXPECT_EQ(pthread_cond_destroy(&c_cond6), 0);
489    EXPECT_EQ(pthread_mutex_destroy(&c_mtx6), 0);
490}
491
492static void *ClockWaitTimeMismatch4(void *arg)
493{
494    Msleep(SLEEP_50_MS);
495    EXPECT_EQ(pthread_mutex_lock(&c_mtx6), 0);
496    EXPECT_EQ(pthread_mutex_unlock(&c_mtx6), 0);
497    EXPECT_EQ(pthread_cond_signal(&c_cond6), 0);
498    return arg;
499}
500
501static void *ClockWaitTimeMismatch5(void *arg)
502{
503    struct timespec ts = {0};
504    EXPECT_EQ(pthread_mutex_lock(&c_mtx6), 0);
505    Msleep(SLEEP_20_MS);
506    GetDelayedTimeByClockid(&ts, SLEEP_100_MS, CLOCK_MONOTONIC);
507    EXPECT_EQ(pthread_cond_clockwait(&c_cond6, &c_mtx6, CLOCK_MONOTONIC, &ts), 0);
508    EXPECT_EQ(pthread_mutex_unlock(&c_mtx6), 0);
509    return arg;
510}
511
512/**
513 * @tc.number    : clockwait_timedwait_0070
514 * @tc.desc      : A case for testing the CLOCK_MONOTONIC feature of pthread_cond_clockwait.
515 * @tc.level     : Level 1
516 */
517void clockwait_timedwait_0070(void)
518{
519    struct timespec tsNow = {0};
520    pthread_t tid1;
521    pthread_t tid2;
522
523    EXPECT_EQ(pthread_create(&tid1, NULL, ClockWaitTimeMismatch4, NULL), 0);
524    EXPECT_EQ(pthread_create(&tid2, NULL, ClockWaitTimeMismatch5, NULL), 0);
525    Msleep(SLEEP_100_MS);
526    clock_gettime(CLOCK_MONOTONIC, &tsNow);
527    tsNow.tv_sec += 1;
528    EXPECT_EQ(clock_settime(CLOCK_REALTIME, &tsNow), 0);
529    pthread_join(tid1, NULL);
530    pthread_join(tid2, NULL);
531    EXPECT_EQ(pthread_cond_destroy(&c_cond6), 0);
532    EXPECT_EQ(pthread_mutex_destroy(&c_mtx6), 0);
533}
534
535static void *PthreadCondMonotonicTimeWait1(void *arg)
536{
537    Msleep(SLEEP_50_MS);
538    EXPECT_EQ(pthread_mutex_lock(&m_mtx1), 0);
539    EXPECT_EQ(pthread_mutex_unlock(&m_mtx1), 0);
540    EXPECT_EQ(pthread_cond_signal(&m_cond1), 0);
541    return arg;
542}
543
544static void *PthreadCondMonotonicTimeWait2(void *arg)
545{
546    const unsigned int nsecPerSec = NSEC_PER_SEC;
547    const unsigned int nsecPer100Ms = NSEC_PER_100MS;
548    struct timespec ts = {0};
549    EXPECT_EQ(pthread_mutex_lock(&m_mtx1), 0);
550
551    clock_gettime(CLOCK_MONOTONIC, &ts);
552    ts.tv_sec = ts.tv_sec + (ts.tv_nsec + nsecPer100Ms) / nsecPerSec;
553    ts.tv_nsec = (ts.tv_nsec + nsecPer100Ms) % nsecPerSec;
554
555    EXPECT_EQ(pthread_cond_timedwait_monotonic_np(&m_cond1, &m_mtx1, &ts), 0);
556    EXPECT_EQ(pthread_mutex_unlock(&m_mtx1), 0);
557    return arg;
558}
559
560/**
561 * @tc.number    : monotonic_timewait_0010
562 * @tc.desc      : Test the case of pthread_cond_timedwait_monotonic_np timewait
563 * @tc.level     : Level 1
564 */
565void monotonic_timewait_0010(void)
566{
567    pthread_t tid1;
568    pthread_t tid2;
569
570    EXPECT_EQ(pthread_create(&tid1, NULL, PthreadCondMonotonicTimeWait1, NULL), 0);
571    EXPECT_EQ(pthread_create(&tid2, NULL, PthreadCondMonotonicTimeWait2, NULL), 0);
572
573    Msleep(SLEEP_100_MS);
574    pthread_join(tid1, NULL);
575    pthread_join(tid2, NULL);
576    EXPECT_EQ(pthread_cond_destroy(&m_cond1), 0);
577    EXPECT_EQ(pthread_mutex_destroy(&m_mtx1), 0);
578}
579
580static void *PthreadCondMonotonicTimeOut(void *arg)
581{
582    struct timespec ts = {0};
583    struct timespec tsNow = {0};
584    EXPECT_EQ(pthread_mutex_lock(&m_mtx2), 0);
585
586    GetDelayedTimeByClockid(&ts, SLEEP_100_MS, CLOCK_MONOTONIC);
587    EXPECT_EQ(pthread_cond_timedwait_monotonic_np(&m_cond2, &m_mtx2, &ts), ETIMEDOUT);
588    clock_gettime(CLOCK_MONOTONIC, &tsNow);
589
590    int timeDiff = GetTimeDiff(tsNow, ts);
591    EXPECT_GE(timeDiff, 0);
592    EXPECT_LE(timeDiff, SLEEP_20_MS);
593
594    EXPECT_EQ(pthread_mutex_unlock(&m_mtx2), 0);
595    return arg;
596}
597
598/**
599 * @tc.number    : monotonic_timewait_0020
600 * @tc.desc      : Test the case of pthread_cond_timedwait_monotonic_np timeout
601 * @tc.level     : Level 1
602 */
603void monotonic_timewait_0020(void)
604{
605    pthread_t tid;
606    EXPECT_EQ(pthread_create(&tid, NULL, PthreadCondMonotonicTimeOut, NULL), 0);
607    Msleep(SLEEP_200_MS);
608    pthread_join(tid, NULL);
609    EXPECT_EQ(pthread_cond_destroy(&m_cond2), 0);
610    EXPECT_EQ(pthread_mutex_destroy(&m_mtx2), 0);
611}
612
613static void *PthreadCondMonotonicTimeEinval(void *arg)
614{
615    const long einvalNsec = NSEC_PER_SEC;
616    struct timespec ts = {0};
617    EXPECT_EQ(pthread_mutex_lock(&m_mtx3), 0);
618
619    ts.tv_sec = 1;
620    ts.tv_nsec = einvalNsec;
621    EXPECT_EQ(pthread_cond_timedwait_monotonic_np(&m_cond3, &m_mtx3, &ts), EINVAL);
622
623    EXPECT_EQ(pthread_mutex_unlock(&m_mtx3), 0);
624    return arg;
625}
626
627/**
628 * @tc.number    : monotonic_timewait_0030
629 * @tc.desc      : Test the case of pthread_cond_timedwait_monotonic_np EINVAL
630 * @tc.level     : Level 2
631 */
632void monotonic_timewait_0030(void)
633{
634    pthread_t tid;
635
636    EXPECT_EQ(pthread_create(&tid, NULL, PthreadCondMonotonicTimeEinval, NULL), 0);
637
638    Msleep(SLEEP_200_MS);
639    pthread_join(tid, NULL);
640    EXPECT_EQ(pthread_cond_destroy(&m_cond3), 0);
641    EXPECT_EQ(pthread_mutex_destroy(&m_mtx3), 0);
642}
643
644static void *PthreadCondUnsignedTimeWait1(void *arg)
645{
646    Msleep(SLEEP_50_MS);
647    EXPECT_EQ(pthread_mutex_lock(&u_mtx1), 0);
648    EXPECT_EQ(pthread_mutex_unlock(&u_mtx1), 0);
649    EXPECT_EQ(pthread_cond_signal(&u_cond1), 0);
650    return arg;
651}
652
653static void *PthreadCondUnsignedTimeWait2(void *arg)
654{
655    unsigned int ms = SLEEP_100_MS;
656    struct timespec ts = {0};
657
658    GetDelayedTimeByClockid(&ts, ms, CLOCK_MONOTONIC);
659    EXPECT_EQ(pthread_mutex_lock(&u_mtx1), 0);
660    EXPECT_EQ(pthread_cond_timeout_np(&u_cond1, &u_mtx1, ms), 0);
661    EXPECT_EQ(pthread_mutex_unlock(&u_mtx1), 0);
662    return arg;
663}
664
665/**
666 * @tc.number    : timeoutnp_timewait_0010
667 * @tc.desc      : Test the case of pthread_cond_timeout_np timewait
668 * @tc.level     : Level 1
669 */
670void timeoutnp_timewait_0010(void)
671{
672    pthread_t tid1;
673    pthread_t tid2;
674
675    EXPECT_EQ(pthread_create(&tid1, NULL, PthreadCondUnsignedTimeWait1, NULL), 0);
676    EXPECT_EQ(pthread_create(&tid2, NULL, PthreadCondUnsignedTimeWait2, NULL), 0);
677
678    Msleep(SLEEP_100_MS);
679    pthread_join(tid1, NULL);
680    pthread_join(tid2, NULL);
681    EXPECT_EQ(pthread_cond_destroy(&u_cond1), 0);
682    EXPECT_EQ(pthread_mutex_destroy(&u_mtx1), 0);
683}
684
685static void *PthreadCondUnsignedTimeOut(void *arg)
686{
687    unsigned int ms = SLEEP_100_MS;
688    struct timespec ts = {0};
689    struct timespec tsNow = {0};
690    EXPECT_EQ(pthread_mutex_lock(&u_mtx2), 0);
691
692    GetDelayedTimeByClockid(&ts, SLEEP_100_MS, CLOCK_MONOTONIC);
693    EXPECT_EQ(pthread_cond_timeout_np(&u_cond2, &u_mtx2, ms), ETIMEDOUT);
694    clock_gettime(CLOCK_MONOTONIC, &tsNow);
695
696    int timeDiff = GetTimeDiff(tsNow, ts);
697    EXPECT_GE(timeDiff, 0);
698    EXPECT_LE(timeDiff, SLEEP_20_MS);
699
700    EXPECT_EQ(pthread_mutex_unlock(&u_mtx2), 0);
701    return arg;
702}
703
704/**
705 * @tc.number    : timeoutnp_timewait_0020
706 * @tc.desc      : Test the case of pthread_cond_timeout_np timeout
707 * @tc.level     : Level 1
708 */
709void timeoutnp_timewait_0020(void)
710{
711    pthread_t tid;
712    EXPECT_EQ(pthread_create(&tid, NULL, PthreadCondUnsignedTimeOut, NULL), 0);
713    Msleep(SLEEP_200_MS);
714    pthread_join(tid, NULL);
715    EXPECT_EQ(pthread_cond_destroy(&u_cond2), 0);
716    EXPECT_EQ(pthread_mutex_destroy(&u_mtx2), 0);
717}
718
719TEST_FUN G_Fun_Array[] = {
720    pthread_cond_timedwait_0010,
721    pthread_cond_timedwait_0020,
722    pthread_cond_timedwait_time64_0010,
723    pthread_cond_timedwait_monotonic_np_0010,
724    pthread_cond_timedwait_monotonic_np_0020,
725    pthread_cond_timeout_np_0010,
726    pthread_cond_clockwait_0010,
727    pthread_cond_timedwait_Time_0010,
728    clockwait_timedwait_0010,
729    clockwait_timedwait_0020,
730    clockwait_timedwait_0030,
731    clockwait_timedwait_0040,
732    clockwait_timedwait_0050,
733    monotonic_timewait_0010,
734    monotonic_timewait_0020,
735    monotonic_timewait_0030,
736    timeoutnp_timewait_0010,
737    timeoutnp_timewait_0020,
738    clockwait_timedwait_0060,
739    clockwait_timedwait_0070,
740};
741
742int main(void)
743{
744    int num = sizeof(G_Fun_Array) / sizeof(TEST_FUN);
745    for (int pos = 0; pos < num; ++pos)     {
746        G_Fun_Array[pos]();
747    }
748    return t_status;
749}
750