test: refine code

Author: shuai132

include/coro/condition_variable.hpp

@@ -18,7 +18,7 @@ namespace coro {
 //   - std::mutex: Thread-safe for multithreaded use (default)
 //   - dummy_mutex: No lock overhead for single-threaded use
 template <typename MUTEX = std::mutex>
-struct condition_variable {
+struct condition_variable_t {
  private:
   // Intrusive list node for waiting coroutines
   struct waiter_node {
@@ -28,14 +28,14 @@ struct condition_variable {
   };
 
  public:
-  condition_variable() : head_(nullptr), tail_(nullptr) {}
+  condition_variable_t() : head_(nullptr), tail_(nullptr) {}
 
   // Wait releases the mutex and suspends the coroutine
   // When resumed by notify, the mutex is NOT automatically re-acquired
   // You must manually re-acquire the lock after wait returns
   // Similar to Go's cond.Wait()
   struct wait_awaitable {
-    condition_variable* cv_;
+    condition_variable_t* cv_;
     void* mtx_{};                 // Type-erased mutex pointer
     void (*unlock_fn_)(void*){};  // Function pointer to unlock
     waiter_node node_{};
@@ -178,7 +178,8 @@ struct condition_variable {
 };
 
 // Type aliases for convenience
-using condition_variable_mt = condition_variable<std::mutex>;
-using condition_variable_st = condition_variable<dummy_mutex>;
+using condition_variable = condition_variable_t<std::mutex>;
+using condition_variable_mt = condition_variable_t<std::mutex>;
+using condition_variable_st = condition_variable_t<dummy_mutex>;
 
 }  // namespace coro

test/coro_condition_variable_mt.cpp

@@ -35,8 +35,8 @@ void test_concurrent_notify() {
     auto exec = std::make_unique<executor_loop>();
     auto* exec_ptr = exec.get();
 
-    // Capture i by value properly
-    static auto waiter = [&mtx, &cv, &wakeup_count, id = i]() -> async<void> {
+    // Create waiter with proper parameter passing
+    auto waiter = [](coro::mutex& mtx, coro::condition_variable& cv, std::atomic<int>& wakeup_count, int id) -> async<void> {
       LOG("Waiter %d: starting", id);
       co_await mtx.lock();
       LOG("Waiter %d: acquired lock, waiting", id);
@@ -49,7 +49,7 @@ void test_concurrent_notify() {
       LOG("Waiter %d: finished", id);
     };
 
-    waiter().detach(*exec_ptr);
+    waiter(mtx, cv, wakeup_count, i).detach(*exec_ptr);
 
     // Each executor runs in its own thread
     threads.emplace_back([exec_ptr]() {
@@ -126,7 +126,7 @@ void test_concurrent_wait() {
     for (int wid = 0; wid < waiters_per_thread; wid++) {
       int unique_id = tid * waiters_per_thread + wid;
 
-      static auto waiter = [&mtx, &cv, &ready_count, unique_id]() -> async<void> {
+      auto waiter = [](coro::mutex& mtx, coro::condition_variable& cv, std::atomic<int>& ready_count, int unique_id) -> async<void> {
         co_await mtx.lock();
         LOG("Waiter %d: waiting", unique_id);
         co_await cv.wait(mtx);
@@ -136,7 +136,7 @@ void test_concurrent_wait() {
         mtx.unlock();
       };
 
-      waiter().detach(*exec_ptr);
+      waiter(mtx, cv, ready_count, unique_id).detach(*exec_ptr);
     }
 
     threads.emplace_back([exec_ptr]() {

test/coro_wait_group_mt.cpp

@@ -255,7 +255,7 @@ async<void> wait_group_reuse_mt_test(executor& exec1, executor& exec2, std::thre
 }
 
 // Test wait_group_st (single-threaded version) on multiple threads to verify it works
-async<void> wait_group_st_test(executor& exec1, executor& exec2, std::thread::id exec1_tid, std::thread::id exec2_tid) {
+async<void> wait_group_st_test() {
   LOG("=== Single-Thread WaitGroup Type Test ===");
 
   // Note: wait_group_st is for single-threaded use, but we test it still works correctly
@@ -309,7 +309,7 @@ async<void> run_all_tests(executor& exec1, executor& exec2, std::thread::id exec
   co_await wait_group_reuse_mt_test(exec1, exec2, exec1_tid, exec2_tid);
   LOG("");
 
-  co_await wait_group_st_test(exec1, exec2, exec1_tid, exec2_tid);
+  co_await wait_group_st_test();
   LOG("");
 
   LOG("=== All Wait Group Multi-Thread Tests PASSED! ===");