Clippy warnings (#305)

ntex-async-std/src/signals.rs

@@ -1,7 +1,7 @@
 use std::{cell::RefCell, future::Future, pin::Pin, rc::Rc, task::Context, task::Poll};
 
 thread_local! {
-    static SRUN: RefCell<bool> = RefCell::new(false);
+    static SRUN: RefCell<bool> = const { RefCell::new(false) };
     static SHANDLERS: Rc<RefCell<Vec<oneshot::Sender<Signal>>>> = Default::default();
 }
 

ntex-bytes/src/bytes.rs

@@ -4179,7 +4179,11 @@ mod tests {
     }
 
     #[test]
-    #[allow(clippy::len_zero)]
+    #[allow(
+        clippy::len_zero,
+        clippy::nonminimal_bool,
+        clippy::unnecessary_fallible_conversions
+    )]
     fn bytes() {
         let mut b = Bytes::from(LONG.to_vec());
         b.clear();
@@ -4226,6 +4230,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::unnecessary_fallible_conversions)]
     fn bytes_vec() {
         let bv = BytesVec::copy_from_slice(LONG);
         // SharedVec size is 32

ntex-bytes/src/string.rs

@@ -371,7 +371,7 @@ mod utf8 {
 
 #[cfg(test)]
 mod test {
-    use std::borrow::{Borrow, Cow, ToOwned};
+    use std::borrow::{Borrow, Cow};
     use std::collections::hash_map::DefaultHasher;
     use std::hash::{Hash, Hasher};
 

ntex-bytes/tests/test_buf.rs

@@ -1,4 +1,5 @@
 #![deny(warnings, rust_2018_idioms)]
+#![allow(clippy::unnecessary_mut_passed)]
 
 use ntex_bytes::{Buf, Bytes, BytesMut};
 

ntex-bytes/tests/test_bytes.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::op_ref, clippy::let_underscore_future)]
 use std::{borrow::Borrow, borrow::BorrowMut, task::Poll};
 
 use ntex_bytes::{Buf, BufMut, Bytes, BytesMut, BytesVec, Pool, PoolId, PoolRef};

ntex-connect/src/openssl.rs

@@ -124,7 +124,6 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ntex_service::ServiceFactory;
 
     #[ntex::test]
     async fn test_openssl_connect() {

ntex-connect/src/rustls.rs

@@ -126,11 +126,9 @@ impl<T: Address> Service<Connect<T>> for Connector<T> {
 
 #[cfg(test)]
 mod tests {
-    use std::sync::Arc;
     use tls_rustls::{OwnedTrustAnchor, RootCertStore};
 
     use super::*;
-    use ntex_service::ServiceFactory;
     use ntex_util::future::lazy;
 
     #[ntex::test]

ntex-http/src/map.rs

@@ -579,7 +579,7 @@ mod tests {
     }
 
     #[test]
-    #[allow(clippy::needless_borrow)]
+    #[allow(clippy::needless_borrow, clippy::needless_borrows_for_generic_args)]
     fn test_basics() {
         let m = HeaderMap::default();
         assert!(m.is_empty());

ntex-http/src/value.rs

@@ -85,6 +85,7 @@ impl HeaderValue {
         let mut i = 0;
         while i < bytes.len() {
             if !is_visible_ascii(bytes[i]) {
+                #[allow(clippy::out_of_bounds_indexing)]
                 ([] as [u8; 0])[0]; // Invalid header value
             }
             i += 1;

ntex-io/src/dispatcher.rs

@@ -1,4 +1,5 @@
 //! Framed transport dispatcher
+#![allow(clippy::let_underscore_future)]
 use std::{cell::Cell, future, pin::Pin, rc::Rc, task::Context, task::Poll};
 
 use ntex_bytes::Pool;
@@ -341,7 +342,7 @@ where
                     // call service
                     let shared = slf.shared.clone();
                     shared.inflight.set(shared.inflight.get() + 1);
-                    spawn(async move {
+                    let _ = spawn(async move {
                         let result = shared.service.call(item).await;
                         shared.handle_result(result, &shared.io);
                     });
@@ -365,7 +366,7 @@ where
                     // call service
                     let shared = slf.shared.clone();
                     shared.inflight.set(shared.inflight.get() + 1);
-                    spawn(async move {
+                    let _ = spawn(async move {
                         let result = shared.service.call(item).await;
                         shared.handle_result(result, &shared.io);
                     });
@@ -595,7 +596,7 @@ mod tests {
     use ntex_bytes::{Bytes, BytesMut, PoolId, PoolRef};
     use ntex_codec::BytesCodec;
     use ntex_service::ServiceCtx;
-    use ntex_util::{time::sleep, time::Millis, time::Seconds};
+    use ntex_util::{time::sleep, time::Millis};
 
     use super::*;
     use crate::{io::Flags, testing::IoTest, Io, IoRef, IoStream};

ntex-io/src/io.rs

@@ -932,7 +932,7 @@ mod tests {
     use ntex_codec::BytesCodec;
 
     use super::*;
-    use crate::{testing::IoTest, FilterLayer, Io, ReadBuf, WriteBuf};
+    use crate::{testing::IoTest, ReadBuf, WriteBuf};
 
     const BIN: &[u8] = b"GET /test HTTP/1\r\n\r\n";
     const TEXT: &str = "GET /test HTTP/1\r\n\r\n";

ntex-io/src/ioref.rs

@@ -119,8 +119,7 @@ impl IoRef {
             })
             // .with_write_buf() could return io::Error<Result<(), U::Error>>,
             // in that case mark io as failed
-            .map_or_else(
+            .unwrap_or_else(|err| {
-                |err| {
                 log::trace!(
                     "{}: Got io error while encoding, error: {:?}",
                     self.tag(),
@@ -128,9 +127,7 @@ impl IoRef {
                 );
                 self.0.io_stopped(Some(err));
                 Ok(())
-                },
+            })
-                |item| item,
-            )
         } else {
             log::trace!("{}: Io is closed/closing, skip frame encoding", self.tag());
             Ok(())
@@ -318,7 +315,7 @@ mod tests {
     use ntex_util::time::{sleep, Millis};
 
     use super::*;
-    use crate::{testing::IoTest, FilterLayer, Io, ReadBuf, WriteBuf};
+    use crate::{testing::IoTest, FilterLayer, Io, ReadBuf};
 
     const BIN: &[u8] = b"GET /test HTTP/1\r\n\r\n";
     const TEXT: &str = "GET /test HTTP/1\r\n\r\n";

ntex-io/src/testing.rs

@@ -1,4 +1,5 @@
 //! utilities and helpers for testing
+#![allow(clippy::let_underscore_future)]
 use std::future::{poll_fn, Future};
 use std::sync::{Arc, Mutex};
 use std::task::{ready, Context, Poll, Waker};
@@ -355,11 +356,11 @@ impl IoStream for IoTest {
     fn start(self, read: ReadContext, write: WriteContext) -> Option<Box<dyn Handle>> {
         let io = Rc::new(self);
 
-        ntex_util::spawn(ReadTask {
+        let _ = ntex_util::spawn(ReadTask {
             io: io.clone(),
             state: read,
         });
-        ntex_util::spawn(WriteTask {
+        let _ = ntex_util::spawn(WriteTask {
             io: io.clone(),
             state: write,
             st: IoWriteState::Processing(None),

ntex-io/src/timer.rs

@@ -127,7 +127,8 @@ pub(crate) fn register(timeout: Seconds, io: &IoRef) -> TimerHandle {
         if !timer.running.get() {
             timer.running.set(true);
 
-            spawn(async move {
+            #[allow(clippy::let_underscore_future)]
+            let _ = spawn(async move {
                 let guard = TimerGuard;
                 loop {
                     sleep(SEC).await;

ntex-router/src/de.rs

@@ -491,11 +491,10 @@ impl<'de> de::VariantAccess<'de> for UnitVariant {
 
 #[cfg(test)]
 mod tests {
-    use serde::de;
     use serde_derive::Deserialize;
 
     use super::*;
-    use crate::path::{Path, PathItem};
+    use crate::path::PathItem;
 
     #[derive(Deserialize)]
     struct MyStruct {

ntex-router/src/resource.rs

@@ -754,6 +754,7 @@ mod tests {
     }
 
     #[test]
+    #[allow(clippy::needless_borrows_for_generic_args)]
     fn test_static_tail() {
         let re = ResourceDef::new("/*".to_string());
         let tree = Tree::new(&re, 1);

ntex-rt/src/arbiter.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::let_underscore_future)]
 use std::any::{Any, TypeId};
 use std::sync::atomic::{AtomicUsize, Ordering};
 use std::task::{Context, Poll};
@@ -9,7 +10,7 @@ use futures_core::stream::Stream;
 use crate::system::System;
 
 thread_local!(
-    static ADDR: RefCell<Option<Arbiter>> = RefCell::new(None);
+    static ADDR: RefCell<Option<Arbiter>> = const { RefCell::new(None) };
     static STORAGE: RefCell<HashMap<TypeId, Box<dyn Any>>> = RefCell::new(HashMap::new());
 );
 
@@ -103,7 +104,7 @@ impl Arbiter {
 
                 crate::block_on(async move {
                     // start arbiter controller
-                    crate::spawn(ArbiterController {
+                    let _ = crate::spawn(ArbiterController {
                         stop: Some(stop),
                         rx: Box::pin(arb_rx),
                     });
@@ -268,7 +269,7 @@ impl Future for ArbiterController {
                         return Poll::Ready(());
                     }
                     ArbiterCommand::Execute(fut) => {
-                        crate::spawn(fut);
+                        let _ = crate::spawn(fut);
                     }
                     ArbiterCommand::ExecuteFn(f) => {
                         f.call_box();

ntex-rt/src/builder.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::let_underscore_future)]
 use std::{cell::RefCell, future::Future, io, rc::Rc};
 
 use async_channel::unbounded;
@@ -159,8 +160,8 @@ where
     let result = Rc::new(RefCell::new(None));
     let result_inner = result.clone();
     crate::block_on(Box::pin(async move {
-        crate::spawn(arb);
+        let _ = crate::spawn(arb);
-        crate::spawn(arb_controller);
+        let _ = crate::spawn(arb_controller);
         if let Err(e) = f() {
             *result_inner.borrow_mut() = Some(Err(e));
         } else {

ntex-rt/src/system.rs

@@ -16,7 +16,7 @@ pub struct System {
 }
 
 thread_local!(
-    static CURRENT: RefCell<Option<System>> = RefCell::new(None);
+    static CURRENT: RefCell<Option<System>> = const { RefCell::new(None) };
 );
 
 impl System {

ntex-service/src/apply.rs

@@ -203,7 +203,7 @@ mod tests {
     use std::task::Poll;
 
     use super::*;
-    use crate::{chain, chain_factory, Service, ServiceCtx};
+    use crate::{chain, chain_factory};
 
     #[derive(Clone, Debug)]
     struct Srv;

ntex-service/src/ctx.rs

@@ -193,10 +193,10 @@ impl<'a, S> fmt::Debug for ServiceCtx<'a, S> {
 
 #[cfg(test)]
 mod tests {
-    use ntex_util::future::lazy;
+    use std::task::Context;
-    use ntex_util::{channel::condition, time};
+    use std::{cell::Cell, cell::RefCell};
-    use std::task::{Context, Poll};
+
-    use std::{cell::Cell, cell::RefCell, future::poll_fn, rc::Rc};
+    use ntex_util::{channel::condition, future::lazy, time};
 
     use super::*;
     use crate::Pipeline;
@@ -218,6 +218,7 @@ mod tests {
             ctx: ServiceCtx<'_, Self>,
         ) -> Result<Self::Response, Self::Error> {
             format!("{:?}", ctx);
+            #[allow(clippy::clone_on_copy)]
             let _ = ctx.clone();
             Ok(req)
         }

ntex-service/src/fn_service.rs

@@ -389,7 +389,7 @@ mod tests {
     use std::task::Poll;
 
     use super::*;
-    use crate::{Pipeline, ServiceFactory};
+    use crate::Pipeline;
 
     #[ntex::test]
     async fn test_fn_service() {

ntex-service/src/fn_shutdown.rs

@@ -72,7 +72,7 @@ where
 #[cfg(test)]
 mod tests {
     use ntex_util::future::lazy;
-    use std::{rc::Rc, task::Poll};
+    use std::rc::Rc;
 
     use crate::{chain, fn_service, Pipeline};
 

ntex-service/src/map_config.rs

@@ -119,7 +119,7 @@ mod tests {
     use std::{cell::Cell, rc::Rc};
 
     use super::*;
-    use crate::{fn_service, ServiceFactory};
+    use crate::fn_service;
 
     #[ntex::test]
     async fn test_map_config() {

ntex-service/src/map_err.rs

@@ -161,7 +161,7 @@ mod tests {
     use ntex_util::future::{lazy, Ready};
 
     use super::*;
-    use crate::{fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
+    use crate::{fn_factory, Pipeline};
 
     #[derive(Debug, Clone)]
     struct Srv(bool);

ntex-service/src/middleware.rs

@@ -187,7 +187,7 @@ mod tests {
     use std::task::{Context, Poll};
 
     use super::*;
-    use crate::{fn_service, Pipeline, Service, ServiceCtx, ServiceFactory};
+    use crate::{fn_service, Pipeline, ServiceCtx};
 
     #[derive(Debug, Clone)]
     struct Tr<R>(PhantomData<R>);

ntex-tokio/src/signals.rs

@@ -6,7 +6,7 @@ use tokio::sync::oneshot;
 use tokio::task::spawn_local;
 
 thread_local! {
-    static SRUN: RefCell<bool> = RefCell::new(false);
+    static SRUN: RefCell<bool> = const { RefCell::new(false) };
     static SHANDLERS: Rc<RefCell<Vec<oneshot::Sender<Signal>>>> = Default::default();
 }
 

ntex-util/src/channel/mpsc.rs

@@ -252,8 +252,7 @@ impl<T> SendError<T> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{future::lazy, future::stream_recv, Stream};
+    use crate::{future::lazy, future::stream_recv};
-    use futures_sink::Sink;
 
     #[ntex_macros::rt_test2]
     async fn test_mpsc() {

ntex-util/src/services/buffer.rs

@@ -287,8 +287,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Pipeline, ServiceFactory};
-    use std::{rc::Rc, task::Context, task::Poll, time::Duration};
+    use std::{rc::Rc, time::Duration};
 
     use super::*;
     use crate::future::lazy;

ntex-util/src/services/extensions.rs

@@ -1,4 +1,4 @@
-use std::{any::Any, any::TypeId, fmt, iter::Extend};
+use std::{any::Any, any::TypeId, fmt};
 
 #[derive(Default)]
 /// A type map of request extensions.

ntex-util/src/services/inflight.rs

@@ -90,8 +90,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Pipeline, ServiceFactory};
-    use std::{cell::RefCell, task::Poll, time::Duration};
+    use std::{cell::RefCell, time::Duration};
 
     use super::*;
     use crate::{channel::oneshot, future::lazy};

ntex-util/src/services/keepalive.rs

@@ -138,8 +138,6 @@ where
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::ServiceFactory;
-
     use super::*;
     use crate::future::lazy;
 

ntex-util/src/services/onerequest.rs

@@ -81,8 +81,8 @@ where
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceCtx, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Pipeline, ServiceFactory};
-    use std::{cell::RefCell, task::Poll, time::Duration};
+    use std::{cell::RefCell, time::Duration};
 
     use super::*;
     use crate::{channel::oneshot, future::lazy};

ntex-util/src/services/timeout.rs

@@ -147,9 +147,9 @@ where
 
 #[cfg(test)]
 mod tests {
-    use std::{fmt, time::Duration};
+    use std::time::Duration;
 
-    use ntex_service::{apply, fn_factory, Pipeline, Service, ServiceFactory};
+    use ntex_service::{apply, fn_factory, Pipeline, ServiceFactory};
 
     use super::*;
     use crate::future::lazy;

ntex-util/src/services/variant.rs

@@ -232,8 +232,7 @@ variant_impl_and!(VariantFactory7, VariantFactory8, V8, V8R, v8, (V2, V3, V4, V5
 
 #[cfg(test)]
 mod tests {
-    use ntex_service::{fn_factory, Service, ServiceFactory};
+    use ntex_service::fn_factory;
-    use std::task::{Context, Poll};
 
     use super::*;
     use crate::future::lazy;

ntex-util/src/time/mod.rs

@@ -339,6 +339,7 @@ impl crate::Stream for Interval {
 }
 
 #[cfg(test)]
+#[allow(clippy::let_underscore_future)]
 mod tests {
     use futures_util::StreamExt;
     use std::time;

ntex-util/src/time/wheel.rs

@@ -1,7 +1,7 @@
 //! Time wheel based timer service.
 //!
 //! Inspired by linux kernel timers system
-#![allow(arithmetic_overflow)]
+#![allow(arithmetic_overflow, clippy::let_underscore_future)]
 use std::cell::{Cell, RefCell};
 use std::time::{Duration, Instant, SystemTime};
 use std::{cmp::max, future::Future, mem, pin::Pin, rc::Rc, task, task::Poll};
@@ -611,7 +611,7 @@ impl TimerDriver {
         timer.inner.borrow_mut().driver_sleep =
             Delay::new(Duration::from_millis(timer.next_expiry_ms()));
 
-        crate::spawn(TimerDriver(timer));
+        let _ = crate::spawn(TimerDriver(timer));
     }
 }
 
@@ -676,7 +676,7 @@ impl LowresTimerDriver {
         timer.flags.set(flags);
         timer.inner.borrow_mut().lowres_driver_sleep = Delay::new(LOWRES_RESOLUTION);
 
-        crate::spawn(LowresTimerDriver(timer));
+        let _ = crate::spawn(LowresTimerDriver(timer));
     }
 }
 

ntex/src/http/client/pool.rs

@@ -388,8 +388,9 @@ where
 }
 
 pin_project_lite::pin_project! {
-    struct OpenConnection<T: Service<Connect>>
+    struct OpenConnection<T>
-    where T: 'static
+    where T: Service<Connect>,
+          T: 'static
     {
         key: Key,
         #[pin]
@@ -610,11 +611,9 @@ impl Drop for Acquired {
 
 #[cfg(test)]
 mod tests {
-    use std::{cell::RefCell, rc::Rc};
-
     use super::*;
     use crate::time::{sleep, Millis};
-    use crate::{http::Uri, io as nio, service::fn_service, testing::Io, util::lazy};
+    use crate::{io as nio, service::fn_service, testing::Io, util::lazy};
 
     #[crate::rt_test]
     async fn test_basics() {

ntex/src/http/client/request.rs

@@ -583,6 +583,7 @@ mod tests {
     }
 
     #[crate::rt_test]
+    #[allow(clippy::let_underscore_future)]
     async fn test_basics() {
         let mut req = Client::new()
             .put("/")

ntex/src/http/error.rs

@@ -238,8 +238,7 @@ impl From<BlockingError<io::Error>> for PayloadError {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use ntex_http::{Error as HttpError, StatusCode};
+    use ntex_http::Error as HttpError;
-    use std::io;
 
     #[test]
     fn test_into_response() {

ntex/src/http/h1/codec.rs

@@ -197,8 +197,8 @@ impl Encoder for Codec {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::{h1::PayloadItem, HttpMessage, Method};
+    use crate::http::{h1::PayloadItem, HttpMessage};
-    use crate::util::{Bytes, BytesMut};
+    use crate::util::Bytes;
 
     #[test]
     fn test_http_request_chunked_payload_and_next_message() {

ntex/src/http/h1/decoder.rs

@@ -740,9 +740,8 @@ fn uninit_array<T, const LEN: usize>() -> [mem::MaybeUninit<T>; LEN] {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::header::{HeaderName, SET_COOKIE};
+    use crate::http::header::SET_COOKIE;
-    use crate::http::{HttpMessage, Method, Version};
+    use crate::http::HttpMessage;
-    use crate::util::{Bytes, BytesMut};
 
     impl PayloadType {
         fn unwrap(self) -> PayloadDecoder {

ntex/src/http/h1/dispatcher.rs

@@ -838,19 +838,19 @@ where
 #[cfg(test)]
 mod tests {
     use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-    use std::{cell::Cell, future::poll_fn, future::Future, io, sync::Arc};
+    use std::{cell::Cell, future::poll_fn, future::Future, sync::Arc};
 
     use ntex_h2::Config;
     use rand::Rng;
 
     use super::*;
-    use crate::http::config::{DispatcherConfig, ServiceConfig};
+    use crate::http::config::ServiceConfig;
     use crate::http::h1::{ClientCodec, DefaultControlService};
-    use crate::http::{body, Request, ResponseHead, StatusCode};
+    use crate::http::{body, ResponseHead, StatusCode};
     use crate::io::{self as nio, Base};
     use crate::service::{fn_service, IntoService};
     use crate::util::{lazy, stream_recv, Bytes, BytesMut};
-    use crate::{codec::Decoder, testing::Io, time::sleep, time::Millis, time::Seconds};
+    use crate::{codec::Decoder, testing::Io, time::sleep, time::Millis};
 
     const BUFFER_SIZE: usize = 32_768;
 

ntex/src/http/h1/service.rs

@@ -83,8 +83,6 @@ mod openssl {
 
 #[cfg(feature = "rustls")]
 mod rustls {
-    use std::fmt;
-
     use ntex_tls::rustls::{TlsAcceptor, TlsServerFilter};
     use tls_rustls::ServerConfig;
 

ntex/src/http/response.rs

@@ -808,8 +808,7 @@ impl From<BytesMut> for Response {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::body::Body;
+    use crate::http::header::{CONTENT_TYPE, COOKIE};
-    use crate::http::header::{HeaderValue, CONTENT_TYPE, COOKIE};
 
     #[test]
     fn test_debug() {

ntex/src/server/accept.rs

@@ -6,7 +6,7 @@ use polling::{Event, Events, Poller};
 use crate::{rt::System, time::sleep, time::Millis, util::Either};
 
 use super::socket::{Listener, SocketAddr, Stream};
-use super::worker::{WorkerMessage, WorkerClient, WorkerManagerCmd, WorkerManagerNotifier};
+use super::worker::{WorkerClient, WorkerManagerCmd, WorkerManagerNotifier, WorkerMessage};
 use super::{Server, ServerStatus, Token};
 
 const EXIT_TIMEOUT: Duration = Duration::from_millis(100);
@@ -26,7 +26,10 @@ struct ServerSocketInfo {
 pub(super) struct AcceptNotify(Arc<Poller>, mpsc::Sender<WorkerManagerCmd<Stream>>);
 
 impl AcceptNotify {
-    pub(super) fn new(waker: Arc<Poller>, tx: mpsc::Sender<WorkerManagerCmd<Stream>>) -> Self {
+    pub(super) fn new(
+        waker: Arc<Poller>,
+        tx: mpsc::Sender<WorkerManagerCmd<Stream>>,
+    ) -> Self {
         AcceptNotify(waker, tx)
     }
 }
@@ -44,7 +47,11 @@ impl WorkerManagerNotifier<Stream> for AcceptNotify {
 
 pub(super) struct AcceptLoop {
     notify: AcceptNotify,
-    inner: Option<(mpsc::Receiver<WorkerManagerCmd<Stream>>, Arc<Poller>, Server)>,
+    inner: Option<(
+        mpsc::Receiver<WorkerManagerCmd<Stream>>,
+        Arc<Poller>,
+        Server,
+    )>,
     status_handler: Option<Box<dyn FnMut(ServerStatus) + Send>>,
 }
 

ntex/src/server/builder.rs

@@ -13,8 +13,8 @@ use super::config::{
     Config, ConfigWrapper, ConfiguredService, ServiceConfig, ServiceRuntime,
 };
 use super::service::{Factory, InternalServiceFactory};
-use super::worker::{self, WorkerManagerCmd, Worker, WorkerAvailability, WorkerClient};
+use super::worker::{self, Worker, WorkerAvailability, WorkerClient, WorkerManagerCmd};
-use super::{socket::Listener, Server, ServerCommand, ServerStatus, Token, socket};
+use super::{socket, socket::Listener, Server, ServerCommand, ServerStatus, Token};
 
 const STOP_DELAY: Millis = Millis(300);
 
@@ -381,7 +381,11 @@ impl ServerBuilder {
         }
     }
 
-    fn start_worker(&self, idx: usize, notify: AcceptNotify) -> WorkerClient<socket::Stream> {
+    fn start_worker(
+        &self,
+        idx: usize,
+        notify: AcceptNotify,
+    ) -> WorkerClient<socket::Stream> {
         let avail = WorkerAvailability::new(Box::new(notify));
         let services: Vec<Box<dyn InternalServiceFactory<socket::Stream>>> =
             self.services.iter().map(|v| v.clone_factory()).collect();

ntex/src/server/config.rs

@@ -185,7 +185,9 @@ impl InternalServiceFactory<Stream> for ConfiguredService {
         })
     }
 
-    fn create(&self) -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<Stream>)>, ()>> {
+    fn create(
+        &self,
+    ) -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<Stream>)>, ()>> {
         // configure services
         let rt = ServiceRuntime::new(self.topics.clone());
         let cfg_fut = self.rt.configure(ServiceRuntime(rt.0.clone()));
@@ -387,7 +389,8 @@ struct ServiceFactory<T> {
     pool: PoolId,
 }
 
-impl<T> service::ServiceFactory<(Option<CounterGuard>, ServerMessage<Stream>)> for ServiceFactory<T>
+impl<T> service::ServiceFactory<(Option<CounterGuard>, ServerMessage<Stream>)>
+    for ServiceFactory<T>
 where
     T: service::ServiceFactory<Io>,
     T::Service: 'static,

ntex/src/server/service.rs

@@ -31,7 +31,8 @@ pub trait InternalServiceFactory<T>: Send {
 
     fn clone_factory(&self) -> Box<dyn InternalServiceFactory<T>>;
 
-    fn create(&self) -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<T>)>, ()>>;
+    fn create(&self)
+        -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<T>)>, ()>>;
 }
 
 pub type BoxedServerService<T> =
@@ -154,7 +155,9 @@ where
         })
     }
 
-    fn create(&self) -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<Stream>)>, ()>> {
+    fn create(
+        &self,
+    ) -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<Stream>)>, ()>> {
         let token = self.token;
         let tag = self.tag;
         let cfg = Config::default();
@@ -186,7 +189,9 @@ impl<T> InternalServiceFactory<T> for Box<dyn InternalServiceFactory<T>> {
         self.as_ref().clone_factory()
     }
 
-    fn create(&self) -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<T>)>, ()>> {
+    fn create(
+        &self,
+    ) -> BoxFuture<'static, Result<Vec<(Token, BoxedServerService<T>)>, ()>> {
         self.as_ref().create()
     }
 }

ntex/src/server/worker.rs

@@ -1,16 +1,16 @@
 use std::sync::atomic::{AtomicBool, AtomicUsize, Ordering};
-use std::{fmt, future::Future, pin::Pin, sync::Arc, task::Context, task::Poll};
 use std::sync::mpsc;
+use std::{fmt, future::Future, pin::Pin, sync::Arc, task::Context, task::Poll};
 
 use async_channel::{unbounded, Receiver, Sender};
 
 use crate::rt::{spawn, Arbiter};
 use crate::service::Pipeline;
-use ntex_util::time::Millis;
 use crate::time::{sleep, Sleep};
 use crate::util::{
     join_all, ready, select, stream_recv, BoxFuture, Either, Stream as FutStream,
 };
+use ntex_util::time::Millis;
 
 use super::service::{BoxedServerService, InternalServiceFactory, ServerMessage};
 use super::{counter::Counter, Token};
@@ -378,7 +378,8 @@ enum WorkerState<T> {
 }
 
 impl<T> Future for Worker<T>
-where T: 'static + Send
+where
+    T: 'static + Send,
 {
     type Output = ();
 
@@ -548,7 +549,7 @@ where T: 'static + Send
 
 #[cfg(test)]
 mod tests {
-    use std::sync::{Arc, Mutex};
+    use std::sync::Mutex;
 
     use super::*;
     use crate::io::Io;
@@ -625,8 +626,10 @@ mod tests {
         let (sync_tx, _sync_rx) = std::sync::mpsc::channel();
         let poll = Arc::new(polling::Poller::new().unwrap());
         let waker = poll.clone();
-        let avail =
+        let avail = WorkerAvailability::new(Box::new(AcceptNotify::new(
-            WorkerAvailability::new(Box::new(AcceptNotify::new(waker.clone(), sync_tx.clone())));
+            waker.clone(),
+            sync_tx.clone(),
+        )));
 
         let st = Arc::new(Mutex::new(St::Pending));
         let counter = Arc::new(Mutex::new(0));
@@ -703,7 +706,8 @@ mod tests {
         // force shutdown
         let (_tx1, rx1) = unbounded();
         let (tx2, rx2) = unbounded();
-        let avail = WorkerAvailability::new(Box::new(AcceptNotify::new(waker, sync_tx.clone())));
+        let avail =
+            WorkerAvailability::new(Box::new(AcceptNotify::new(waker, sync_tx.clone())));
         let f = SrvFactory {
             st: st.clone(),
             counter: counter.clone(),

ntex/src/web/app.rs

@@ -597,10 +597,7 @@ mod tests {
     use crate::service::fn_service;
     use crate::util::{Bytes, Ready};
     use crate::web::test::{call_service, init_service, read_body, TestRequest};
-    use crate::web::{
+    use crate::web::{self, middleware::DefaultHeaders, HttpRequest, HttpResponse};
-        self, middleware::DefaultHeaders, DefaultError, HttpRequest, HttpResponse,
-        WebRequest,
-    };
 
     #[crate::rt_test]
     async fn test_default_resource() {

ntex/src/web/error.rs

@@ -681,7 +681,6 @@ mod tests {
     use super::*;
     use crate::http::client::error::{ConnectError, SendRequestError};
     use crate::web::test::TestRequest;
-    use crate::web::DefaultError;
 
     #[test]
     fn test_into_error() {

ntex/src/web/guard.rs

@@ -414,7 +414,6 @@ impl Guard for HostGuard {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::{header, Method};
     use crate::web::test::TestRequest;
 
     #[test]

ntex/src/web/middleware/defaultheaders.rs

@@ -140,10 +140,8 @@ where
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::header::CONTENT_TYPE;
     use crate::service::{IntoService, Pipeline};
     use crate::util::lazy;
-    use crate::web::request::WebRequest;
     use crate::web::test::{ok_service, TestRequest};
     use crate::web::{DefaultError, Error, HttpResponse};
 

ntex/src/web/middleware/logger.rs

@@ -417,7 +417,7 @@ impl<'a> fmt::Display for FormatDisplay<'a> {
 mod tests {
     use super::*;
     use crate::http::{header, StatusCode};
-    use crate::service::{IntoService, Middleware, Pipeline};
+    use crate::service::{IntoService, Pipeline};
     use crate::util::lazy;
     use crate::web::test::{self, TestRequest};
     use crate::web::{DefaultError, Error};

ntex/src/web/responder.rs

@@ -307,10 +307,10 @@ where
 pub(crate) mod tests {
     use super::*;
     use crate::http::body::{Body, ResponseBody};
-    use crate::http::header::{HeaderValue, CONTENT_TYPE};
+    use crate::http::header::CONTENT_TYPE;
-    use crate::http::{Response as HttpResponse, StatusCode};
+    use crate::http::Response as HttpResponse;
+    use crate::web;
     use crate::web::test::{init_service, TestRequest};
-    use crate::{util::Bytes, util::BytesMut, web};
 
     fn responder<T: Responder<DefaultError>>(responder: T) -> impl Responder<DefaultError> {
         responder

ntex/src/web/test.rs

@@ -282,8 +282,8 @@ pub async fn respond_to<T: Responder<DefaultError>>(
 ///     }
 /// }
 ///
-/// #[test]
+/// #[ntex::test]
-/// fn test_index() {
+/// async fn test_index() {
 ///     let req = test::TestRequest::with_header("content-type", "text/plain")
 ///         .to_http_request();
 ///
@@ -972,9 +972,8 @@ mod tests {
     use std::convert::Infallible;
 
     use super::*;
-    use crate::http::header;
+    use crate::http::{header, HttpMessage};
-    use crate::http::HttpMessage;
+    use crate::web::{self, App};
-    use crate::web::{self, App, HttpResponse};
 
     #[crate::rt_test]
     async fn test_basics() {

ntex/src/web/types/form.rs

@@ -333,7 +333,7 @@ mod tests {
     use serde::{Deserialize, Serialize};
 
     use super::*;
-    use crate::http::header::{HeaderValue, CONTENT_TYPE};
+    use crate::http::header::HeaderValue;
     use crate::util::Bytes;
     use crate::web::test::{from_request, respond_to, TestRequest};
 

ntex/src/web/types/payload.rs

@@ -405,8 +405,6 @@ impl Future for HttpMessageBody {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::header;
-    use crate::util::Bytes;
     use crate::web::test::{from_request, TestRequest};
 
     #[crate::rt_test]

ntex/src/ws/client.rs

@@ -905,6 +905,7 @@ mod tests {
     }
 
     #[crate::rt_test]
+    #[allow(clippy::let_underscore_future)]
     async fn bearer_auth() {
         let client = WsClient::build("http://localhost")
             .bearer_auth("someS3cr3tAutht0k3n")

ntex/src/ws/frame.rs

@@ -217,7 +217,6 @@ impl Parser {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::util::Bytes;
 
     struct F {
         finished: bool,

ntex/src/ws/handshake.rs

@@ -83,7 +83,7 @@ pub fn handshake_response(req: &RequestHead) -> ResponseBuilder {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::http::{error::ResponseError, header, test::TestRequest, Method};
+    use crate::http::{error::ResponseError, test::TestRequest};
 
     #[test]
     fn test_handshake() {

ntex/tests/connect.rs

@@ -81,9 +81,9 @@ async fn test_openssl_string() {
     let tcp = std::net::TcpListener::bind("127.0.0.1:0").unwrap();
     let local_addr = tcp.local_addr().unwrap();
 
-    let tcp = Some(tcp);
+    let mut tcp = Some(tcp);
     let srv = build_test_server(move |srv| {
-        srv.listen("test", tcp.unwrap(), |_| {
+        srv.listen("test", tcp.take().unwrap(), |_| {
             chain_factory(
                 fn_service(|io: Io<_>| async move {
                     let res = io.read_ready().await;

ntex/tests/http_server.rs

@@ -103,7 +103,7 @@ async fn test_expect_continue() {
 
 #[ntex::test]
 async fn test_chunked_payload() {
-    let chunk_sizes = vec![32768, 32, 32768];
+    let chunk_sizes = [32768, 32, 32768];
     let total_size: usize = chunk_sizes.iter().sum();
 
     let srv = test_server(|| {

ntex/tests/server.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::let_underscore_future)]
 use std::sync::atomic::{AtomicUsize, Ordering::Relaxed};
 use std::{io, io::Read, net, sync::mpsc, sync::Arc, thread, time};
 

ntex/tests/web_httpserver.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::let_underscore_future)]
 use std::{sync::mpsc, thread, time::Duration};
 
 #[cfg(feature = "openssl")]