add some debug message to debug why restart doesn't work

seems like tracing::debug! doesn't show up. Use tracing::info! instead.

REVERT THIS COMMIT ONCE IT IS NO LONGER NEEDED!

Author: boquan-fang

dc/s2n-quic-dc/src/stream/testing.rs

@@ -56,6 +56,8 @@ pub fn bind_pair(
     ClientTokio<ClientProvider, NoopSubscriber>,
     ServerTokio<ServerProvider, NoopSubscriber>,
 ) {
+    tracing::info!("Binding pair!");
+
     let test_subscriber = NoopSubscriber {};
     let client = ClientTokio::<ClientProvider, NoopSubscriber>::builder()
         .with_default_protocol(protocol)
@@ -176,6 +178,7 @@ pub mod dcquic {
         }
 
         pub async fn bind(protocol: Protocol, addr: SocketAddr) -> Self {
+            tracing::info!("Bind function called.");
             Self::bind_with(protocol, addr, crate::testing::Pair::default()).await
         }
 
@@ -184,7 +187,9 @@ pub mod dcquic {
             addr: SocketAddr,
             pair: crate::testing::Pair,
         ) -> Self {
+            tracing::info!("Bind with function called.");
             let (client, server) = pair.build().await;
+            tracing::info!("Server client provider successfully built.");
             let (client, server) = bind_pair(protocol, addr, client, server);
             Self {
                 client,

dc/s2n-quic-dc/src/stream/tests/restart.rs

@@ -99,13 +99,18 @@ impl Harness {
 
     async fn run_one(&self, bidirectional: bool, sleep_before_shutdown: bool) {
         tracing::info!(bidirectional, sleep_before_shutdown);
+        tracing::info!("About to create context!");
         let context = Context::bind(self.protocol, "127.0.0.1:0".parse().unwrap()).await;
 
+        tracing::info!("Context created!");
+
         check_stream(&context, bidirectional, sleep_before_shutdown)
             .instrument(info_span!("first"))
             .await
             .unwrap();
 
+        tracing::info!("First check stream succeeded.");
+
         match self.drop {
             Side::Client => context.client.drop_state(),
             Side::Server => context.server.drop_state(),
@@ -115,9 +120,11 @@ impl Harness {
             }
         }
 
+        tracing::info!("Restart started!");
+
         // This might fail, we don't care. At least two streams should fail before we
         // manage to successfully establish after dropping state.
-        tracing::debug!(
+        tracing::info!(
             "initial: {:?}",
             tokio::time::timeout(
                 Duration::from_secs(2),
@@ -132,7 +139,7 @@ impl Harness {
 
         // This should enqueue a recovery handshake. This used to be something we'd *wait* for, but
         // now we just do that in the background; this should still fail.
-        tracing::debug!(
+        tracing::info!(
             "recovery handshake: {:?}",
             tokio::time::timeout(
                 Duration::from_secs(2),

dc/s2n-quic-dc/src/testing.rs

@@ -249,11 +249,14 @@ impl Pair {
     }
 
     pub async fn build(self) -> (client::Provider, server::Provider) {
+        tracing::info!("Build function called.");
         init_tracing();
 
         let tls_materials_provider = TestTlsProvider {};
         let test_event_subscriber = NoopSubscriber {};
 
+        tracing::info!("Building a server provider.");
+
         let server = self
             .server()
             .start(
@@ -270,6 +273,8 @@ impl Pair {
             .await
             .unwrap();
 
+        tracing::info!("Building a client provider.");
+
         let client = self
             .client()
             .start(