Return named future type from async-time-mock-tokio sleep methods

Uses the async-time-mock-macros create_mock_future macro.

async-time-mock-macros/src/lib.rs

@@ -0,0 +1,4 @@
+mod create_mock_future;
+
+#[doc(hidden)]
+pub use pin_project_lite::pin_project;

async-time-mock-tokio/Cargo.toml

@@ -12,13 +12,14 @@ rust-version = "1.70"
 
 
 [dependencies]
-async-time-mock-core = {version = "0.1", path = "../async-time-mock-core", optional = true}
+async-time-mock-core = { version = "0.1", path = "../async-time-mock-core", optional = true }
+async-time-mock-macros = { version = "0.1", path = "../async-time-mock-macros" }
+futures-core = { version = "0.3", optional = true }
 pin-project = "1"
-tokio = {version = "1", features = ["time"]}
-futures-core = {version = "0.3", optional = true}
+tokio = { version = "1", features = ["time"] }
 
 [dev-dependencies]
-tokio = {version = "1", features = ["macros", "rt-multi-thread"]}
+tokio = { version = "1", features = ["macros", "rt-multi-thread"] }
 
 [features]
 default = ["stream"]

async-time-mock-tokio/src/lib.rs

@@ -2,16 +2,19 @@
 use std::future::Future;
 use std::time::{Duration, SystemTime};
 
+#[cfg(feature = "mock")]
+pub use async_time_mock_core as core;
+
 mod instant;
 use crate::interval::Interval;
 pub use instant::Instant;
 
-#[cfg(feature = "mock")]
-pub use async_time_mock_core as core;
-
 mod elapsed;
 mod interval;
+mod sleep;
 mod timeout;
+
+pub use sleep::Sleep;
 pub use timeout::Timeout;
 
 #[derive(Clone)]
@@ -59,26 +62,20 @@ impl MockableClock {
 		}
 	}
 
-	pub async fn sleep(&self, duration: Duration) -> TimeHandlerGuard {
+	pub fn sleep(&self, duration: Duration) -> Sleep {
 		use MockableClock::*;
 		match self {
-			Real => {
-				tokio::time::sleep(duration).await;
-				TimeHandlerGuard::Real
-			}
+			Real => tokio::time::sleep(duration).into(),
 			#[cfg(feature = "mock")]
-			Mock(registry) => registry.sleep(duration).await.into(),
+			Mock(registry) => registry.sleep(duration).into(),
 		}
 	}
 
-	pub async fn sleep_until(&self, until: Instant) -> TimeHandlerGuard {
+	pub fn sleep_until(&self, until: Instant) -> Sleep {
 		match (self, until) {
-			(MockableClock::Real, Instant::Real(until)) => {
-				tokio::time::sleep_until(until).await;
-				TimeHandlerGuard::Real
-			}
+			(MockableClock::Real, Instant::Real(until)) => tokio::time::sleep_until(until).into(),
 			#[cfg(feature = "mock")]
-			(MockableClock::Mock(registry), Instant::Mock(until)) => registry.sleep_until(until).await.into(),
+			(MockableClock::Mock(registry), Instant::Mock(until)) => registry.sleep_until(until).into(),
 			#[cfg(feature = "mock")]
 			_ => panic!("Clock and instant weren't compatible, both need to be either real or mocked"),
 		}

async-time-mock-tokio/src/sleep.rs

@@ -0,0 +1,13 @@
+use crate::TimeHandlerGuard;
+#[cfg(feature = "mock")]
+use async_time_mock_core::TimerListener;
+use async_time_mock_macros::create_mock_future;
+
+create_mock_future!(
+	Sleep,
+	TimeHandlerGuard,
+	tokio::time::Sleep,
+	TimerListener,
+	|()| TimeHandlerGuard::Real,
+	TimeHandlerGuard::from
+);