LLVM OpenMP 22.0.0git
asserter-seq-test.cpp
Go to the documentation of this file.
1#include "OmptAliases.h"
2#include "OmptAsserter.h"
3#include <omp-tools.h>
4#include <sstream>
5
6#include "gtest/gtest.h"
7
8using namespace omptest;
9using OAE = omptest::OmptAssertEvent;
10using OS = omptest::ObserveState;
11
12/// SequencedAsserter test-fixture class to avoid code duplication among tests.
13class OmptSequencedAsserterTest : public testing::Test {
14protected:
15 OmptSequencedAsserterTest() {
16 // Construct default sequenced asserter
17 SeqAsserter = std::make_unique<omptest::OmptSequencedAsserter>();
18
19 // Silence all potential log prints
20 SeqAsserter->getLog()->setLoggingLevel(logging::Level::Critical);
21 }
22
23 std::unique_ptr<omptest::OmptSequencedAsserter> SeqAsserter;
24};
25
26TEST_F(OmptSequencedAsserterTest, DefaultState) {
27 // Assertion should neither start as 'deactivated' nor 'suspended'
28 ASSERT_EQ(SeqAsserter->isActive(), true);
29 ASSERT_EQ(SeqAsserter->AssertionSuspended, false);
30
31 // Assertion should begin with event ID zero
32 ASSERT_EQ(SeqAsserter->NextEvent, 0);
33
34 // Assertion should begin without previous notifications or assertions
35 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
36 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
37
38 // There should be no expected events
39 ASSERT_EQ(SeqAsserter->Events.empty(), true);
40 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 0);
41
42 // Default mode should be Strict
43 ASSERT_NE(SeqAsserter->getOperationMode(), AssertMode::Relaxed);
44 ASSERT_EQ(SeqAsserter->getOperationMode(), AssertMode::Strict);
45
46 // Default state should be passing
47 ASSERT_NE(SeqAsserter->getState(), AssertState::Fail);
48 ASSERT_EQ(SeqAsserter->getState(), AssertState::Pass);
49 ASSERT_NE(SeqAsserter->checkState(), AssertState::Fail);
50 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
51}
52
53TEST_F(OmptSequencedAsserterTest, IgnoreNotificationsWhenEmpty) {
54 // ParallelBegin events are suppressed by default
55 auto SuppressedEvent = OAE::ParallelBegin(
56 /*Name=*/"ParBegin", /*Group=*/"", /*Expected=*/OS::Always,
57 /*NumThreads=*/3);
58
59 // DeviceFinalize events are not ignored by default
60 auto IgnoredEvent = OAE::DeviceFinalize(
61 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
62 /*DeviceNum=*/7);
63
64 // Situation: There is nothing to assert.
65 // Result: All notifications are ignored.
66 // Hence, check that the perceived count of notifications remains unchanged
67 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
68
69 SeqAsserter->notify(std::move(SuppressedEvent));
70
71 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
72 SeqAsserter->notify(std::move(IgnoredEvent));
73 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
74 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
75 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
76}
77
78TEST_F(OmptSequencedAsserterTest, IgnoreNotificationsWhileDeactivated) {
79 auto ExpectedEvent = OAE::DeviceUnload(
80 /*Name=*/"DevUnload", /*Group=*/"", /*Expected=*/OS::Always);
81 SeqAsserter->insert(std::move(ExpectedEvent));
82 ASSERT_EQ(SeqAsserter->Events.empty(), false);
83
84 // Deactivate asserter, effectively ignoring notifications
85 SeqAsserter->setActive(false);
86 ASSERT_EQ(SeqAsserter->isActive(), false);
87 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
88
89 // DeviceFinalize events are not ignored by default
90 auto IgnoredEvent = OAE::DeviceFinalize(
91 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
92 /*DeviceNum=*/7);
93 SeqAsserter->notify(std::move(IgnoredEvent));
94
95 // Assertion was deactivated: No change
96 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
97 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
98
99 SeqAsserter->setActive(true);
100 ASSERT_EQ(SeqAsserter->isActive(), true);
101
102 auto ObservedEvent = OAE::DeviceUnload(
103 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always);
104 SeqAsserter->notify(std::move(ObservedEvent));
105
106 // Assertion was activated, one notification expected
107 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
108 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 1);
109 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
110}
111
112TEST_F(OmptSequencedAsserterTest, AddEvent) {
113 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 0);
114 auto ExpectedEvent = OAE::DeviceFinalize(
115 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
116 /*DeviceNum=*/7);
117 SeqAsserter->insert(std::move(ExpectedEvent));
118 // Sanity check: Notifications should not be triggered
119 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
120 // Adding an expected event must change the event count but not the state
121 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 1);
122 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
123 ASSERT_EQ(SeqAsserter->getState(), AssertState::Pass);
124}
125
126TEST_F(OmptSequencedAsserterTest, AddEventIgnoreSuppressed) {
127 auto ExpectedEvent = OAE::DeviceFinalize(
128 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
129 /*DeviceNum=*/7);
130 SeqAsserter->insert(std::move(ExpectedEvent));
131 // ParallelBegin events are suppressed by default
132 auto SuppressedEvent = OAE::ParallelBegin(
133 /*Name=*/"ParBegin", /*Group=*/"", /*Expected=*/OS::Always,
134 /*NumThreads=*/3);
135 // Situation: There is one expected event and ParallelBegins are suppressed.
136 // Notification count remains unchanged for suppressed events
137 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
138 SeqAsserter->notify(std::move(SuppressedEvent));
139 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
140 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
141 ASSERT_EQ(SeqAsserter->getState(), AssertState::Pass);
142}
143
144TEST_F(OmptSequencedAsserterTest, AddEventObservePass) {
145 auto ExpectedEvent = OAE::DeviceFinalize(
146 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
147 /*DeviceNum=*/7);
148 SeqAsserter->insert(std::move(ExpectedEvent));
149 // DeviceFinalize events are not ignored by default
150 auto ObservedEvent = OAE::DeviceFinalize(
151 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
152 /*DeviceNum=*/7);
153 SeqAsserter->notify(std::move(ObservedEvent));
154 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
155 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 1);
156 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
157}
158
159TEST_F(OmptSequencedAsserterTest, AddEventObserveFail) {
160 auto ExpectedEvent = OAE::DeviceFinalize(
161 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
162 /*DeviceNum=*/7);
163 SeqAsserter->insert(std::move(ExpectedEvent));
164 // DeviceFinalize events are not ignored by default
165 // Provide wrong DeviceNum
166 auto ObservedEvent = OAE::DeviceFinalize(
167 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
168 /*DeviceNum=*/23);
169
170 SeqAsserter->notify(std::move(ObservedEvent));
171 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
172 // Observed and expected event do not match: Fail
173 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
174 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Fail);
175}
176
177TEST_F(OmptSequencedAsserterTest, AddEventObserveDifferentType) {
178 auto ExpectedEvent = OAE::DeviceUnload(
179 /*Name=*/"DevUnload", /*Group=*/"", /*Expected=*/OS::Always);
180 SeqAsserter->insert(std::move(ExpectedEvent));
181 // DeviceFinalize events are not ignored by default
182 auto ObservedEvent = OAE::DeviceFinalize(
183 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
184 /*DeviceNum=*/7);
185
186 SeqAsserter->notify(std::move(ObservedEvent));
187 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
188 // Observed and expected event do not match: Fail
189 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
190 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Fail);
191}
192
193TEST_F(OmptSequencedAsserterTest, CheckTargetGroupNoEffect) {
194 // Situation: Groups are designed to be used as an indicator -WITHIN- target
195 // regions. Hence, comparing two target regions w.r.t. their groups has no
196 // effect on pass or fail.
197
198 auto ExpectedEvent = OAE::Target(
199 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
200 /*Kind=*/TARGET, /*Endpoint=*/BEGIN,
201 /*DeviceNum=*/7, /*TaskData=*/nullptr, /*TargetId=*/23,
202 /*CodeptrRA=*/nullptr);
203 SeqAsserter->insert(std::move(ExpectedEvent));
204 ASSERT_EQ(SeqAsserter->Events.empty(), false);
205
206 // Deactivate asserter, effectively ignoring notifications
207 SeqAsserter->setActive(false);
208 ASSERT_EQ(SeqAsserter->isActive(), false);
209 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
210
211 // Target events are not ignored by default
212 auto ObservedEvent = OAE::Target(
213 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
214 /*Kind=*/TARGET, /*Endpoint=*/BEGIN, /*DeviceNum=*/7,
215 /*TaskData=*/nullptr, /*TargetId=*/23, /*CodeptrRA=*/nullptr);
216 SeqAsserter->notify(std::move(ObservedEvent));
217
218 // Assertion was deactivated: No change
219 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
220 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
221 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 1);
222
223 // Re-activate asserter
224 SeqAsserter->setActive(true);
225 ASSERT_EQ(SeqAsserter->isActive(), true);
226 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
227
228 // Actually observe a target event from "AnotherGroup"
229 auto AnotherObservedEvent = OAE::Target(
230 /*Name=*/"Target", /*Group=*/"AnotherGroup", /*Expected=*/OS::Always,
231 /*Kind=*/TARGET, /*Endpoint=*/BEGIN, /*DeviceNum=*/7,
232 /*TaskData=*/nullptr, /*TargetId=*/23, /*CodeptrRA=*/nullptr);
233 SeqAsserter->notify(std::move(AnotherObservedEvent));
234
235 // Observed all expected events; groups of target regions do not affect pass
236 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
237 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 1);
238 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 0);
239
240 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
241}
242
243TEST_F(OmptSequencedAsserterTest, CheckSyncPoint) {
244 auto ExpectedEvent = OAE::Target(
245 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
246 /*Kind=*/TARGET, /*Endpoint=*/BEGIN,
247 /*DeviceNum=*/7, /*TaskData=*/nullptr, /*TargetId=*/23,
248 /*CodeptrRA=*/nullptr);
249 SeqAsserter->insert(std::move(ExpectedEvent));
250 ASSERT_EQ(SeqAsserter->Events.empty(), false);
251 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 1);
252
253 // Target events are not ignored by default
254 auto ObservedEvent = OAE::Target(
255 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
256 /*Kind=*/TARGET, /*Endpoint=*/BEGIN, /*DeviceNum=*/7,
257 /*TaskData=*/nullptr, /*TargetId=*/23, /*CodeptrRA=*/nullptr);
258 SeqAsserter->notify(std::move(ObservedEvent));
259 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
260
261 SeqAsserter->notify(OAE::AssertionSyncPoint(
262 /*Name=*/"", /*Group=*/"", /*Expected=*/OS::Always,
263 /*SyncPointName=*/"SyncPoint 1"));
264 ASSERT_EQ(SeqAsserter->getNotificationCount(), 2);
265 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 1);
266
267 // All events processed: SyncPoint "passes"
268 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
269
270 auto AnotherExpectedEvent = OAE::Target(
271 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
272 /*Kind=*/TARGET, /*Endpoint=*/BEGIN,
273 /*DeviceNum=*/7, /*TaskData=*/nullptr, /*TargetId=*/23,
274 /*CodeptrRA=*/nullptr);
275
276 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 0);
277 SeqAsserter->insert(std::move(AnotherExpectedEvent));
278 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 1);
279
280 // Remaining events present: SyncPoint "fails"
281 SeqAsserter->notify(OAE::AssertionSyncPoint(
282 /*Name=*/"", /*Group=*/"", /*Expected=*/OS::Always,
283 /*SyncPointName=*/"SyncPoint 2"));
284 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Fail);
285}
286
287TEST_F(OmptSequencedAsserterTest, CheckExcessNotify) {
288 auto ExpectedEvent = OAE::Target(
289 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
290 /*Kind=*/TARGET, /*Endpoint=*/BEGIN,
291 /*DeviceNum=*/7, /*TaskData=*/nullptr, /*TargetId=*/23,
292 /*CodeptrRA=*/nullptr);
293 SeqAsserter->insert(std::move(ExpectedEvent));
294 ASSERT_EQ(SeqAsserter->Events.empty(), false);
295 ASSERT_EQ(SeqAsserter->getRemainingEventCount(), 1);
296
297 // Target events are not ignored by default
298 auto ObservedEvent = OAE::Target(
299 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
300 /*Kind=*/TARGET, /*Endpoint=*/BEGIN, /*DeviceNum=*/7,
301 /*TaskData=*/nullptr, /*TargetId=*/23, /*CodeptrRA=*/nullptr);
302 SeqAsserter->notify(std::move(ObservedEvent));
303 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
304
305 // All events processed: pass
306 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
307
308 // Target events are not ignored by default
309 auto AnotherObservedEvent = OAE::Target(
310 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
311 /*Kind=*/TARGET, /*Endpoint=*/BEGIN, /*DeviceNum=*/7,
312 /*TaskData=*/nullptr, /*TargetId=*/23, /*CodeptrRA=*/nullptr);
313
314 // No more events expected: notify "fails"
315 SeqAsserter->notify(std::move(AnotherObservedEvent));
316 ASSERT_EQ(SeqAsserter->getNotificationCount(), 2);
317 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Fail);
318}
319
320TEST_F(OmptSequencedAsserterTest, CheckSuspend) {
321 SeqAsserter->insert(OAE::AssertionSuspend(
322 /*Name=*/"", /*Group=*/"", /*Expected=*/OS::Never));
323 ASSERT_EQ(SeqAsserter->Events.empty(), false);
324
325 // Being notified while the next expected event is a "suspend" should change
326 // the asserter's state
327 ASSERT_EQ(SeqAsserter->getNotificationCount(), 0);
328 ASSERT_EQ(SeqAsserter->AssertionSuspended, false);
329 SeqAsserter->notify(OAE::DeviceFinalize(
330 /*Name=*/"DevFini", /*Group=*/"", /*Expected=*/OS::Always,
331 /*DeviceNum=*/7));
332 ASSERT_EQ(SeqAsserter->AssertionSuspended, true);
333 ASSERT_EQ(SeqAsserter->getNotificationCount(), 1);
334
335 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 0);
336 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
337
338 auto ExpectedEvent = OAE::Target(
339 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
340 /*Kind=*/TARGET, /*Endpoint=*/BEGIN,
341 /*DeviceNum=*/7, /*TaskData=*/nullptr, /*TargetId=*/23,
342 /*CodeptrRA=*/nullptr);
343 SeqAsserter->insert(std::move(ExpectedEvent));
344
345 // Being notified with an observed event, which matches the next expected
346 // event, resumes assertion (suspended = false)
347 ASSERT_EQ(SeqAsserter->AssertionSuspended, true);
348 SeqAsserter->notify(OAE::Target(
349 /*Name=*/"Target", /*Group=*/"MyTargetGroup", /*Expected=*/OS::Always,
350 /*Kind=*/TARGET, /*Endpoint=*/BEGIN,
351 /*DeviceNum=*/7, /*TaskData=*/nullptr, /*TargetId=*/23,
352 /*CodeptrRA=*/nullptr));
353 ASSERT_EQ(SeqAsserter->AssertionSuspended, false);
354
355 ASSERT_EQ(SeqAsserter->getNotificationCount(), 2);
356 ASSERT_EQ(SeqAsserter->getSuccessfulAssertionCount(), 1);
357 ASSERT_EQ(SeqAsserter->checkState(), AssertState::Pass);
358}
OmptAliases.h
Defines shorthand aliases for OMPT enum values, providing improved ease-of-use and readability.
BEGIN
constexpr ompt_scope_endpoint_t BEGIN
Aliases for enum: ompt_scope_endpoint_t.
Definition: OmptAliases.h:21
TARGET
constexpr ompt_target_t TARGET
Aliases for enum: ompt_target_t.
Definition: OmptAliases.h:26
OmptAsserter.h
Contains all asserter-related class declarations and important enums.
TEST_F
TEST_F(OmptSequencedAsserterTest, DefaultState)
Definition: asserter-seq-test.cpp:26
OmptSequencedAsserterTest
SequencedAsserter test-fixture class to avoid code duplication among tests.
Definition: asserter-seq-test.cpp:13
OmptSequencedAsserterTest::SeqAsserter
std::unique_ptr< omptest::OmptSequencedAsserter > SeqAsserter
Definition: asserter-seq-test.cpp:23
omptest::OmptAssertEvent
Assertion event struct, provides statically callable CTORs.
Definition: OmptAssertEvent.h:34
omptest::OmptAssertEvent::AssertionSuspend
static OmptAssertEvent AssertionSuspend(const std::string &Name, const std::string &Group, const ObserveState &Expected)
Definition: OmptAssertEvent.cpp:49
omptest::OmptAssertEvent::AssertionSyncPoint
static OmptAssertEvent AssertionSyncPoint(const std::string &Name, const std::string &Group, const ObserveState &Expected, const std::string &SyncPointName)
Definition: OmptAssertEvent.cpp:39
omptest::OmptAssertEvent::DeviceUnload
static OmptAssertEvent DeviceUnload(const std::string &Name, const std::string &Group, const ObserveState &Expected)
Definition: OmptAssertEvent.cpp:353
omptest::OmptAssertEvent::DeviceFinalize
static OmptAssertEvent DeviceFinalize(const std::string &Name, const std::string &Group, const ObserveState &Expected, int DeviceNum)
Definition: OmptAssertEvent.cpp:329
omptest::OmptAssertEvent::ParallelBegin
static OmptAssertEvent ParallelBegin(const std::string &Name, const std::string &Group, const ObserveState &Expected, int NumThreads)
Definition: OmptAssertEvent.cpp:76
omptest::OmptAssertEvent::Target
static OmptAssertEvent Target(const std::string &Name, const std::string &Group, const ObserveState &Expected, ompt_target_t Kind, ompt_scope_endpoint_t Endpoint, int DeviceNum=expectedDefault(int), ompt_data_t *TaskData=expectedDefault(ompt_data_t *), ompt_id_t TargetId=expectedDefault(ompt_id_t), const void *CodeptrRA=expectedDefault(void *))
Definition: OmptAssertEvent.cpp:172
Generated on Tue Sep 2 2025 18:35:28 for LLVM OpenMP by doxygen 1.9.6