test: drop a bunch of NOLINT

test/entt/process/scheduler.cpp

@@ -22,31 +22,20 @@ struct foo_process: entt::process<foo_process, entt::scheduler::delta_type> {
 };
 
 struct succeeded_process: entt::process<succeeded_process, entt::scheduler::delta_type> {
-    void update(delta_type, void *) {
-        ++invoked;
+    void update(delta_type, void *data) {
+        ++static_cast<std::pair<int, int> *>(data)->first;
         succeed();
     }
-
-    inline static unsigned int invoked; // NOLINT
 };
 
 struct failed_process: entt::process<failed_process, entt::scheduler::delta_type> {
-    void update(delta_type, void *) {
-        ++invoked;
+    void update(delta_type, void *data) {
+        ++static_cast<std::pair<int, int> *>(data)->second;
         fail();
     }
-
-    inline static unsigned int invoked; // NOLINT
 };
 
-struct Scheduler: ::testing::Test {
-    void SetUp() override {
-        succeeded_process::invoked = 0u;
-        failed_process::invoked = 0u;
-    }
-};
-
-TEST_F(Scheduler, Functionalities) {
+TEST(Scheduler, Functionalities) {
     entt::scheduler scheduler{};
     entt::scheduler other{std::move(scheduler)};
 
@@ -80,7 +69,7 @@ TEST_F(Scheduler, Functionalities) {
     ASSERT_TRUE(scheduler.empty());
 }
 
-TEST_F(Scheduler, Swap) {
+TEST(Scheduler, Swap) {
     entt::scheduler scheduler{};
     entt::scheduler other{};
     int counter{};
@@ -107,8 +96,9 @@ TEST_F(Scheduler, Swap) {
     ASSERT_EQ(counter, 2);
 }
 
-TEST_F(Scheduler, Then) {
+TEST(Scheduler, Then) {
     entt::scheduler scheduler{};
+    std::pair<int, int> counter{};
 
     scheduler
         // failing process with successor
@@ -124,18 +114,15 @@ TEST_F(Scheduler, Then) {
         .attach<succeeded_process>()
         .then<succeeded_process>();
 
-    ASSERT_EQ(succeeded_process::invoked, 0u);
-    ASSERT_EQ(failed_process::invoked, 0u);
-
     while(!scheduler.empty()) {
-        scheduler.update(0);
+        scheduler.update(0, &counter);
     }
 
-    ASSERT_EQ(succeeded_process::invoked, 6u);
-    ASSERT_EQ(failed_process::invoked, 2u);
+    ASSERT_EQ(counter.first, 6u);
+    ASSERT_EQ(counter.second, 2u);
 }
 
-TEST_F(Scheduler, Functor) {
+TEST(Scheduler, Functor) {
     entt::scheduler scheduler{};
 
     bool first_functor = false;
@@ -164,26 +151,24 @@ TEST_F(Scheduler, Functor) {
     ASSERT_TRUE(scheduler.empty());
 }
 
-TEST_F(Scheduler, SpawningProcess) {
+TEST(Scheduler, SpawningProcess) {
     entt::scheduler scheduler{};
+    std::pair<int, int> counter{};
 
     scheduler.attach([&scheduler](auto, void *, auto resolve, auto) {
         scheduler.attach<succeeded_process>().then<failed_process>();
         resolve();
     });
 
-    ASSERT_EQ(succeeded_process::invoked, 0u);
-    ASSERT_EQ(failed_process::invoked, 0u);
-
     while(!scheduler.empty()) {
-        scheduler.update(0);
+        scheduler.update(0, &counter);
     }
 
-    ASSERT_EQ(succeeded_process::invoked, 1u);
-    ASSERT_EQ(failed_process::invoked, 1u);
+    ASSERT_EQ(counter.first, 1u);
+    ASSERT_EQ(counter.second, 1u);
 }
 
-TEST_F(Scheduler, CustomAllocator) {
+TEST(Scheduler, CustomAllocator) {
     const std::allocator<void> allocator{};
     entt::scheduler scheduler{allocator};