diff --git a/src/de_impl.rs b/src/de_impl.rs
index b89df8d..eab52cc 100644
--- a/src/de_impl.rs
+++ b/src/de_impl.rs
@@ -416,9 +416,10 @@ impl<'de> de::Visitor<'de> for DeserializeStringWithVisitor {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use serde::Deserialize;
+
     mod as_string_tests {
         use super::*;
-        use serde::Deserialize;
 
         #[derive(Debug, PartialEq, Deserialize)]
         struct TestStrStruct {
@@ -427,7 +428,7 @@ mod tests {
         }
 
         #[test]
-        fn test_as_str_with_string() {
+        fn test_as_string_with_string() {
             let json = r#"{"field": "Hello"}"#;
             let deserialized: TestStrStruct = serde_json::from_str(json).unwrap();
             assert_eq!(
@@ -439,7 +440,7 @@ mod tests {
         }
 
         #[test]
-        fn test_as_str_with_null() {
+        fn test_as_string_with_null() {
             let json = r#"{"field": null}"#;
             let deserialized: TestStrStruct = serde_json::from_str(json).unwrap();
             assert_eq!(
@@ -451,7 +452,7 @@ mod tests {
         }
 
         #[test]
-        fn test_as_str_with_number() {
+        fn test_as_string_with_number() {
             let json = r#"{"field": 123}"#;
             let deserialized: TestStrStruct = serde_json::from_str(json).unwrap();
             assert_eq!(
@@ -461,108 +462,140 @@ mod tests {
                 }
             );
         }
+
+        #[test]
+        fn test_as_string_with_boolean() {
+            let json = r#"{"field": true}"#;
+            let deserialized: TestStrStruct = serde_json::from_str(json).unwrap();
+            assert_eq!(
+                deserialized,
+                TestStrStruct {
+                    field: "true".to_owned()
+                }
+            );
+        }
+
+        #[test]
+        fn test_as_string_with_empty_string() {
+            let json = r#"{"field": ""}"#;
+            let deserialized: TestStrStruct = serde_json::from_str(json).unwrap();
+            assert_eq!(
+                deserialized,
+                TestStrStruct {
+                    field: "".to_owned()
+                }
+            );
+        }
     }
 
     mod as_bool_tests {
         use super::*;
-        use serde::Deserialize;
 
         #[derive(Debug, PartialEq, Deserialize)]
-        struct TestStruct {
+        struct TestBoolStruct {
             #[serde(deserialize_with = "as_bool")]
             field: bool,
         }
 
         #[test]
-        fn test_ok_values() {
-            let json = r#"{"field": "OK"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: true });
-
-            let json = r#"{"field": true}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: true });
-
-            let json = r#"{"field": "Y"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: true });
+        fn test_truthy_values() {
+            let truthy_values = ["1", "OK", "ON", "T", "TRUE", "Y", "YES"];
+            for value in truthy_values {
+                let json = format!(r#"{{"field": "{}"}}"#, value);
+                let deserialized: TestBoolStruct = serde_json::from_str(&json).unwrap();
+                assert_eq!(deserialized, TestBoolStruct { field: true });
+            }
         }
 
         #[test]
-        fn test_ng_values() {
-            let json = r#"{"field": "NG"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: false });
-
-            let json = r#"{"field": false}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: false });
-
-            let json = r#"{"field": "NO"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: false });
+        fn test_falsy_values() {
+            let falsy_values = ["0", "OFF", "F", "FALSE", "N", "NO"];
+            for value in falsy_values {
+                let json = format!(r#"{{"field": "{}"}}"#, value);
+                let deserialized: TestBoolStruct = serde_json::from_str(&json).unwrap();
+                assert_eq!(deserialized, TestBoolStruct { field: false });
+            }
         }
 
         #[test]
-        fn test_null_value() {
+        fn test_as_bool_with_null() {
             let json = r#"{"field": null}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: false });
+            let deserialized: TestBoolStruct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestBoolStruct { field: false });
         }
 
         #[test]
-        fn test_invalid_values() {
+        fn test_invalid_boolean() {
             let json = r#"{"field": "INVALID"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: false });
+            let deserialized: TestBoolStruct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestBoolStruct { field: false });
         }
     }
 
     mod as_f64_tests {
         use super::*;
-        use serde::Deserialize;
 
         #[derive(Debug, PartialEq, Deserialize)]
-        struct TestStruct {
+        struct TestF64Struct {
             #[serde(deserialize_with = "as_f64")]
             field: f64,
         }
 
+        #[test]
+        fn test_as_f64_with_large_number() {
+            let json = r#"{"field": 1e308}"#;
+            let deserialized: TestF64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestF64Struct { field: 1e308 });
+        }
+
+        #[test]
+        fn test_as_f64_with_negative_number() {
+            let json = r#"{"field": -123.45}"#;
+            let deserialized: TestF64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestF64Struct { field: -123.45 });
+        }
+
         #[test]
         fn test_as_f64_with_number() {
             let json = r#"{"field": 123.45}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123.45 });
+            let deserialized: TestF64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestF64Struct { field: 123.45 });
         }
 
         #[test]
         fn test_as_f64_with_integer() {
             let json = r#"{"field": 123}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123.0 });
+            let deserialized: TestF64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestF64Struct { field: 123.0 });
         }
 
         #[test]
         fn test_as_f64_with_string() {
             let json = r#"{"field": "123.45"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123.45 });
+            let deserialized: TestF64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestF64Struct { field: 123.45 });
+        }
+
+        #[test]
+        fn test_as_f64_with_empty_string() {
+            let json = r#"{"field": ""}"#;
+            let deserialized = serde_json::from_str::<TestF64Struct>(json).unwrap();
+            assert_eq!(deserialized, TestF64Struct { field: 0.0 });
         }
 
         #[test]
         fn test_as_f64_with_null() {
             let json = r#"{"field": null}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 0.0 });
+            let deserialized: TestF64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestF64Struct { field: 0.0 });
         }
     }
 
     mod as_i64_tests {
         use super::*;
-        use serde::Deserialize;
 
         #[derive(Debug, PartialEq, Deserialize)]
-        struct TestStruct {
+        struct TestI64Struct {
             #[serde(deserialize_with = "as_i64")]
             field: i64,
         }
@@ -570,38 +603,51 @@ mod tests {
         #[test]
         fn test_as_i64_with_integer() {
             let json = r#"{"field": 123}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123 });
+            let deserialized: TestI64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestI64Struct { field: 123 });
         }
 
         #[test]
         fn test_as_i64_with_string() {
             let json = r#"{"field": "123"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123 });
+            let deserialized: TestI64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestI64Struct { field: 123 });
         }
 
         #[test]
         fn test_as_i64_with_float() {
             let json = r#"{"field": 123.45}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123 });
+            let deserialized: TestI64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestI64Struct { field: 123 });
         }
 
         #[test]
         fn test_as_i64_with_null() {
             let json = r#"{"field": null}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 0 });
+            let deserialized: TestI64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestI64Struct { field: 0 });
+        }
+
+        #[test]
+        fn test_as_i64_with_max_value() {
+            let json = format!(r#"{{"field": {}}}"#, i64::MAX);
+            let deserialized: TestI64Struct = serde_json::from_str(&json).unwrap();
+            assert_eq!(deserialized, TestI64Struct { field: i64::MAX });
+        }
+
+        #[test]
+        fn test_as_i64_with_overflow() {
+            let json = format!(r#"{{"field": {}}}"#, u64::MAX);
+            let deserialized = serde_json::from_str::<TestI64Struct>(&json);
+            assert!(deserialized.is_err());
         }
     }
 
     mod as_u64_tests {
         use super::*;
-        use serde::Deserialize;
 
         #[derive(Debug, PartialEq, Deserialize)]
-        struct TestStruct {
+        struct TestU64Struct {
             #[serde(deserialize_with = "as_u64")]
             field: u64,
         }
@@ -609,29 +655,43 @@ mod tests {
         #[test]
         fn test_as_u64_with_integer() {
             let json = r#"{"field": 123}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123 });
+            let deserialized: TestU64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestU64Struct { field: 123 });
         }
 
         #[test]
         fn test_as_u64_with_string() {
             let json = r#"{"field": "123"}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123 });
+            let deserialized: TestU64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestU64Struct { field: 123 });
         }
 
         #[test]
         fn test_as_u64_with_float() {
             let json = r#"{"field": 123.45}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 123 });
+            let deserialized: TestU64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestU64Struct { field: 123 });
         }
 
         #[test]
         fn test_as_u64_with_null() {
             let json = r#"{"field": null}"#;
-            let deserialized: TestStruct = serde_json::from_str(json).unwrap();
-            assert_eq!(deserialized, TestStruct { field: 0 });
+            let deserialized: TestU64Struct = serde_json::from_str(json).unwrap();
+            assert_eq!(deserialized, TestU64Struct { field: 0 });
+        }
+
+        #[test]
+        fn test_as_u64_with_negative_number() {
+            let json = r#"{"field": -1}"#;
+            let deserialized = serde_json::from_str::<TestU64Struct>(json);
+            assert!(deserialized.is_err());
+        }
+
+        #[test]
+        fn test_as_u64_with_large_value() {
+            let json = format!(r#"{{"field": {}}}"#, u64::MAX);
+            let deserialized: TestU64Struct = serde_json::from_str(&json).unwrap();
+            assert_eq!(deserialized, TestU64Struct { field: u64::MAX });
         }
     }
 }