test: Replace println! with debug!

frostyplanet · frostyplanet · commit 3fac0a8847ca · 2025-06-28T00:21:47.000+08:00
So that github action result loading will be faster.
diff --git a/src/tests/test_async.rs b/src/tests/test_async.rs
@@ -82,7 +82,7 @@ async fn test_basic_bounded_1_thread<T: AsyncTxTrait<i32>, R: AsyncRxTrait<i32>>
         for i in 0i32..12 {
             match rx.recv().await {
                 Ok(j) => {
-                    println!("recv {}", i);
+                    debug!("recv {}", i);
                     assert_eq!(i, j);
                 }
                 Err(e) => {
@@ -92,7 +92,7 @@ async fn test_basic_bounded_1_thread<T: AsyncTxTrait<i32>, R: AsyncRxTrait<i32>>
         }
         let res = rx.recv().await;
         assert!(res.is_err());
-        println!("rx close");
+        debug!("rx close");
         let _ = noti_tx.send(true);
     });
     assert!(tx.send(10).await.is_ok());
@@ -125,7 +125,7 @@ async fn test_basic_unbounded_1_thread<T: BlockingTxTrait<i32>, R: AsyncRxTrait<
         for i in 0i32..12 {
             match rx.recv().await {
                 Ok(j) => {
-                    println!("recv {}", i);
+                    debug!("recv {}", i);
                     assert_eq!(i, j);
                 }
                 Err(e) => {
@@ -135,7 +135,7 @@ async fn test_basic_unbounded_1_thread<T: BlockingTxTrait<i32>, R: AsyncRxTrait<
         }
         let res = rx.recv().await;
         assert!(res.is_err());
-        println!("rx close");
+        debug!("rx close");
         let _ = noti_tx.send(true);
     });
     assert!(tx.send(10).is_ok());
@@ -433,7 +433,7 @@ async fn test_presure_bounded_async_multi(
                 }
             }
             let _ = _noti_tx.send(_rx_i).await;
-            //println!("rx {} exit", _rx_i);
+            //debug!("rx {} exit", _rx_i);
         });
     }
     drop(tx);
diff --git a/src/tests/test_async_blocking.rs b/src/tests/test_async_blocking.rs
@@ -133,12 +133,12 @@ fn test_presure_1_tx_async_1_rx_blocking<T: AsyncTxTrait<usize>, R: BlockingRxTr
             match rx.recv() {
                 Ok(_) => {
                     _counter.as_ref().fetch_add(1, Ordering::SeqCst);
-                    //print!("{} {}\r", _rx_i, i);
+                    //debug!("{} {}\r", _rx_i, i);
                 }
                 Err(_) => break 'A,
             }
         }
-        println!("rx exit");
+        debug!("rx exit");
     });
     let rt = get_runtime();
     rt.block_on(async move {
@@ -148,7 +148,7 @@ fn test_presure_1_tx_async_1_rx_blocking<T: AsyncTxTrait<usize>, R: BlockingRxTr
                 _ => {}
             }
         }
-        println!("tx exit");
+        debug!("tx exit");
     });
     let _ = th.join();
     assert_eq!(counter.as_ref().load(Ordering::Acquire), round);
@@ -178,12 +178,12 @@ fn test_presure_multi_tx_async_1_rx_blocking<R: BlockingRxTrait<usize>>(
             match rx.recv() {
                 Ok(_) => {
                     _counter.as_ref().fetch_add(1, Ordering::SeqCst);
-                    //print!("{} {}\r", _rx_i, i);
+                    //debug!("{} {}\r", _rx_i, i);
                 }
                 Err(_) => break 'A,
             }
         }
-        println!("rx exit");
+        debug!("rx exit");
     });
     let rt = get_runtime();
     rt.block_on(async move {
@@ -199,7 +199,7 @@ fn test_presure_multi_tx_async_1_rx_blocking<R: BlockingRxTrait<usize>>(
                     }
                 }
                 let _ = _noti_tx.send(_tx_i).await;
-                println!("tx {} exit", _tx_i);
+                debug!("tx {} exit", _tx_i);
             });
         }
         drop(tx);
@@ -239,12 +239,12 @@ fn test_presure_multi_tx_async_multi_rx_blocking(
                 match _rx.recv() {
                     Ok(_) => {
                         _counter.as_ref().fetch_add(1, Ordering::SeqCst);
-                        //print!("{} {}\r", _rx_i, i);
+                        //debug!("{} {}\r", _rx_i, i);
                     }
                     Err(_) => break 'A,
                 }
             }
-            println!("rx {} exit", _rx_i);
+            debug!("rx {} exit", _rx_i);
         }));
     }
     drop(rx);
@@ -262,7 +262,7 @@ fn test_presure_multi_tx_async_multi_rx_blocking(
                     }
                 }
                 let _ = _noti_tx.send(_tx_i).await;
