1 // Copyright 2020 The Pigweed Authors
2 //
3 // Licensed under the Apache License, Version 2.0 (the "License"); you may not
4 // use this file except in compliance with the License. You may obtain a copy of
5 // the License at
6 //
7 // https://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, WITHOUT
11 // WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
12 // License for the specific language governing permissions and limitations under
13 // the License.
14
15 #include <chrono>
16
17 #include "pw_chrono/system_clock.h"
18 #include "pw_sync/timed_mutex.h"
19 #include "pw_sync_private/borrow_lockable_tests.h"
20 #include "pw_unit_test/framework.h"
21
22 using pw::chrono::SystemClock;
23 using namespace std::chrono_literals;
24
25 namespace pw::sync {
26 namespace {
27
28 extern "C" {
29
30 // Functions defined in mutex_facade_test_c.c which call the API from C.
31 void pw_sync_TimedMutex_CallLock(pw_sync_TimedMutex* mutex);
32 bool pw_sync_TimedMutex_CallTryLock(pw_sync_TimedMutex* mutex);
33 bool pw_sync_TimedMutex_CallTryLockFor(pw_sync_TimedMutex* mutex,
34 pw_chrono_SystemClock_Duration timeout);
35 bool pw_sync_TimedMutex_CallTryLockUntil(
36 pw_sync_TimedMutex* mutex, pw_chrono_SystemClock_TimePoint deadline);
37 void pw_sync_TimedMutex_CallUnlock(pw_sync_TimedMutex* mutex);
38
39 } // extern "C"
40
41 // We can't control the SystemClock's period configuration, so just in case
42 // duration cannot be accurately expressed in integer ticks, round the
43 // duration up.
44 constexpr SystemClock::duration kRoundedArbitraryDuration =
45 SystemClock::for_at_least(42ms);
46 constexpr pw_chrono_SystemClock_Duration kRoundedArbitraryDurationInC =
47 PW_SYSTEM_CLOCK_MS(42);
48
49 // TODO: b/235284163 - Add real concurrency tests once we have pw::thread.
50
TEST(TimedMutex,LockUnlock)51 TEST(TimedMutex, LockUnlock) {
52 TimedMutex mutex;
53 mutex.lock();
54 mutex.unlock();
55 // TODO: b/235284163 - Ensure it fails to lock when already held by someone
56 // else.
57 // EXPECT_FALSE(mutex.try_lock());
58 }
59
60 TimedMutex static_mutex;
TEST(TimedMutex,LockUnlockStatic)61 TEST(TimedMutex, LockUnlockStatic) {
62 static_mutex.lock();
63 static_mutex.unlock();
64 // TODO: b/235284163 - Ensure it fails to lock when already held by someone
65 // else.
66 // EXPECT_FALSE(static_mutex.try_lock());
67 }
68
TEST(TimedMutex,TryLockUnlock)69 TEST(TimedMutex, TryLockUnlock) {
70 TimedMutex mutex;
71 const bool locked = mutex.try_lock();
72 EXPECT_TRUE(locked);
73 if (locked) {
74 // EXPECT_FALSE(mutex.try_lock());
75 mutex.unlock();
76 }
77 // TODO: b/235284163 - Ensure it fails to lock when already held by someone
78 // else.
79 }
80
TEST(TimedMutex,TryLockUnlockFor)81 TEST(TimedMutex, TryLockUnlockFor) {
82 TimedMutex mutex;
83
84 SystemClock::time_point before = SystemClock::now();
85 const bool locked = mutex.try_lock_for(kRoundedArbitraryDuration);
86 EXPECT_TRUE(locked);
87 if (locked) {
88 SystemClock::duration time_elapsed = SystemClock::now() - before;
89 EXPECT_LT(time_elapsed, kRoundedArbitraryDuration);
90 mutex.unlock();
91 }
92 // TODO: b/235284163 - Ensure it blocks and fails to lock when already held by
93 // someone else.
94 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
95 // held by someone else and a zero length duration is used.
96 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
97 // held by someone else and a negative duration is used.
98 }
99
TEST(TimedMutex,TryLockUnlockUntil)100 TEST(TimedMutex, TryLockUnlockUntil) {
101 TimedMutex mutex;
102
103 const SystemClock::time_point deadline =
104 SystemClock::now() + kRoundedArbitraryDuration;
105 const bool locked = mutex.try_lock_until(deadline);
106 EXPECT_TRUE(locked);
107 if (locked) {
108 EXPECT_LT(SystemClock::now(), deadline);
109 mutex.unlock();
110 }
111 // TODO: b/235284163 - Ensure it blocks and fails to lock when already held by
112 // someone else.
113 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
114 // held by someone else and now is used.
115 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
116 // held by someone else and a timestamp in the past is used.
117 }
118
119 PW_SYNC_ADD_BORROWABLE_TIMED_LOCK_NAMED_TESTS(BorrowableTimedMutex,
120 TimedMutex,
121 chrono::SystemClock);
122
TEST(VirtualTimedMutex,LockUnlock)123 TEST(VirtualTimedMutex, LockUnlock) {
124 VirtualTimedMutex mutex;
125 mutex.lock();
126 // TODO: b/235284163 - Ensure it fails to lock when already held by someone
127 // else.
128 // EXPECT_FALSE(mutex.try_lock());
129 mutex.unlock();
130 }
131
132 VirtualTimedMutex static_virtual_mutex;
TEST(VirtualTimedMutex,LockUnlockStatic)133 TEST(VirtualTimedMutex, LockUnlockStatic) {
134 static_virtual_mutex.lock();
135 // TODO: b/235284163 - Ensure it fails to lock when already held by someone
136 // else.
137 // EXPECT_FALSE(static_virtual_mutex.try_lock());
138 static_virtual_mutex.unlock();
139 }
140
TEST(VirtualMutex,LockUnlockExternal)141 TEST(VirtualMutex, LockUnlockExternal) {
142 VirtualTimedMutex virtual_timed_mutex;
143 auto& mutex = virtual_timed_mutex.timed_mutex();
144 mutex.lock();
145 // TODO: b/235284163 - Ensure it fails to lock when already held.
146 // EXPECT_FALSE(mutex.try_lock());
147 mutex.unlock();
148 }
149
150 PW_SYNC_ADD_BORROWABLE_TIMED_LOCK_NAMED_TESTS(BorrowableVirtualTimedMutex,
151 VirtualTimedMutex,
152 chrono::SystemClock);
153
TEST(TimedMutex,LockUnlockInC)154 TEST(TimedMutex, LockUnlockInC) {
155 TimedMutex mutex;
156 pw_sync_TimedMutex_CallLock(&mutex);
157 pw_sync_TimedMutex_CallUnlock(&mutex);
158 }
159
TEST(TimedMutex,TryLockUnlockInC)160 TEST(TimedMutex, TryLockUnlockInC) {
161 TimedMutex mutex;
162 ASSERT_TRUE(pw_sync_TimedMutex_CallTryLock(&mutex));
163 // TODO: b/235284163 - Ensure it fails to lock when already held by someone
164 // else.
165 // EXPECT_FALSE(pw_sync_TimedMutex_CallTryLock(&mutex));
166 pw_sync_TimedMutex_CallUnlock(&mutex);
167 }
168
TEST(TimedMutex,TryLockUnlockForInC)169 TEST(TimedMutex, TryLockUnlockForInC) {
170 TimedMutex mutex;
171
172 pw_chrono_SystemClock_TimePoint before = pw_chrono_SystemClock_Now();
173 ASSERT_TRUE(
174 pw_sync_TimedMutex_CallTryLockFor(&mutex, kRoundedArbitraryDurationInC));
175 pw_chrono_SystemClock_Duration time_elapsed =
176 pw_chrono_SystemClock_TimeElapsed(before, pw_chrono_SystemClock_Now());
177 EXPECT_LT(time_elapsed.ticks, kRoundedArbitraryDurationInC.ticks);
178 pw_sync_TimedMutex_CallUnlock(&mutex);
179 // TODO: b/235284163 - Ensure it blocks and fails to lock when already held by
180 // someone else.
181 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
182 // held by someone else and a zero length duration is used.
183 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
184 // held by someone else and a negative duration is used.
185 }
186
TEST(TimedMutex,TryLockUnlockUntilInC)187 TEST(TimedMutex, TryLockUnlockUntilInC) {
188 TimedMutex mutex;
189 pw_chrono_SystemClock_TimePoint deadline;
190 deadline.duration_since_epoch.ticks =
191 pw_chrono_SystemClock_Now().duration_since_epoch.ticks +
192 kRoundedArbitraryDurationInC.ticks;
193 ASSERT_TRUE(pw_sync_TimedMutex_CallTryLockUntil(&mutex, deadline));
194 EXPECT_LT(pw_chrono_SystemClock_Now().duration_since_epoch.ticks,
195 deadline.duration_since_epoch.ticks);
196 pw_sync_TimedMutex_CallUnlock(&mutex);
197 // TODO: b/235284163 - Ensure it blocks and fails to lock when already held by
198 // someone else.
199 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
200 // held by someone else and now is used.
201 // TODO: b/235284163 - Ensure it does not block and fails to lock when already
202 // held by someone else and a timestamp in the past is used.
203 }
204
205 } // namespace
206 } // namespace pw::sync
207