[OpenMP][OMPT] Refactorigns to ompTest and improvements

The patch introduces a few minor improvements and name changes to show
the more general nature of certain classes.
A test no longer exists/aborts execution when an assert fails, but
reports an error and continues execution.

Change-Id: I43b1af14b061a2e26981b94e2e3021266daf73a0

Author: jplehr

openmp/libomptarget/test/ompTest/include/OmptAssertEvent.h

@@ -9,6 +9,9 @@
 #include <string>
 
 namespace omptest{
+
+enum class AssertState { pass, fail };
+
 struct OmptAssertEvent {
   static OmptAssertEvent ThreadBegin(const std::string &Name) {
     auto EName = getName(Name);

openmp/libomptarget/test/ompTest/include/OmptAsserter.h

@@ -9,8 +9,15 @@
 
 #include <iostream>
 
+/// General base class for the subscriber/notification pattern in
+/// OmptCallbachHandler. Derived classes need to implement the notify method.
+struct OmptListener {
+  /// Called for each registered OMPT event of the OmptCallbackHandler
+  virtual void notify(omptest::OmptAssertEvent &&AE) = 0;
+};
+
 /// Base class for asserting on OMPT events
-class OmptAsserter {
+class OmptAsserter : public OmptListener {
 public:
   virtual void insert(omptest::OmptAssertEvent &&AE) {
     assert(false && "Base class 'insert' has undefined semantics.");
@@ -39,24 +46,29 @@ class OmptAsserter {
 /// Class that can assert in a sequenced fashion, i.e., events hace to occur in
 /// the order they were registered
 struct OmptSequencedAsserter : public OmptAsserter {
+  OmptSequencedAsserter()
+      : NextEvent(0), Events(), State(omptest::AssertState::pass) {}
+
+  /// Add the event to the in-sequence set of events that the asserter should
+  /// check for.
   void insert(omptest::OmptAssertEvent &&AE) override {
     Events.emplace_back(std::move(AE));
   }
 
-  /// Implements the asserter's logic
+  /// Implements the asserter's actual logic
   virtual void notifyImpl(omptest::OmptAssertEvent &&AE) override {
     // Ignore notifications while inactive
     if (!isActive())
       return;
 
-    std::cout << "OmptSequencedAsserter::notifyImpl called w/ " << Events.size()
-              << " Events to check.\nNext Check item: " << NextEvent
-              << std::endl;
     if (NextEvent >= Events.size()) {
-      std::cerr << "[Error] Too many events to check. Only asserted single "
-                   "event.\nOffending event: "
-                << AE.getEventName() << std::endl;
-      exit(-1); // TODO: Make this reasonable assert error
+      std::cerr << "[Error] [OmptSequencedAsserter] Too many events to check. "
+                   "Only asserted "
+                << Events.size()
+                << " event.\nOffending event: " << AE.getEventName()
+                << std::endl;
+      State = omptest::AssertState::fail;
+      return;
     }
 
     auto &E = Events[NextEvent++];
@@ -66,11 +78,21 @@ struct OmptSequencedAsserter : public OmptAsserter {
     // TODO: Implement assert error
     std::cout << "[ASSERT ERROR] The events are not equal.\n"
               << AE.getEventName() << " == " << E.getEventName() << std::endl;
-    exit(-2);
+    State = omptest::AssertState::fail;
+  }
+
+  omptest::AssertState getState() {
+    // This is called after the testcase executed.
+    // Once, reached, no more events should be in the queue
+    if (NextEvent < Events.size())
+      State = omptest::AssertState::fail;
+
+    return State;
   }
 
-  int NextEvent{0};
+  size_t NextEvent{0};
   std::vector<omptest::OmptAssertEvent> Events;
+  omptest::AssertState State;
 };
 
 /// Class that asserts with set semantics, i.e., unordered

openmp/libomptarget/test/ompTest/include/OmptCallbackHandler.h

@@ -17,7 +17,7 @@ struct OmptCallbackHandler {
     return Handler;
   }
 
-  void subscribe(OmptAsserter *Asserter) { Subscribers.push_back(Asserter); }
+  void subscribe(OmptListener *Listener) { Subscribers.push_back(Listener); }
 
   void clearSubscribers() { Subscribers.clear(); }
 
@@ -135,6 +135,6 @@ struct OmptCallbackHandler {
                      ompt_data_t *parallel_data, ompt_data_t *task_data,
                      uint64_t count, const void *codeptr_ra) {}
 
-  std::vector<OmptAsserter *> Subscribers;
+  std::vector<OmptListener *> Subscribers;
 };
 #endif

openmp/libomptarget/test/ompTest/include/OmptTester.h

@@ -29,32 +29,30 @@ ompt_start_tool_result_t *ompt_start_tool(unsigned int omp_version,
 #endif
 
 struct Error {
-  operator bool() { return fail; }
-  bool fail;
+  operator bool() { return Fail; }
+  bool Fail;
 };
 
-enum class AssertState { pass, fail };
-
 /// A pretty crude test case abstraction
 struct TestCase {
-  TestCase(const std::string name) : Name(name) {}
+  TestCase(const std::string &name) : Name(name) {}
   virtual ~TestCase() {}
   std::string Name;
-  AssertState assertState;
+  omptest::AssertState AS;
   Error exec() {
     OmptCallbackHandler::get().subscribe(&SequenceAsserter);
     OmptCallbackHandler::get().subscribe(&EventAsserter);
 
-    Error e;
-    e.fail = false;
+    Error E;
+    E.Fail = false;
     execImpl();
 
     // We remove subscribers to not be notified of events after our test case
     // finished.
     OmptCallbackHandler::get().clearSubscribers();
-    if (assertState == AssertState::fail)
-      e.fail = true;
-    return e;
+    if (SequenceAsserter.getState() == omptest::AssertState::fail)
+      E.Fail = true;
+    return E;
   };
 
   virtual void execImpl() { assert(false && "Allocating base class"); }
@@ -65,19 +63,16 @@ struct TestCase {
   OmptEventAsserter EventAsserter;
 };
 
-void failAssertImpl(TestCase &tc) { tc.assertState = AssertState::fail; }
-void passAssertImpl(TestCase &tc) { tc.assertState = AssertState::pass; }
-
 /// A pretty crude test suite abstraction
 struct TestSuite {
   using C = std::vector<std::unique_ptr<TestCase>>;
 
   std::string Name;
   TestSuite() = default;
-  TestSuite(const TestSuite &o) = delete;
-  TestSuite(TestSuite &&o) {
-    Name = o.Name;
-    TestCases.swap(o.TestCases);
+  TestSuite(const TestSuite &O) = delete;
+  TestSuite(TestSuite &&O) {
+    Name = O.Name;
+    TestCases.swap(O.TestCases);
   }
 
   void setup() {}
@@ -139,8 +134,8 @@ struct Runner {
       TS.setup();
       for (auto &TC : TS) {
         std::cout << "\nExecuting " << TC->Name << std::endl;
-        if (Error err = TC->exec()) {
-          reportError();
+        if (Error Err = TC->exec()) {
+          reportError(Err);
           abortOrKeepGoing();
         }
       }
@@ -149,7 +144,7 @@ struct Runner {
     return 0;
   }
 
-  void reportError() {}
+  void reportError(const Error &Err) {}
   void abortOrKeepGoing() {}
 
   std::vector<TestSuite> TestSuites;

openmp/libomptarget/test/ompTest/src/main.cpp

@@ -76,4 +76,4 @@ int main(int argc, char **argv) {
 
   std::cout << "Ending" << std::endl;
   return 0;
-}
+}