Move tests to another file.

tests.rs

@@ -0,0 +1,163 @@
+// Copyright 2013 Simon Sapin.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+use std::char;
+use std::u32;
+use super::{URL, RelativeSchemeData, SchemeRelativeURL, UserInfo, OtherSchemeData};
+
+
+#[test]
+fn test_url_parsing() {
+    for test in parse_test_data(include_str!("urltestdata.txt")).move_iter() {
+        let Test {
+            input: input,
+            base: base,
+            scheme: expected_scheme,
+            username: expected_username,
+            password: expected_password,
+            host: expected_host,
+            port: expected_port,
+            path: expected_path,
+            query: expected_query,
+            fragment: expected_fragment
+        } = test;
+        let base = URL::parse(base, None).unwrap();
+        let url = URL::parse(input, Some(base));
+        if expected_scheme.is_none() {
+            assert!(url.is_none(), "Expected a parse error");
+            continue
+        }
+        let URL {
+            scheme: scheme,
+            scheme_data: scheme_data,
+            query: query,
+            fragment: fragment
+        } = url.unwrap();
+
+        assert_eq!(Some(scheme.to_str_ascii()), expected_scheme);
+        match scheme_data {
+            RelativeSchemeData(SchemeRelativeURL {
+                userinfo: userinfo, host: host, port: port, path: path
+            }) => {
+                let (username, password) = match userinfo {
+                    Some(UserInfo { username: username, password: password })
+                    => (Some(username.to_str_ascii()), password.map(|p| p.to_str_ascii())),
+                    _ => (None, None),
+                };
+                assert_eq!(username, expected_username);
+                assert_eq!(password, expected_password);
+                assert_eq!(Some(host.serialize().to_str_ascii()), expected_host)
+                assert_eq!(Some(port.to_str_ascii()), expected_port);
+                assert_eq!(Some(path.map(|p| p.to_str_ascii()).connect("/")), expected_path);
+            },
+            OtherSchemeData(scheme_data) => {
+                assert_eq!(Some(scheme_data.to_str_ascii()), expected_path);
+                assert_eq!(None, expected_username);
+                assert_eq!(None, expected_password);
+                assert_eq!(None, expected_host);
+                assert_eq!(None, expected_port);
+            },
+        }
+        assert_eq!(query.map(|p| p.to_str_ascii()), expected_query);
+        assert_eq!(fragment.map(|p| p.to_str_ascii()), expected_fragment);
+    }
+}
+
+struct Test {
+    input: ~str,
+    base: ~str,
+    scheme: Option<~str>,
+    username: Option<~str>,
+    password: Option<~str>,
+    host: Option<~str>,
+    port: Option<~str>,
+    path: Option<~str>,
+    query: Option<~str>,
+    fragment: Option<~str>,
+}
+
+fn parse_test_data(input: &str) -> ~[Test] {
+    let mut tests: ~[Test] = ~[];
+    for line in input.line_iter() {
+        if line == "" || line[0] == ('#' as u8) {
+            continue
+        }
+        let mut pieces = line.split_iter(' ').to_owned_vec();
+        let input = unescape(pieces.shift());
+        let mut test = Test {
+            input: input,
+            base: if pieces.is_empty() {
+                tests[tests.len() - 1].base.to_owned()
+            } else {
+                unescape(pieces.shift())
+            },
+            scheme: None,
+            username: None,
+            password: None,
+            host: None,
+            port: None,
+            path: None,
+            query: None,
+            fragment: None,
+        };
+        for piece in pieces.move_iter() {
+            if piece != "" || piece[0] == ('#' as u8) {
+                continue
+            }
+            let colon = piece.find(':').unwrap();
+            let value = piece.slice_from(colon + 1).to_owned();
+            match piece.slice_to(colon) {
+                "s" => test.scheme = Some(value),
+                "u" => test.username = Some(value),
+                "pass" => test.password = Some(value),
+                "h" => test.host = Some(value),
+                "p" => test.path = Some(value),
+                "q" => test.query = Some(value),
+                "f" => test.fragment = Some(value),
+                _ => fail!("Invalid token")
+            }
+        }
+        tests.push(test)
+    }
+    tests
+}
+
+fn unescape(input: &str) -> ~str {
+    let mut output = ~"";
+    let mut chars = input.iter();
+    loop {
+        match chars.next() {
+            None => return output,
+            Some(c) => output.push_char(
+                if c == '\\' {
+                    match chars.next().unwrap() {
+                        '\\' => '\\',
+                        'n' => '\n',
+                        'r' => '\r',
+                        's' => ' ',
+                        't' => '\t',
+                        'f' => '\x0C',
+                        'u' => {
+                            let mut hex = ~"";
+                            hex.push_char(chars.next().unwrap());
+                            hex.push_char(chars.next().unwrap());
+                            hex.push_char(chars.next().unwrap());
+                            hex.push_char(chars.next().unwrap());
+                            u32::parse_bytes(hex.as_bytes(), 16)
+                                .and_then(char::from_u32).unwrap()
+                        }
+                        _ => fail!("Invalid test data input"),
+                    }
+                } else {
+                    c
+                }
+            )
+        }
+    }
+}

url.rs

@@ -9,7 +9,7 @@
 
 #[link(name = "url", vers = "0.1")];
 #[crate_type = "lib"];
-#[feature(globs, macro_rules)];
+#[feature(macro_rules)];
 
 extern mod encoding;
 
