IDNA: One test in the test harness per test case.

This makes individual failures show up separately.

idna/Cargo.toml

@@ -6,13 +6,19 @@ description = "IDNA (Internationalizing Domain Names in Applications) and Punyco
 repository = "https://github.com/servo/rust-url/"
 license = "MIT/Apache-2.0"
 
-[dependencies]
-unicode-bidi = "0.2.3"
-unicode-normalization = "0.1.2"
-matches = "0.1"
+[lib]
+doctest = false
+test = false
+
+[[test]]
+name = "tests"
+harness = false
 
 [dev-dependencies]
+rustc-test = "0.1"
 rustc-serialize = "0.3"
 
-[[test]]
-name = "tests"
+[dependencies]
+unicode-bidi = "0.2.3"
+unicode-normalization = "0.1.2"
+matches = "0.1"

idna/tests/punycode.rs

@@ -8,15 +8,16 @@
 
 use idna::punycode::{decode, encode_str};
 use rustc_serialize::json::{Json, Object};
+use test::TestFn;
 
-fn one_test(description: &str, decoded: &str, encoded: &str) {
+fn one_test(decoded: &str, encoded: &str) {
     match decode(encoded) {
         None => panic!("Decoding {} failed.", encoded),
         Some(result) => {
             let result = result.into_iter().collect::<String>();
             assert!(result == decoded,
-                    format!("Incorrect decoding of {}:\n   {}\n!= {}\n{}",
-                            encoded, result, decoded, description))
+                    format!("Incorrect decoding of \"{}\":\n   \"{}\"\n!= \"{}\"\n",
+                            encoded, result, decoded))
         }
     }
 
@@ -24,8 +25,8 @@ fn one_test(description: &str, decoded: &str, encoded: &str) {
         None => panic!("Encoding {} failed.", decoded),
         Some(result) => {
             assert!(result == encoded,
-                    format!("Incorrect encoding of {}:\n   {}\n!= {}\n{}",
-                            decoded, result, encoded, description))
+                    format!("Incorrect encoding of \"{}\":\n   \"{}\"\n!= \"{}\"\n",
+                            decoded, result, encoded))
         }
     }
 }
@@ -38,17 +39,24 @@ fn get_string<'a>(map: &'a Object, key: &str) -> &'a str {
     }
 }
 