-                println!("tx {} exit", _tx_i);
+                debug!("tx {} exit", _tx_i);
             });
         }
         drop(tx);
diff --git a/src/tests/test_blocking_async.rs b/src/tests/test_blocking_async.rs
@@ -38,7 +38,7 @@ async fn test_basic_1_tx_blocking_1_rx_async<T: BlockingTxTrait<usize>, R: Async
     for i in 0usize..12 {
         match rx.recv().await {
             Ok(j) => {
-                println!("recv {}", i);
+                debug!("recv {}", i);
                 assert_eq!(i, j);
             }
             Err(e) => {
@@ -48,7 +48,7 @@ async fn test_basic_1_tx_blocking_1_rx_async<T: BlockingTxTrait<usize>, R: Async
     }
     let res = rx.recv().await;
     assert!(res.is_err());
-    println!("rx close");
+    debug!("rx close");
     let _ = th.join();
 }
 
@@ -134,7 +134,7 @@ async fn test_presure_tx_multi_blocking_1_rx_async<R: AsyncRxTrait<usize>>(
                 match _tx.send(i) {
                     Err(e) => panic!("{}", e),
                     _ => {
-                        //println!("tx {} {}", _tx_i, i);
+                        //debug!("tx {} {}", _tx_i, i);
                     }
                 }
             }
@@ -147,7 +147,7 @@ async fn test_presure_tx_multi_blocking_1_rx_async<R: AsyncRxTrait<usize>>(
         match rx.recv().await {
             Ok(_i) => {
                 _counter.as_ref().fetch_add(1, Ordering::SeqCst);
-                //println!("rx {} {}\r", _rx_i, _i);
+                //debug!("rx {} {}\r", _rx_i, _i);
             }
             Err(_) => break 'A,
         }
@@ -205,7 +205,7 @@ async fn test_presure_tx_multi_blocking_multi_rx_async(
                     }
                 }
             }
-            println!("tx {} exit", _tx_i);
+            debug!("tx {} exit", _tx_i);
         }));
     }
     drop(tx);
@@ -224,9 +224,9 @@ async fn test_presure_tx_multi_blocking_multi_rx_async(
                     Err(_) => break 'A,
                 }
             }
-            println!("rx {} exiting", _rx_i);
+            debug!("rx {} exiting", _rx_i);
             let _ = _noti_tx.send(_rx_i).await;
-            println!("rx {} exit", _rx_i);
+            debug!("rx {} exit", _rx_i);
         });
     }
     drop(rx);

Original file line number	Diff line number	Diff line change
`@@ -133,12 +133,12 @@ fn test_presure_1_tx_async_1_rx_blocking<T: AsyncTxTrait<usize>, R: BlockingRxTr`
`133`	`133`	`match rx.recv() {`
`134`	`134`	`Ok(_) => {`
`135`	`135`	`_counter.as_ref().fetch_add(1, Ordering::SeqCst);`
`136`		`- //print!("{} {}\r", _rx_i, i);`
	`136`	`+ //debug!("{} {}\r", _rx_i, i);`
`137`	`137`	`}`
`138`	`138`	`Err(_) => break 'A,`
`139`	`139`	`}`
`140`	`140`	`}`
`141`		`- println!("rx exit");`
	`141`	`+ debug!("rx exit");`
`142`	`142`	`});`
`143`	`143`	`let rt = get_runtime();`
`144`	`144`	`rt.block_on(async move {`
`@@ -148,7 +148,7 @@ fn test_presure_1_tx_async_1_rx_blocking<T: AsyncTxTrait<usize>, R: BlockingRxTr`
`148`	`148`	`_ => {}`
`149`	`149`	`}`
`150`	`150`	`}`
`151`		`- println!("tx exit");`
	`151`	`+ debug!("tx exit");`
`152`	`152`	`});`
`153`	`153`	`let _ = th.join();`
`154`	`154`	`assert_eq!(counter.as_ref().load(Ordering::Acquire), round);`
`@@ -178,12 +178,12 @@ fn test_presure_multi_tx_async_1_rx_blocking<R: BlockingRxTrait<usize>>(`
`178`	`178`	`match rx.recv() {`
`179`	`179`	`Ok(_) => {`
`180`	`180`	`_counter.as_ref().fetch_add(1, Ordering::SeqCst);`
`181`		`- //print!("{} {}\r", _rx_i, i);`
	`181`	`+ //debug!("{} {}\r", _rx_i, i);`
`182`	`182`	`}`
`183`	`183`	`Err(_) => break 'A,`
`184`	`184`	`}`
`185`	`185`	`}`
`186`		`- println!("rx exit");`
	`186`	`+ debug!("rx exit");`
`187`	`187`	`});`
`188`	`188`	`let rt = get_runtime();`
`189`	`189`	`rt.block_on(async move {`
`@@ -199,7 +199,7 @@ fn test_presure_multi_tx_async_1_rx_blocking<R: BlockingRxTrait<usize>>(`
`199`	`199`	`}`
`200`	`200`	`}`
`201`	`201`	`let _ = _noti_tx.send(_tx_i).await;`
`202`		`- println!("tx {} exit", _tx_i);`
	`202`	`+ debug!("tx {} exit", _tx_i);`
