diff --git a/Cargo.toml b/Cargo.toml
index 535bcb82d..229cb6dce 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -116,6 +116,7 @@ codegen-units = 1
 [patch.crates-io]
 actix-web = { path = "." }
 actix-http = { path = "actix-http" }
+actix-http-test = { path = "test-server" }
 actix-web-codegen = { path = "actix-web-codegen" }
 actix-web-actors = { path = "actix-web-actors" }
 actix-session = { path = "actix-session" }
diff --git a/src/extract.rs b/src/extract.rs
index 9023ea49a..6d414fbcc 100644
--- a/src/extract.rs
+++ b/src/extract.rs
@@ -265,13 +265,12 @@ tuple_from_req!(TupleFromRequest10, (0, A), (1, B), (2, C), (3, D), (4, E), (5,
 #[cfg(test)]
 mod tests {
     use actix_http::http::header;
-    use actix_router::ResourceDef;
     use bytes::Bytes;
     use serde_derive::Deserialize;
 
     use super::*;
     use crate::test::{block_on, TestRequest};
-    use crate::types::{Form, FormConfig, Path, Query};
+    use crate::types::{Form, FormConfig};
 
     #[derive(Deserialize, Debug, PartialEq)]
     struct Info {
@@ -350,58 +349,4 @@ mod tests {
             block_on(Result::<Form<Info>, Error>::from_request(&req, &mut pl)).unwrap();
         assert!(r.is_err());
     }
-
-    #[derive(Deserialize)]
-    struct MyStruct {
-        key: String,
-        value: String,
-    }
-
-    #[derive(Deserialize)]
-    struct Id {
-        id: String,
-    }
-
-    #[derive(Deserialize)]
-    struct Test2 {
-        key: String,
-        value: u32,
-    }
-
-    #[test]
-    fn test_request_extract() {
-        let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
-
-        let resource = ResourceDef::new("/{key}/{value}/");
-        resource.match_path(req.match_info_mut());
-
-        let (req, mut pl) = req.into_parts();
-        let s = Path::<MyStruct>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.key, "name");
-        assert_eq!(s.value, "user1");
-
-        let s = Path::<(String, String)>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.0, "name");
-        assert_eq!(s.1, "user1");
-
-        let s = Query::<Id>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.id, "test");
-
-        let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
-        let resource = ResourceDef::new("/{key}/{value}/");
-        resource.match_path(req.match_info_mut());
-
-        let (req, mut pl) = req.into_parts();
-        let s = Path::<Test2>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.as_ref().key, "name");
-        assert_eq!(s.value, 32);
-
-        let s = Path::<(String, u8)>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(s.0, "name");
-        assert_eq!(s.1, 32);
-
-        let res = Path::<Vec<String>>::from_request(&req, &mut pl).unwrap();
-        assert_eq!(res[0], "name".to_owned());
-        assert_eq!(res[1], "32".to_owned());
-    }
 }
diff --git a/src/types/form.rs b/src/types/form.rs
index 249f33b3a..e8f78c496 100644
--- a/src/types/form.rs
+++ b/src/types/form.rs
@@ -331,10 +331,6 @@ mod tests {
 
     fn eq(err: UrlencodedError, other: UrlencodedError) -> bool {
         match err {
-            UrlencodedError::Chunked => match other {
-                UrlencodedError::Chunked => true,
-                _ => false,
-            },
             UrlencodedError::Overflow => match other {
                 UrlencodedError::Overflow => true,
                 _ => false,
diff --git a/src/types/path.rs b/src/types/path.rs
index 13a35d5ea..5f0a05af9 100644
--- a/src/types/path.rs
+++ b/src/types/path.rs
@@ -171,10 +171,25 @@ where
 #[cfg(test)]
 mod tests {
     use actix_router::ResourceDef;
+    use derive_more::Display;
+    use serde_derive::Deserialize;
 
     use super::*;
     use crate::test::{block_on, TestRequest};
 
+    #[derive(Deserialize, Debug, Display)]
+    #[display(fmt = "MyStruct({}, {})", key, value)]
+    struct MyStruct {
+        key: String,
+        value: String,
+    }
+
+    #[derive(Deserialize)]
+    struct Test2 {
+        key: String,
+        value: u32,
+    }
+
     #[test]
     fn test_extract_path_single() {
         let resource = ResourceDef::new("/{value}/");
@@ -184,6 +199,7 @@ mod tests {
 
         let (req, mut pl) = req.into_parts();
         assert_eq!(*Path::<i8>::from_request(&req, &mut pl).unwrap(), 32);
+        assert!(Path::<MyStruct>::from_request(&req, &mut pl).is_err());
     }
 
     #[test]
@@ -213,4 +229,46 @@ mod tests {
         let () = <()>::from_request(&req, &mut pl).unwrap();
     }
 
+    #[test]
+    fn test_request_extract() {
+        let mut req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+
+        let resource = ResourceDef::new("/{key}/{value}/");
+        resource.match_path(req.match_info_mut());
+
+        let (req, mut pl) = req.into_parts();
+        let mut s = Path::<MyStruct>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.key, "name");
+        assert_eq!(s.value, "user1");
+        s.value = "user2".to_string();
+        assert_eq!(s.value, "user2");
+        assert_eq!(
+            format!("{}, {:?}", s, s),
+            "MyStruct(name, user2), MyStruct { key: \"name\", value: \"user2\" }"
+        );
+        let s = s.into_inner();
+        assert_eq!(s.value, "user2");
+
+        let s = Path::<(String, String)>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, "user1");
+
+        let mut req = TestRequest::with_uri("/name/32/").to_srv_request();
+        let resource = ResourceDef::new("/{key}/{value}/");
+        resource.match_path(req.match_info_mut());
+
+        let (req, mut pl) = req.into_parts();
+        let s = Path::<Test2>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.as_ref().key, "name");
+        assert_eq!(s.value, 32);
+
+        let s = Path::<(String, u8)>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.0, "name");
+        assert_eq!(s.1, 32);
+
+        let res = Path::<Vec<String>>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(res[0], "name".to_owned());
+        assert_eq!(res[1], "32".to_owned());
+    }
+
 }
diff --git a/src/types/query.rs b/src/types/query.rs
index 596254be5..f9f545d61 100644
--- a/src/types/query.rs
+++ b/src/types/query.rs
@@ -133,3 +133,35 @@ where
             })
     }
 }
+
+#[cfg(test)]
+mod tests {
+    use derive_more::Display;
+    use serde_derive::Deserialize;
+
+    use super::*;
+    use crate::test::TestRequest;
+
+    #[derive(Deserialize, Debug, Display)]
+    struct Id {
+        id: String,
+    }
+
+    #[test]
+    fn test_request_extract() {
+        let req = TestRequest::with_uri("/name/user1/").to_srv_request();
+        let (req, mut pl) = req.into_parts();
+        assert!(Query::<Id>::from_request(&req, &mut pl).is_err());
+
+        let req = TestRequest::with_uri("/name/user1/?id=test").to_srv_request();
+        let (req, mut pl) = req.into_parts();
+
+        let mut s = Query::<Id>::from_request(&req, &mut pl).unwrap();
+        assert_eq!(s.id, "test");
+        assert_eq!(format!("{}, {:?}", s, s), "test, Id { id: \"test\" }");
+
+        s.id = "test1".to_string();
+        let s = s.into_inner();
+        assert_eq!(s.id, "test1");
+    }
+}