@@ -25,6 +25,9 @@ use encoding::label::encoding_from_whatwg_label;
 
 pub mod punycode;
 
+#[cfg(test)]
+mod tests;
+
 
 pub struct URL {
     scheme: ~[Ascii],
@@ -527,160 +530,3 @@ pub fn serialize_form_urlencoded(pairs: ~[(~str, ~str)],
     }
     output
 }
-
-
-#[cfg(test)]
-mod tests {
-    use std::{char, u32};
-    use super::*;
-
-    #[test]
-    fn test_url_parsing() {
-        for test in parse_test_data(include_str!("urltestdata.txt")).move_iter() {
-            let Test {
-                input: input,
-                base: base,
-                scheme: expected_scheme,
-                username: expected_username,
-                password: expected_password,
-                host: expected_host,
-                port: expected_port,
-                path: expected_path,
-                query: expected_query,
-                fragment: expected_fragment
-            } = test;
-            let base = URL::parse(base, None).unwrap();
-            let url = URL::parse(input, Some(base));
-            if expected_scheme.is_none() {
-                assert!(url.is_none(), "Expected a parse error");
-                continue
-            }
-            let URL {
-                scheme: scheme,
-                scheme_data: scheme_data,
-                query: query,
-                fragment: fragment
-            } = url.unwrap();
-
-            assert_eq!(Some(scheme.to_str_ascii()), expected_scheme);
-            match scheme_data {
-                RelativeSchemeData(SchemeRelativeURL {
-                    userinfo: userinfo, host: host, port: port, path: path
-                }) => {
-                    let (username, password) = match userinfo {
-                        Some(UserInfo { username: username, password: password })
-                        => (Some(username.to_str_ascii()), password.map(|p| p.to_str_ascii())),
-                        _ => (None, None),
-                    };
-                    assert_eq!(username, expected_username);
-                    assert_eq!(password, expected_password);
-                    assert_eq!(Some(host.serialize().to_str_ascii()), expected_host)
-                    assert_eq!(Some(port.to_str_ascii()), expected_port);
-                    assert_eq!(Some(path.map(|p| p.to_str_ascii()).connect("/")), expected_path);
-                },
-                OtherSchemeData(scheme_data) => {
-                    assert_eq!(Some(scheme_data.to_str_ascii()), expected_path);
-                    assert_eq!(None, expected_username);
-                    assert_eq!(None, expected_password);
-                    assert_eq!(None, expected_host);
-                    assert_eq!(None, expected_port);
-                },
-            }
-            assert_eq!(query.map(|p| p.to_str_ascii()), expected_query);
-            assert_eq!(fragment.map(|p| p.to_str_ascii()), expected_fragment);
-        }
-    }
-
-    struct Test {
-        input: ~str,
-        base: ~str,
-        scheme: Option<~str>,
-        username: Option<~str>,
-        password: Option<~str>,
-        host: Option<~str>,
-        port: Option<~str>,
-        path: Option<~str>,
-        query: Option<~str>,
-        fragment: Option<~str>,
-    }
-
-    fn parse_test_data(input: &str) -> ~[Test] {
-        let mut tests: ~[Test] = ~[];
-        for line in input.line_iter() {
-            if line == "" || line[0] == ('#' as u8) {
-                continue
-            }
-            let mut pieces = line.split_iter(' ').to_owned_vec();
-            let input = unescape(pieces.shift());
-            let mut test = Test {
-                input: input,
-                base: if pieces.is_empty() {
-                    tests[tests.len() - 1].base.to_owned()
-                } else {
-                    unescape(pieces.shift())
-                },
-                scheme: None,
-                username: None,
-                password: None,
-                host: None,
-                port: None,
-                path: None,
-                query: None,
-                fragment: None,
-            };
-            for piece in pieces.move_iter() {
-                if piece != "" || piece[0] == ('#' as u8) {
-                    continue
-                }
-                let colon = piece.find(':').unwrap();
-                let value = piece.slice_from(colon + 1).to_owned();
-                match piece.slice_to(colon) {
-                    "s" => test.scheme = Some(value),
-                    "u" => test.username = Some(value),
-                    "pass" => test.password = Some(value),
-                    "h" => test.host = Some(value),
-                    "p" => test.path = Some(value),
-                    "q" => test.query = Some(value),
-                    "f" => test.fragment = Some(value),
-                    _ => fail!("Invalid token")
-                }
-            }
-            tests.push(test)
-        }
-        tests
-    }
-
-    fn unescape(input: &str) -> ~str {
-        let mut output = ~"";
-        let mut chars = input.iter();
-        loop {
-            match chars.next() {
-                None => return output,
-                Some(c) => output.push_char(
-                    if c == '\\' {
-                        match chars.next().unwrap() {
-                            '\\' => '\\',
-                            'n' => '\n',
-                            'r' => '\r',
-                            's' => ' ',
-                            't' => '\t',
-                            'f' => '\x0C',
-                            'u' => {
-                                let mut hex = ~"";
-                                hex.push_char(chars.next().unwrap());
-                                hex.push_char(chars.next().unwrap());
-                                hex.push_char(chars.next().unwrap());
-                                hex.push_char(chars.next().unwrap());
-                                u32::parse_bytes(hex.as_bytes(), 16)
-                                    .and_then(char::from_u32).unwrap()
-                            }
-                            _ => fail!("Invalid test data input"),
-                        }
-                    } else {
-                        c
-                    }
-                )
-            }
-        }
-    }
-}