`203`	`203`	`});`
`204`	`204`	`}`
`205`	`205`	`drop(tx);`
`@@ -239,12 +239,12 @@ fn test_presure_multi_tx_async_multi_rx_blocking(`
`239`	`239`	`match _rx.recv() {`
`240`	`240`	`Ok(_) => {`
`241`	`241`	`_counter.as_ref().fetch_add(1, Ordering::SeqCst);`
`242`		`- //print!("{} {}\r", _rx_i, i);`
	`242`	`+ //debug!("{} {}\r", _rx_i, i);`
`243`	`243`	`}`
`244`	`244`	`Err(_) => break 'A,`
`245`	`245`	`}`
`246`	`246`	`}`
`247`		`- println!("rx {} exit", _rx_i);`
	`247`	`+ debug!("rx {} exit", _rx_i);`
`248`	`248`	`}));`
`249`	`249`	`}`
`250`	`250`	`drop(rx);`
`@@ -262,7 +262,7 @@ fn test_presure_multi_tx_async_multi_rx_blocking(`
`262`	`262`	`}`
`263`	`263`	`}`
`264`	`264`	`let _ = _noti_tx.send(_tx_i).await;`
`265`		`- println!("tx {} exit", _tx_i);`
	`265`	`+ debug!("tx {} exit", _tx_i);`
`266`	`266`	`});`
`267`	`267`	`}`
`268`	`268`	`drop(tx);`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ async fn test_basic_1_tx_blocking_1_rx_async<T: BlockingTxTrait<usize>, R: Async`
`38`	`38`	`for i in 0usize..12 {`
`39`	`39`	`match rx.recv().await {`
`40`	`40`	`Ok(j) => {`
`41`		`- println!("recv {}", i);`
	`41`	`+ debug!("recv {}", i);`
`42`	`42`	`assert_eq!(i, j);`
`43`	`43`	`}`
`44`	`44`	`Err(e) => {`
`@@ -48,7 +48,7 @@ async fn test_basic_1_tx_blocking_1_rx_async<T: BlockingTxTrait<usize>, R: Async`
`48`	`48`	`}`
`49`	`49`	`let res = rx.recv().await;`
`50`	`50`	`assert!(res.is_err());`
`51`		`- println!("rx close");`
	`51`	`+ debug!("rx close");`
`52`	`52`	`let _ = th.join();`
`53`	`53`	`}`
`54`	`54`
`@@ -134,7 +134,7 @@ async fn test_presure_tx_multi_blocking_1_rx_async<R: AsyncRxTrait<usize>>(`
`134`	`134`	`match _tx.send(i) {`
`135`	`135`	`Err(e) => panic!("{}", e),`
`136`	`136`	`_ => {`
`137`		`- //println!("tx {} {}", _tx_i, i);`
	`137`	`+ //debug!("tx {} {}", _tx_i, i);`
`138`	`138`	`}`
`139`	`139`	`}`
`140`	`140`	`}`
`@@ -147,7 +147,7 @@ async fn test_presure_tx_multi_blocking_1_rx_async<R: AsyncRxTrait<usize>>(`
`147`	`147`	`match rx.recv().await {`
`148`	`148`	`Ok(_i) => {`
`149`	`149`	`_counter.as_ref().fetch_add(1, Ordering::SeqCst);`
`150`		`- //println!("rx {} {}\r", _rx_i, _i);`
	`150`	`+ //debug!("rx {} {}\r", _rx_i, _i);`
`151`	`151`	`}`
`152`	`152`	`Err(_) => break 'A,`
`153`	`153`	`}`
`@@ -205,7 +205,7 @@ async fn test_presure_tx_multi_blocking_multi_rx_async(`
`205`	`205`	`}`
`206`	`206`	`}`
`207`	`207`	`}`
`208`		`- println!("tx {} exit", _tx_i);`
	`208`	`+ debug!("tx {} exit", _tx_i);`
`209`	`209`	`}));`
`210`	`210`	`}`
`211`	`211`	`drop(tx);`
`@@ -224,9 +224,9 @@ async fn test_presure_tx_multi_blocking_multi_rx_async(`
`224`	`224`	`Err(_) => break 'A,`
`225`	`225`	`}`
`226`	`226`	`}`
`227`		`- println!("rx {} exiting", _rx_i);`
	`227`	`+ debug!("rx {} exiting", _rx_i);`
`228`	`228`	`let _ = _noti_tx.send(_rx_i).await;`
`229`		`- println!("rx {} exit", _rx_i);`
	`229`	`+ debug!("rx {} exit", _rx_i);`
`230`	`230`	`});`
`231`	`231`	`}`
`232`	`232`	`drop(rx);`