diff --git a/include/yaclib/algo/when_any.hpp b/include/yaclib/algo/when_any.hpp
index d50a73030..6c44a60e4 100644
--- a/include/yaclib/algo/when_any.hpp
+++ b/include/yaclib/algo/when_any.hpp
@@ -17,15 +17,24 @@ enum class PolicyWhenAny {
 namespace detail {
 
 template <typename T, PolicyWhenAny P>
-class AnyCombinator : public util::IRef {
+class AnyCombinator : public BaseCore {
  public:
-  static std::pair<Future<T>, util::Ptr<AnyCombinator>> Make(bool empty = true) {
+  static std::pair<Future<T>, util::Ptr<AnyCombinator>> Make(size_t size = 0) {
     auto [future, promise] = MakeContract<T>();
-    if (empty) {
+    if (size == 0) {
       std::move(promise).Set(util::Result<T>{});
       return {std::move(future), nullptr};
     }
-    return {std::move(future), new util::Counter<AnyCombinator<T, P>>{std::move(promise)}};
+    return {
+        std::move(future),
+        new util::Counter<AnyCombinator<T, P>>{std::move(promise), size},
+    };
+  }
+
+  void CallInline(void* context) noexcept final {
+    if (BaseCore::GetState() != BaseCore::State::HasStop) {
+      Combine(std::move(static_cast<ResultCore<T>*>(context)->Get()));
+    }
   }
 
   void Combine(util::Result<T>&& result) {
@@ -37,59 +46,38 @@ class AnyCombinator : public util::IRef {
       if (!_done.exchange(true, std::memory_order_acq_rel)) {
         std::move(_promise).Set(std::move(result));
       }
-    } else if (!_error.load(std::memory_order_acquire) && !_error.exchange(true, std::memory_order_acq_rel)) {
-      _except_error = std::move(result);
+    } else {
+      if constexpr (P == PolicyWhenAny::FirstError) {
+        if (!_error.load(std::memory_order_acquire) && !_error.exchange(true, std::memory_order_acq_rel)) {
+          _except_error = std::move(result);
+        }
+      } else if constexpr (P == PolicyWhenAny::LastError) {
+        if (_size.fetch_sub(1, std::memory_order_acq_rel) == 1U) {
+          std::move(_promise).Set(std::move(result));
+        }
+      }
     }
   }
 
   ~AnyCombinator() override {
-    if (!_done.load(std::memory_order_acquire)) {
-      std::move(_promise).Set(std::move(_except_error));
+    if constexpr (P == PolicyWhenAny::FirstError) {
+      if (!_done.load(std::memory_order_acquire)) {
+        std::move(_promise).Set(std::move(_except_error));
+      }
     }
   }
 
  private:
-  explicit AnyCombinator(Promise<T> promise) : _promise{std::move(promise)} {
+  explicit AnyCombinator(Promise<T> promise, size_t size = 0)
+      : BaseCore{BaseCore::State::Empty}, _size(size), _promise{std::move(promise)} {
   }
 
-  alignas(kCacheLineSize) std::atomic<bool> _done{false};
-  alignas(kCacheLineSize) std::atomic<bool> _error{false};
-  util::Result<T> _except_error;
-  Promise<T> _promise;
-};
+  std::atomic<bool> _done{false};
 
-template <typename T>
-class AnyCombinator<T, PolicyWhenAny::LastError> : public util::IRef {
- public:
-  static std::pair<Future<T>, util::Ptr<AnyCombinator>> Make(size_t size = 0) {
-    auto [future, promise] = MakeContract<T>();
-    if (size == 0) {
-      std::move(promise).Set(util::Result<T>{});
-      return {std::move(future), nullptr};
-    }
-    return {std::move(future), new util::Counter<AnyCombinator<T, PolicyWhenAny::LastError>>{std::move(promise), size}};
-  }
+  std::atomic<size_t> _size{0};
+  std::atomic<bool> _error{false};
 
-  void Combine(util::Result<T>&& result) {
-    if (_done.load(std::memory_order_acquire)) {
-      return;
-    }
-
-    if (result) {
-      if (!_done.exchange(true, std::memory_order_acq_rel)) {
-        std::move(_promise).Set(std::move(result));
-      }
-    } else if (_size.fetch_sub(1, std::memory_order_acq_rel) == 1U) {
-      std::move(_promise).Set(std::move(result));
-    }
-  }
-
- private:
-  explicit AnyCombinator(Promise<T> promise, size_t size = 0) : _size{size}, _promise{std::move(promise)} {
-  }
-
-  alignas(kCacheLineSize) std::atomic<bool> _done{false};
-  alignas(kCacheLineSize) std::atomic<size_t> _size;
+  util::Result<T> _except_error;
   Promise<T> _promise;
 };
 
@@ -98,10 +86,8 @@ using AnyCombinatorPtr = util::Ptr<AnyCombinator<T, P>>;
 
 template <PolicyWhenAny P = PolicyWhenAny::FirstError, typename T, typename... Fs>
 void WhenAnyImpl(detail::AnyCombinatorPtr<T, P>& combinator, Future<T>&& head, Fs&&... tail) {
-  std::move(head).Subscribe([c = combinator](util::Result<T>&& result) mutable {
-    c->Combine(std::move(result));
-    c = nullptr;
-  });
+  head.GetCore()->SetCallbackInline(combinator);
+  std::move(head).Detach();
   if constexpr (sizeof...(tail) != 0) {
     WhenAnyImpl(combinator, std::forward<Fs>(tail)...);
   }
@@ -121,18 +107,10 @@ void WhenAnyImpl(detail::AnyCombinatorPtr<T, P>& combinator, Future<T>&& head, F
 template <PolicyWhenAny P = PolicyWhenAny::FirstError, typename It,
           typename T = util::detail::FutureValueT<typename std::iterator_traits<It>::value_type>>
 auto WhenAny(It begin, size_t size) {
-  auto [future, combinator] = [&size] {
-    if constexpr (P == PolicyWhenAny::FirstError) {
-      return detail::AnyCombinator<T, P>::Make(size == 0);
-    } else {
-      return detail::AnyCombinator<T, P>::Make(size);
-    }
-  }();
+  auto [future, combinator] = detail::AnyCombinator<T, P>::Make(size);
   for (size_t i = 0; i != size; ++i) {
-    std::move(*begin).Subscribe([c = combinator](util::Result<T>&& result) mutable {
-      c->Combine(std::move(result));
-      c = nullptr;
-    });
+    begin->GetCore()->SetCallbackInline(combinator);
+    std::move(*begin).Detach();
     ++begin;
   }
   return std::move(future);
@@ -150,20 +128,9 @@ auto WhenAny(It begin, size_t size) {
 template <PolicyWhenAny P = PolicyWhenAny::FirstError, typename It,
           typename T = util::detail::FutureValueT<typename std::iterator_traits<It>::value_type>>
 auto WhenAny(It begin, It end) {
-  auto [future, combinator] = [&begin, &end] {
-    if constexpr (P == PolicyWhenAny::FirstError) {
-      return detail::AnyCombinator<T, P>::Make(begin == end);
-    } else {
-      return detail::AnyCombinator<T, P>::Make(std::distance(begin, end));
-    }
-  }();
-  for (; begin != end; ++begin) {
-    std::move(*begin).Subscribe([c = combinator](util::Result<T>&& result) mutable {
-      c->Combine(std::move(result));
-      c = nullptr;
-    });
-  }
-  return std::move(future);
+  size_t size = std::distance(begin, end);
+  auto [future, combinator] = detail::AnyCombinator<T, P>::Make(size);
+  return WhenAny(begin, size);
 }
 
 /**
@@ -177,13 +144,7 @@ auto WhenAny(It begin, It end) {
 template <PolicyWhenAny P = PolicyWhenAny::FirstError, typename T, typename... Fs>
 auto WhenAny(Future<T>&& head, Fs&&... tail) {
   static_assert((... && util::IsFutureV<Fs>));
-  auto [future, combinator] = [] {
-    if constexpr (P == PolicyWhenAny::FirstError) {
-      return detail::AnyCombinator<T, P>::Make(false);
-    } else {
-      return detail::AnyCombinator<T, P>::Make(sizeof...(Fs) + 1);
-    }
-  }();
+  auto [future, combinator] = detail::AnyCombinator<T, P>::Make(sizeof...(Fs) + 1);
   detail::WhenAnyImpl<P>(combinator, std::move(head), std::forward<Fs>(tail)...);
   return std::move(future);
 }
diff --git a/test/unit/algo/when_all.cpp b/test/unit/algo/when_all.cpp
index 6310c670d..224425ec7 100644
--- a/test/unit/algo/when_all.cpp
+++ b/test/unit/algo/when_all.cpp
@@ -17,6 +17,16 @@ enum class TestSuite {
   Array,
 };
 
+template <typename T>
+class WaitAllT : public testing::Test {
+ public:
+  using Type = T;
+};
+
+using MyTypes = ::testing::Types<int, void>;
+
+TYPED_TEST_SUITE(WaitAllT, MyTypes);
+
 template <TestSuite suite, typename T = int>
 void JustWorks() {
   constexpr int kSize = 3;
@@ -73,20 +83,12 @@ void JustWorks() {
   }
 }
 
-TEST(Vector, JustWorks) {
-  JustWorks<TestSuite::Vector>();
-}
-
-TEST(VoidVector, JustWorks) {
-  JustWorks<TestSuite::Vector, void>();
-}
-
-TEST(Array, JustWorks) {
-  JustWorks<TestSuite::Array>();
+TYPED_TEST(WaitAllT, VectorJustWorks) {
+  JustWorks<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(VoidArray, JustWorks) {
-  JustWorks<TestSuite::Array, void>();
+TYPED_TEST(WaitAllT, ArrayJustWorks) {
+  JustWorks<TestSuite::Array, typename TestFixture::Type>();
 }
 
 template <TestSuite suite, typename T = void>
@@ -120,20 +122,12 @@ void AllFails() {
   EXPECT_THROW(std::move(all).Get().Ok(), std::runtime_error);
 }
 
-TEST(Vector, AllFails) {
-  AllFails<TestSuite::Vector>();
+TYPED_TEST(WaitAllT, VectorAllFails) {
+  AllFails<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(Array, AllFails) {
-  AllFails<TestSuite::Array>();
-}
-
-TEST(VoidVector, AllFails) {
-  AllFails<TestSuite::Vector, void>();
-}
-
-TEST(VoidArray, AllFails) {
-  AllFails<TestSuite::Array, void>();
+TYPED_TEST(WaitAllT, ArrayAllFails) {
+  AllFails<TestSuite::Array, typename TestFixture::Type>();
 }
 
 template <typename T = int>
@@ -203,20 +197,12 @@ void MultiThreaded() {
   tp->Wait();
 }
 
-TEST(Vector, MultiThreaded) {
-  MultiThreaded<TestSuite::Vector>();
-}
-
-TEST(VoidVector, MultiThreaded) {
-  MultiThreaded<TestSuite::Vector, void>();
-}
-
-TEST(Array, MultiThreaded) {
-  MultiThreaded<TestSuite::Array>();
+TYPED_TEST(WaitAllT, VectorMultiThreaded) {
+  MultiThreaded<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(VoidArray, MultiThreaded) {
-  MultiThreaded<TestSuite::Array, void>();
+TYPED_TEST(WaitAllT, ArrayMultiThreaded) {
+  MultiThreaded<TestSuite::Array, typename TestFixture::Type>();
 }
 
 }  // namespace
diff --git a/test/unit/algo/when_any.cpp b/test/unit/algo/when_any.cpp
index 9f9df3485..141deaab6 100644
--- a/test/unit/algo/when_any.cpp
+++ b/test/unit/algo/when_any.cpp
@@ -12,26 +12,45 @@ namespace {
 using namespace yaclib;
 using namespace std::chrono_literals;
 
-enum class TestSuite { Vector, Array };
+enum class TestSuite {
+  Vector,
+  Array,
+};
 
-template <TestSuite suite, typename T = int, PolicyWhenAny P = PolicyWhenAny::FirstError>
-void JustWorks() {
-  constexpr int kSize = 3;
+template <typename T>
+class WaitAnyT : public testing::Test {
+ public:
+  using Type = T;
+};
 
-  std::array<Promise<T>, kSize> promises;
-  std::array<Future<T>, kSize> futures;
+using MyTypes = ::testing::Types<int, void>;
+
+TYPED_TEST_SUITE(WaitAnyT, MyTypes);
+
+template <TestSuite suite, typename T = int, PolicyWhenAny P = PolicyWhenAny::FirstError, int kSize = 3>
+auto FillArrays(std::array<Promise<T>, kSize>& promises, std::array<Future<T>, kSize>& futures) {
   for (int i = 0; i < kSize; ++i) {
     auto [f, p] = MakeContract<T>();
     futures[i] = std::move(f);
     promises[i] = std::move(p);
   }
-  auto any = [&futures] {
+
+  return [&futures] {
     if constexpr (suite == TestSuite::Array) {
       return WhenAny<P>(std::move(futures[0]), std::move(futures[1]), std::move(futures[2]));
     } else {
       return WhenAny<P>(futures.begin(), futures.end());
     }
   }();
+}
+
+template <TestSuite suite, typename T = int, PolicyWhenAny P = PolicyWhenAny::FirstError>
+void JustWorks() {
+  constexpr int kSize = 3;
+
+  std::array<Promise<T>, kSize> promises;
+  std::array<Future<T>, kSize> futures;
+  auto any = FillArrays<suite, T, P, 3>(promises, futures);
 
   EXPECT_FALSE(any.Ready());
 
@@ -49,36 +68,20 @@ void JustWorks() {
   }
 }
 
-TEST(VectorFirstError, JustWorks) {
-  JustWorks<TestSuite::Vector>();
-}
-
-TEST(VectorLastError, JustWorks) {
-  JustWorks<TestSuite::Vector, int, PolicyWhenAny::LastError>();
-}
-
-TEST(VoidVectorFirstError, JustWorks) {
-  JustWorks<TestSuite::Vector, void>();
-}
-
-TEST(VoidVectorLastError, JustWorks) {
-  JustWorks<TestSuite::Vector, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, VectorFirstErrorJustWorks) {
+  JustWorks<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(ArrayFirstError, JustWorks) {
-  JustWorks<TestSuite::Array>();
+TYPED_TEST(WaitAnyT, VectorLastErrorJustWorks) {
+  JustWorks<TestSuite::Vector, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
-TEST(ArrayLastError, JustWorks) {
-  JustWorks<TestSuite::Array, int, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, ArrayFirstErrorJustWorks) {
+  JustWorks<TestSuite::Array, typename TestFixture::Type>();
 }
 
-TEST(VoidArrayFirstError, JustWorks) {
-  JustWorks<TestSuite::Array, void>();
-}
-
-TEST(VoidArrayLastError, JustWorks) {
-  JustWorks<TestSuite::Array, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, ArrayLastErrorJustWorks) {
+  JustWorks<TestSuite::Array, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
 template <TestSuite suite, typename T = void, PolicyWhenAny P = PolicyWhenAny::FirstError>
@@ -86,19 +89,7 @@ void AllFails() {
   constexpr int kSize = 3;
   std::array<Promise<T>, kSize> promises;
   std::array<Future<T>, kSize> futures;
-  for (int i = 0; i < kSize; ++i) {
-    auto [f, p] = MakeContract<T>();
-    futures[i] = std::move(f);
-    promises[i] = std::move(p);
-  }
-
-  auto any = [&futures] {
-    if constexpr (suite == TestSuite::Array) {
-      return WhenAny<P>(std::move(futures[0]), std::move(futures[1]), std::move(futures[2]));
-    } else {
-      return WhenAny<P>(futures.begin(), futures.end());
-    }
-  }();
+  auto any = FillArrays<suite, T, P, 3>(promises, futures);
 
   EXPECT_FALSE(any.Ready());
 
@@ -118,36 +109,20 @@ void AllFails() {
   }
 }
 
-TEST(VectorFirstError, AllFails) {
-  AllFails<TestSuite::Vector>();
-}
-
-TEST(VectorLastError, AllFails) {
-  AllFails<TestSuite::Vector, int, PolicyWhenAny::LastError>();
-}
-
-TEST(VoidVectorFirstError, AllFails) {
-  AllFails<TestSuite::Vector, void>();
-}
-
-TEST(VoidVectorLastError, AllFails) {
-  AllFails<TestSuite::Vector, void, PolicyWhenAny::LastError>();
-}
-
-TEST(ArrayFirstError, AllFails) {
-  AllFails<TestSuite::Array>();
+TYPED_TEST(WaitAnyT, VectorFirstErrorAllFails) {
+  AllFails<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(ArrayLastError, AllFails) {
-  AllFails<TestSuite::Array, int, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, VectorLastErrorAllFails) {
+  AllFails<TestSuite::Vector, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
-TEST(VoidArrayFirstError, AllFails) {
-  AllFails<TestSuite::Array, void>();
+TYPED_TEST(WaitAnyT, ArrayFirstErrorAllFails) {
+  AllFails<TestSuite::Array, typename TestFixture::Type>();
 }
 
-TEST(VoidArrayLastError, AllFails) {
-  AllFails<TestSuite::Array, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, ArrayLastErrorAllFails) {
+  AllFails<TestSuite::Array, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
 template <TestSuite suite, typename T = int, PolicyWhenAny P = PolicyWhenAny::FirstError>
@@ -155,19 +130,7 @@ void ResultWithFails() {
   constexpr int kSize = 3;
   std::array<Promise<T>, kSize> promises;
   std::array<Future<T>, kSize> futures;
-  for (int i = 0; i < kSize; ++i) {
-    auto [f, p] = MakeContract<T>();
-    futures[i] = std::move(f);
-    promises[i] = std::move(p);
-  }
-
-  auto any = [&futures] {
-    if constexpr (suite == TestSuite::Array) {
-      return WhenAny<P>(std::move(futures[0]), std::move(futures[1]), std::move(futures[2]));
-    } else {
-      return WhenAny<P>(futures.begin(), futures.end());
-    }
-  }();
+  auto any = FillArrays<suite, T, P, 3>(promises, futures);
 
   EXPECT_FALSE(any.Ready());
 
@@ -188,36 +151,20 @@ void ResultWithFails() {
   }
 }
 
-TEST(VectorFirstError, ResultWithFails) {
-  ResultWithFails<TestSuite::Vector>();
-}
-
-TEST(VectorLastError, ResultWithFails) {
-  ResultWithFails<TestSuite::Vector, int, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, VectorFirstErrorResultWithFails) {
+  AllFails<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(VoidVectorFirstError, ResultWithFails) {
-  ResultWithFails<TestSuite::Vector, void>();
+TYPED_TEST(WaitAnyT, VectorLastErrorResultWithFails) {
+  AllFails<TestSuite::Vector, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
-TEST(VoidVectorLastError, ResultWithFails) {
-  ResultWithFails<TestSuite::Vector, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, ArrayFirstErrorResultWithFails) {
+  AllFails<TestSuite::Array, typename TestFixture::Type>();
 }
 
-TEST(ArrayFirstError, ResultWithFails) {
-  ResultWithFails<TestSuite::Array>();
-}
-
-TEST(ArrayLastError, ResultWithFails) {
-  ResultWithFails<TestSuite::Array, int, PolicyWhenAny::LastError>();
-}
-
-TEST(VoidArrayFirstError, ResultWithFails) {
-  ResultWithFails<TestSuite::Array, void>();
-}
-
-TEST(VoidArrayLastError, ResultWithFails) {
-  ResultWithFails<TestSuite::Array, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, ArrayLastErrorResultWithFails) {
+  AllFails<TestSuite::Array, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
 template <typename T = int, PolicyWhenAny P = PolicyWhenAny::FirstError>
@@ -230,20 +177,12 @@ void EmptyInput() {
   EXPECT_THROW(std::move(any).Get().Ok(), std::exception);
 }
 
-TEST(VectorFirstError, EmptyInput) {
-  EmptyInput();
-}
-
-TEST(VectorLastError, EmptyInput) {
-  EmptyInput<int, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, FirstErrorEmptyInput) {
+  EmptyInput<typename TestFixture::Type>();
 }
 
-TEST(VoidVectorFirstError, EmptyInput) {
-  EmptyInput<void>();
-}
-
-TEST(VoidVectorLastError, EmptyInput) {
-  EmptyInput<void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, LastErrorEmptyInput) {
+  EmptyInput<typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
 template <TestSuite suite, typename T = int, PolicyWhenAny P = PolicyWhenAny::FirstError>
@@ -293,36 +232,20 @@ void MultiThreaded() {
   tp->Wait();
 }
 
-TEST(VectorFirstError, MultiThreaded) {
-  MultiThreaded<TestSuite::Vector>();
-}
-
-TEST(VectorLastError, MultiThreaded) {
-  MultiThreaded<TestSuite::Vector, int, PolicyWhenAny::LastError>();
-}
-
-TEST(VoidVectorFirstError, MultiThreaded) {
-  MultiThreaded<TestSuite::Vector, void>();
+TYPED_TEST(WaitAnyT, VectorFirstErrorMultiThreaded) {
+  MultiThreaded<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(VoidVectorLastError, MultiThreaded) {
-  MultiThreaded<TestSuite::Vector, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, VectorLastErrorMultiThreaded) {
+  MultiThreaded<TestSuite::Vector, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
-TEST(ArrayFirstError, MultiThreaded) {
-  MultiThreaded<TestSuite::Array>();
+TYPED_TEST(WaitAnyT, ArrayFirstErrorMultiThreaded) {
+  MultiThreaded<TestSuite::Array, typename TestFixture::Type>();
 }
 
-TEST(ArrayLastError, MultiThreaded) {
-  MultiThreaded<TestSuite::Array, int, PolicyWhenAny::LastError>();
-}
-
-TEST(VoidArrayFirstError, MultiThreaded) {
-  MultiThreaded<TestSuite::Array, void>();
-}
-
-TEST(VoidArrayLastError, MultiThreaded) {
-  MultiThreaded<TestSuite::Array, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, ArrayLastErrorMultiThreaded) {
+  MultiThreaded<TestSuite::Array, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
 template <TestSuite suite, typename T = int, PolicyWhenAny P = PolicyWhenAny::FirstError>
@@ -371,36 +294,20 @@ void TimeTest() {
   tp->Wait();
 }
 
-TEST(VectorFirstError, TimeTest) {
-  TimeTest<TestSuite::Vector>();
-}
-
-TEST(VectorLastError, TimeTest) {
-  TimeTest<TestSuite::Vector, int, PolicyWhenAny::LastError>();
-}
-
-TEST(VoidVectorFirstError, TimeTest) {
-  TimeTest<TestSuite::Vector, void>();
+TYPED_TEST(WaitAnyT, VectorFirstErrorTimeTest) {
+  TimeTest<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(VoidVectorLastError, TimeTest) {
-  TimeTest<TestSuite::Vector, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, VectorLastErrorTimeTest) {
+  TimeTest<TestSuite::Vector, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
-TEST(ArrayFirstError, TimeTest) {
-  TimeTest<TestSuite::Array>();
+TYPED_TEST(WaitAnyT, ArrayFirstErrorTimeTest) {
+  TimeTest<TestSuite::Array, typename TestFixture::Type>();
 }
 
-TEST(ArrayLastError, TimeTest) {
-  TimeTest<TestSuite::Array, int, PolicyWhenAny::LastError>();
-}
-
-TEST(VoidArrayFirstError, TimeTest) {
-  TimeTest<TestSuite::Array, void>();
-}
-
-TEST(VoidArrayLastError, TimeTest) {
-  TimeTest<TestSuite::Array, void, PolicyWhenAny::LastError>();
+TYPED_TEST(WaitAnyT, ArrayLastErrorTimeTest) {
+  TimeTest<TestSuite::Array, typename TestFixture::Type, PolicyWhenAny::LastError>();
 }
 
 template <TestSuite suite, typename T = int>
@@ -438,20 +345,12 @@ void DefaultPolice() {
   }
 }
 
-TEST(VectorFirstError, DefaultPolice) {
-  DefaultPolice<TestSuite::Vector>();
-}
-
-TEST(VoidVectorFirstError, DefaultPolice) {
-  DefaultPolice<TestSuite::Vector, void>();
-}
-
-TEST(ArrayFirstError, DefaultPolice) {
-  DefaultPolice<TestSuite::Array>();
+TYPED_TEST(WaitAnyT, VectorDefaultPolice) {
+  DefaultPolice<TestSuite::Vector, typename TestFixture::Type>();
 }
 
-TEST(VoidArrayFirstError, DefaultPolice) {
-  DefaultPolice<TestSuite::Array, void>();
+TYPED_TEST(WaitAnyT, ArrayDefaultPolice) {
+  DefaultPolice<TestSuite::Array, typename TestFixture::Type>();
 }
 
 }  // namespace