Chore: remove excess dependencies (#4)

* Deps: use `futures_core` over `futures` to minimize dependencies

This practically cuts the number of dependencies by half.

* Deps: use `futures-util` in test dependencies

* Chore: remove redundant use of `^` semver range

Cargo uses the `^` semver range by default.

* Chore: remove dependency on `tokio-test` macros

Cargo.toml

@@ -27,16 +27,13 @@ maintenance = { status = "actively-developed" }
 
 [dependencies]
 tokio = { version = "1", features = ["sync", "time"] }
-futures = "0.3"
+futures-core = { version = "0.3", default-features = false }
 
 [dev-dependencies]
+futures-util = { version = "0.3", default-features = false }
 tokio = { version = "1", features = ["test-util", "rt", "rt-multi-thread", "macros"] }
-tokio-test = "^0.4"
-loom = { version = "^0.4.0" }
-criterion = { version="^0.3.4", features = ["async_tokio", "html_reports"] }
-
-[target.'cfg(loom)'.dependencies]
-loom = { version = "^0.4.0", features = ["futures", "checkpoint"] }
+loom = { version = "0.5", features = ["futures", "checkpoint"] }
+criterion = { version = "0.3", features = ["async_tokio", "html_reports"] }
 
 [[test]]
 name = "tests"
@@ -45,7 +42,6 @@ name = "tests"
 name = "bench_channel_async"
 harness = false
 
-
 [[bench]]
 name = "bench_channel_sync"
 harness = false

src/bounded.rs

@@ -3,7 +3,7 @@ use crate::error::{ReceiveError, RequestError, RespondError, SendError};
 use tokio::sync::{mpsc, oneshot};
 use tokio::time::{timeout, Duration};
 
-use futures::Stream;
+use futures_core::Stream;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 

src/error.rs

@@ -1,6 +1,6 @@
 use std::error::Error;
 use std::fmt;
-use tokio::sync::mpsc::error::{RecvError as MpscRecvError, SendError as MpscSendError};
+use tokio::sync::mpsc::error::SendError as MpscSendError;
 use tokio::sync::oneshot;
 
 /// Error thrown when a [`RequestSender::send()`](crate::RequestSender::send()) or [`UnboundedRequestSender::send()`](crate::unbounded::UnboundedRequestSender::send())
@@ -51,13 +51,6 @@ pub enum ReceiveError {
     TimeoutError,
 }
 
-// Cannot test this due to private field in the tokio error implementation
-#[cfg(not(tarpaulin_include))]
-impl<T> From<MpscRecvError> for RequestError<T> {
-    fn from(_err: MpscRecvError) -> RequestError<T> {
-        RequestError::RecvError
-    }
-}
 impl<T> From<SendError<T>> for RequestError<T> {
     fn from(err: SendError<T>) -> RequestError<T> {
         RequestError::SendError(err.0)
@@ -104,10 +97,14 @@ impl<T> Error for RequestError<T> where T: fmt::Debug {}
 
 impl fmt::Display for ReceiveError {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(fmt, "{}", match self {
-            ReceiveError::RecvError => "receive channel closed",
-            ReceiveError::TimeoutError => "request timed out"
-        })
+        write!(
+            fmt,
+            "{}",
+            match self {
+                ReceiveError::RecvError => "receive channel closed",
+                ReceiveError::TimeoutError => "request timed out",
+            }
+        )
     }
 }
 

src/unbounded.rs

@@ -4,7 +4,7 @@ use crate::bounded::ResponseReceiver;
 use tokio::sync::{mpsc, oneshot};
 use tokio::time::Duration;
 
-use futures::Stream;
+use futures_core::Stream;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 

tests/loom_bounded.rs

@@ -1,7 +1,5 @@
 use loom::future::block_on;
 use loom::thread;
-use tokio_test::assert_err;
-use tokio_test::assert_ok;
 
 #[test]
 #[cfg(not(tarpaulin))]
@@ -11,15 +9,15 @@ fn closing_tx() {
 
         thread::spawn(move || {
             let res = block_on(tx.send(4));
-            assert_ok!(res);
+            assert!(res.is_ok());
             drop(tx);
         });
 
         let v = block_on(rx.recv());
-        assert_ok!(v);
+        assert!(v.is_ok());
 
         let v = block_on(rx.recv());
-        assert_err!(v);
+        assert!(v.is_err());
     })
 }
 
@@ -32,17 +30,16 @@ fn closing_tx_res() {
         thread::spawn(move || {
             let res = block_on(tx.send(5));
             let repl = block_on(res.unwrap().recv());
-            assert_ok!(repl);
-            assert_eq!(repl.unwrap(), 10);
+            assert_eq!(repl, Ok(10));
             drop(tx);
         });
 
         let v = block_on(rx.recv());
         let (req, responder) = v.unwrap();
         let v = responder.respond(req * 2);
-        assert_ok!(v);
+        assert!(v.is_ok());
 
         let v = block_on(rx.recv());
-        assert_err!(v);
+        assert!(v.is_err());
     })
 }