Fix clippy errors and convert tests to use proper assertions

Author: anonrig

tests/identifier_tests.rs

@@ -88,11 +88,10 @@ fn test_utf8_to_utf32_length() {
 
     for (input, expected_len) in test_cases {
         let actual_len = unicode::utf8_to_utf32_length(input.as_bytes());
-        println!("UTF-8 '{}' has {} UTF-32 code points", input, actual_len);
-        // Note: Expected values may need adjustment based on actual Unicode handling
-        assert!(
-            actual_len > 0 || input.is_empty(),
-            "Length should be positive for non-empty strings"
+        assert_eq!(
+            actual_len, expected_len,
+            "UTF-32 length mismatch for '{}'",
+            input
         );
     }
 }
@@ -120,26 +119,24 @@ fn test_utf8_to_utf32_conversion() {
 
     for input in test_cases {
         let utf32_chars = unicode::utf8_to_utf32(input.as_bytes());
-        println!(
-            "UTF-8 to UTF-32: '{}' -> {} chars",
-            input,
-            utf32_chars.len()
-        );
 
         // Verify the conversion produces valid UTF-32
         assert!(
             !utf32_chars.is_empty() || input.is_empty(),
             "Non-empty input should produce non-empty output"
         );
 
-        // Try to convert back to UTF-8
+        // Try to convert back to UTF-8 for roundtrip test
         let utf8_bytes = unicode::utf32_to_utf8(&utf32_chars);
         if !utf8_bytes.is_empty() {
             let roundtrip = String::from_utf8(utf8_bytes);
-            if let Ok(roundtrip_str) = roundtrip {
-                println!("Roundtrip: '{}' -> '{}'", input, roundtrip_str);
-                // Note: Some normalization might occur during roundtrip
-            }
+            assert!(
+                roundtrip.is_ok(),
+                "Failed to roundtrip UTF-8 conversion for '{}'",
+                input
+            );
+            let roundtrip_str = roundtrip.unwrap();
+            assert_eq!(roundtrip_str, input, "Roundtrip mismatch for '{}'", input);
         }
     }
 }
@@ -167,26 +164,26 @@ fn test_utf32_to_utf8_conversion() {
     for utf32_seq in test_utf32_sequences {
         let utf8_bytes = unicode::utf32_to_utf8(&utf32_seq);
 
-        if !utf8_bytes.is_empty() {
-            if let Ok(utf8_str) = String::from_utf8(utf8_bytes.clone()) {
-                println!("UTF-32 {:X?} -> UTF-8 '{}'", utf32_seq, utf8_str);
+        assert!(
+            !utf8_bytes.is_empty(),
+            "UTF-32 to UTF-8 conversion should not produce empty result for {:X?}",
+            utf32_seq
+        );
 
-                // Test roundtrip conversion
-                let back_to_utf32 = unicode::utf8_to_utf32(&utf8_bytes);
-                if back_to_utf32 == utf32_seq {
-                    println!("  Roundtrip successful");
-                } else {
-                    println!(
-                        "  Roundtrip mismatch: {:X?} != {:X?}",
-                        back_to_utf32, utf32_seq
-                    );
-                }
-            } else {
-                println!("UTF-32 {:X?} -> invalid UTF-8 bytes", utf32_seq);
-            }
-        } else {
-            println!("UTF-32 {:X?} -> empty UTF-8", utf32_seq);
-        }
+        let utf8_str = String::from_utf8(utf8_bytes.clone());
+        assert!(
+            utf8_str.is_ok(),
+            "UTF-32 {:X?} should produce valid UTF-8",
+            utf32_seq
+        );
+
+        // Test roundtrip conversion
+        let back_to_utf32 = unicode::utf8_to_utf32(&utf8_bytes);
+        assert_eq!(
+            back_to_utf32, utf32_seq,
+            "Roundtrip conversion failed for UTF-32 {:X?}",
+            utf32_seq
+        );
     }
 }
 
@@ -218,11 +215,6 @@ fn test_identifier_validation_edge_cases() {
         let first_pos = validation::valid_name_code_point_first_position(ch as u32);
         let other_pos = validation::valid_name_code_point_other_position(ch as u32);
 
-        println!(
-            "Character '{}' (U+{:04X}): first={}, other={}",
-            ch, ch as u32, first_pos, other_pos
-        );
-
         // Control and format characters should generally be invalid
         if ch.is_control() || ch as u32 == 0x00AD || ch as u32 == 0x200C || ch as u32 == 0x200D {
             assert!(
@@ -231,6 +223,17 @@ fn test_identifier_validation_edge_cases() {
                 ch as u32
             );
         }
+
+        assert_eq!(
+            first_pos, expected_valid,
+            "First position validation mismatch for U+{:04X}",
+            ch as u32
+        );
+        assert_eq!(
+            other_pos, expected_valid,
+            "Other position validation mismatch for U+{:04X}",
+            ch as u32
+        );
     }
 }
 
@@ -259,15 +262,10 @@ fn test_unicode_categories() {
         ('-', "Dash Punctuation", false), // Valid in middle positions only
     ];
 
-    for (ch, category, expected_first) in category_tests {
+    for (ch, _category, expected_first) in category_tests {
         let first_pos = validation::valid_name_code_point_first_position(ch as u32);
         let other_pos = validation::valid_name_code_point_other_position(ch as u32);
 
-        println!(
-            "'{}' ({}): first={}, other={}",
-            ch, category, first_pos, other_pos
-        );
-
         if ch.is_alphabetic() {
             assert!(
                 first_pos,
@@ -280,5 +278,11 @@ fn test_unicode_categories() {
                 ch
             );
         }
+
+        assert_eq!(
+            first_pos, expected_first,
+            "First position validation mismatch for '{}' ({})",
+            ch, _category
+        );
     }
 }

tests/to_ascii_tests.rs

@@ -13,7 +13,7 @@ fn test_to_ascii_basic() {
         ("bücher.example", "xn--bcher-kva.example"),
     ];
 
-    for (input, expected) in test_cases {
+    for (input, _expected) in test_cases {
         let result = to_ascii(input);
         assert!(
             result.is_ok(),
@@ -32,7 +32,7 @@ fn test_to_ascii_special_characters() {
     assert!(result.is_ok());
 
     // Test soft hyphen removal
-    let result = to_ascii("ex­ample.com"); // Contains U+00AD soft hyphen
+    let result = to_ascii("ex\u{AD}ample.com"); // Contains U+00AD soft hyphen
     assert!(result.is_ok());
 
     // Test replacement character
@@ -82,7 +82,7 @@ fn test_to_ascii_edge_cases() {
         ("simple.café.com", "simple.xn--caf-dma.com"),
     ];
 
-    for (input, expected) in test_cases {
+    for (input, _expected) in test_cases {
         let result = to_ascii(input);
         assert!(
             result.is_ok(),
@@ -113,14 +113,13 @@ fn test_to_ascii_unicode_scripts() {
 
     for (input, expected) in test_cases {
         let result = to_ascii(input);
-        if result.is_ok() {
-            let actual = result.unwrap();
-            println!("Unicode script test: '{}' -> '{}'", input, actual);
-            // Note: Expected values may need adjustment based on actual implementation
-            // For now, just verify the conversion doesn't fail
-        } else {
-            println!("Failed to convert '{}': {:?}", input, result);
-        }
+        assert!(
+            result.is_ok(),
+            "Failed to convert Unicode script '{}'",
+            input
+        );
+        let actual = result.unwrap();
+        assert_eq!(actual, expected, "Unicode script mismatch for '{}'", input);
     }
 }
 
@@ -149,16 +148,24 @@ fn test_to_ascii_punycode_expansion() {
 
     for (input, expected) in test_cases {
         let result = to_ascii(input);
-        if result.is_ok() {
-            let actual = result.unwrap();
-            println!("Punycode expansion: '{}' -> '{}'", input, actual);
-            // Verify it starts with xn-- for Unicode labels
-            if input.chars().any(|c| !c.is_ascii()) {
-                assert!(
-                    actual.contains("xn--"),
-                    "Unicode input should produce punycode output"
-                );
-            }
+        assert!(
+            result.is_ok(),
+            "Failed to convert punycode expansion '{}'",
+            input
+        );
+        let actual = result.unwrap();
+        assert_eq!(
+            actual, expected,
+            "Punycode expansion mismatch for '{}'",
+            input
+        );
+
+        // Verify it starts with xn-- for Unicode labels
+        if !input.is_ascii() {
+            assert!(
+                actual.contains("xn--"),
+                "Unicode input should produce punycode output"
+            );
         }
     }
 }

tests/to_unicode_tests.rs

@@ -1,4 +1,4 @@
-use ada_idna::domain::{IdnaError, to_unicode};
+use ada_idna::domain::to_unicode;
 
 #[test]
 fn test_to_unicode_basic() {

tests/wpt_tests.rs

@@ -12,7 +12,7 @@ fn test_wpt_basic_ascii_domains() {
         ("a.b.c.d.e", "a.b.c.d.e"),
     ];
 
-    for (input, expected) in test_cases {
+    for (input, _expected) in test_cases {
         let result = to_ascii(input);
         assert!(
             result.is_ok(),
@@ -49,13 +49,17 @@ fn test_wpt_unicode_to_ascii() {
 
     for (input, expected) in test_cases {
         let result = to_ascii(input);
-        if result.is_ok() {
-            let actual = result.unwrap();
-            println!("WPT Unicode->ASCII: '{}' -> '{}'", input, actual);
-            // Note: Exact expected values may need adjustment based on implementation
-        } else {
-            println!("WPT Unicode->ASCII failed for '{}': {:?}", input, result);
-        }
+        assert!(
+            result.is_ok(),
+            "WPT: Failed to convert Unicode->ASCII for '{}'",
+            input
+        );
+        let actual = result.unwrap();
+        assert_eq!(
+            actual, expected,
+            "WPT: Unicode->ASCII mismatch for '{}'",
+            input
+        );
     }
 }
 
@@ -79,12 +83,17 @@ fn test_wpt_ascii_to_unicode() {
 
     for (input, expected) in test_cases {
         let result = to_unicode(input);
-        if result.is_ok() {
-            let actual = result.unwrap();
-            println!("WPT ASCII->Unicode: '{}' -> '{}'", input, actual);
-        } else {
-            println!("WPT ASCII->Unicode failed for '{}': {:?}", input, result);
-        }
+        assert!(
+            result.is_ok(),
+            "WPT: Failed to convert ASCII->Unicode for '{}'",
+            input
+        );
+        let actual = result.unwrap();
+        assert_eq!(
+            actual, expected,
+            "WPT: ASCII->Unicode mismatch for '{}'",
+            input
+        );
     }
 }
 
@@ -194,25 +203,31 @@ fn test_wpt_international_domains() {
 
     for (unicode_input, expected_ascii) in international_cases {
         let ascii_result = to_ascii(unicode_input);
-        if ascii_result.is_ok() {
-            let actual_ascii = ascii_result.unwrap();
-            println!(
-                "WPT International: '{}' -> '{}'",
-                unicode_input, actual_ascii
-            );
+        assert!(
+            ascii_result.is_ok(),
+            "WPT: Failed to convert international domain '{}'",
+            unicode_input
+        );
+        let actual_ascii = ascii_result.unwrap();
+        assert_eq!(
+            actual_ascii, expected_ascii,
+            "WPT: International domain mismatch for '{}'",
+            unicode_input
+        );
 
-            // Test roundtrip
-            let unicode_result = to_unicode(&actual_ascii);
-            if unicode_result.is_ok() {
-                let roundtrip_unicode = unicode_result.unwrap();
-                println!("  Roundtrip: '{}' -> '{}'", actual_ascii, roundtrip_unicode);
-            }
-        } else {
-            println!(
-                "WPT International conversion failed for '{}': {:?}",
-                unicode_input, ascii_result
-            );
-        }
+        // Test roundtrip
+        let unicode_result = to_unicode(&actual_ascii);
+        assert!(
+            unicode_result.is_ok(),
+            "WPT: Failed to roundtrip convert '{}'",
+            actual_ascii
+        );
+        let roundtrip_unicode = unicode_result.unwrap();
+        assert_eq!(
+            roundtrip_unicode, unicode_input,
+            "WPT: Roundtrip mismatch for '{}'",
+            unicode_input
+        );
     }
 }
 
@@ -236,12 +251,17 @@ fn test_wpt_normalization_cases() {
 
     for (input, expected) in normalization_cases {
         let result = to_ascii(input);
-        if result.is_ok() {
-            let actual = result.unwrap();
-            println!("WPT Normalization: '{}' -> '{}'", input, actual);
-        } else {
-            println!("WPT Normalization failed for '{}': {:?}", input, result);
-        }
+        assert!(
+            result.is_ok(),
+            "WPT: Failed to convert normalization case '{}'",
+            input
+        );
+        let actual = result.unwrap();
+        assert_eq!(
+            actual, expected,
+            "WPT: Normalization mismatch for '{}'",
+            input
+        );
     }
 }
 
@@ -260,11 +280,11 @@ fn test_wpt_mixed_script_validation() {
     for (input, should_succeed) in mixed_script_cases {
         let result = to_ascii(input);
         if should_succeed {
-            if result.is_ok() {
-                println!("WPT Mixed script OK: '{}' -> '{}'", input, result.unwrap());
-            } else {
-                println!("WPT Mixed script failed: '{}' -> {:?}", input, result);
-            }
+            assert!(
+                result.is_ok(),
+                "WPT: Mixed script should succeed for '{}'",
+                input
+            );
         } else {
             assert!(
                 result.is_err(),