-#[test]
-fn test_punycode() {
-
+pub fn collect_tests<F: FnMut(String, TestFn)>(add_test: &mut F) {
     match Json::from_str(include_str!("punycode_tests.json")) {
-        Ok(Json::Array(tests)) => for test in &tests {
+        Ok(Json::Array(tests)) => for (i, test) in tests.into_iter().enumerate() {
             match test {
-                &Json::Object(ref o) => one_test(
-                    get_string(o, "description"),
-                    get_string(o, "decoded"),
-                    get_string(o, "encoded")
-                ),
+                Json::Object(o) => {
+                    let test_name = {
+                        let desc = get_string(&o, "description");
+                            if desc.is_empty() {
+                            format!("Punycode {}", i + 1)
+                        } else {
+                            format!("Punycode {}: {}", i + 1, desc)
+                        }
+                    };
+                    add_test(test_name, TestFn::dyn_test_fn(move || one_test(
+                        get_string(&o, "decoded"),
+                        get_string(&o, "encoded"),
+                    )))
+                }
                 _ => panic!(),
             }
         },

idna/tests/tests.rs

@@ -1,5 +1,25 @@
 extern crate idna;
 extern crate rustc_serialize;
+extern crate test;
 
 mod punycode;
 mod uts46;
+
+fn main() {
+    let mut tests = Vec::new();
+    {
+        let mut add_test = |name, run| {
+            tests.push(test::TestDescAndFn {
+                desc: test::TestDesc {
+                    name: test::DynTestName(name),
+                    ignore: false,
+                    should_panic: test::ShouldPanic::No,
+                },
+                testfn: run,
+            })
+        };
+        punycode::collect_tests(&mut add_test);
+        uts46::collect_tests(&mut add_test);
+    }
+    test::test_main(&std::env::args().collect::<Vec<_>>(), tests)
+}

idna/tests/uts46.rs

@@ -8,11 +8,11 @@
 
 use std::char;
 use idna::uts46;
+use test::TestFn;
 
-#[test]
-fn test_uts46() {
+pub fn collect_tests<F: FnMut(String, TestFn)>(add_test: &mut F) {
     // http://www.unicode.org/Public/idna/latest/IdnaTest.txt
-    for line in include_str!("IdnaTest.txt").lines() {
+    for (i, line) in include_str!("IdnaTest.txt").lines().enumerate() {
         if line == "" || line.starts_with("#") {
             continue
         }
@@ -35,47 +35,54 @@ fn test_uts46() {
         let source = unescape(original);
         let to_unicode = pieces.remove(0);
         let to_ascii = pieces.remove(0);
-        let _nv8 = if pieces.len() > 0 { pieces.remove(0) } else { "" };
+        let nv8 = if pieces.len() > 0 { pieces.remove(0) } else { "" };
 
         if expected_failure {
             continue;
         }
 
-        let result = uts46::to_ascii(&source, uts46::Flags {
-            use_std3_ascii_rules: true,
-            transitional_processing: test_type == "T",
-            verify_dns_length: true,
-        });
+        let test_name = format!("UTS #46 line {}", i + 1);
+        add_test(test_name, TestFn::dyn_test_fn(move || {
+            let result = uts46::to_ascii(&source, uts46::Flags {
+                use_std3_ascii_rules: true,
+                transitional_processing: test_type == "T",
+                verify_dns_length: true,
+            });
 
-        if to_ascii.starts_with("[") {
-            if to_ascii.starts_with("[C") {
-                // http://unicode.org/reports/tr46/#Deviations
-                // applications that perform IDNA2008 lookup are not required to check for these contexts
-                continue;
+            if to_ascii.starts_with("[") {
+                if to_ascii.starts_with("[C") {
+                    // http://unicode.org/reports/tr46/#Deviations
+                    // applications that perform IDNA2008 lookup are not required to check
+                    // for these contexts
+                    return;
+                }
+                let res = result.ok();
+                assert!(res == None, "Expected error. result: {} | original: {} | source: {}",
+                        res.unwrap(), original, source);
+                return;
             }
-            let res = result.ok();
-            assert!(res == None, "Expected error. result: {} | original: {} | source: {}", res.unwrap(), original, source);
-            continue;
-        }
 
-        let to_ascii = if to_ascii.len() > 0 {
-            to_ascii.to_string()
-        } else {
-            if to_unicode.len() > 0 {
-                to_unicode.to_string()
+            let to_ascii = if to_ascii.len() > 0 {
+                to_ascii.to_string()
             } else {
-                source.clone()
-            }
-        };
+                if to_unicode.len() > 0 {
+                    to_unicode.to_string()
+                } else {
+                    source.clone()
+                }
+            };
 
-        if _nv8 == "NV8" {
-            // This result isn't valid under IDNA2008. Skip it
-            continue;
-        }
+            if nv8 == "NV8" {
+                // This result isn't valid under IDNA2008. Skip it
+                return;
+            }
 
-        assert!(result.is_ok(), "Couldn't parse {} | original: {} | error: {:?}", source, original, result.err());
-        let output = result.ok().unwrap();
-        assert!(output == to_ascii, "result: {} | expected: {} | original: {} | source: {}", output, to_ascii, original, source);
+            assert!(result.is_ok(), "Couldn't parse {} | original: {} | error: {:?}",
+                    source, original, result.err());
+            let output = result.ok().unwrap();
+            assert!(output == to_ascii, "result: {} | expected: {} | original: {} | source: {}",
+                    output, to_ascii, original, source);
+        }))
     }
 }