Fix bitrotten tests

src/components/gfx/text/util.rs

@@ -123,7 +123,7 @@ pub fn true_type_tag(a: char, b: char, c: char, d: char) -> u32 {
 
 #[test]
 fn test_true_type_tag() {
-    assert!(true_type_tag('c', 'm', 'a', 'p') == 0x_63_6D_61_70_u32);
+    assert_eq!(true_type_tag('c', 'm', 'a', 'p'), 0x_63_6D_61_70_u32);
 }
 
 #[test]
@@ -139,8 +139,8 @@ fn test_transform_compress_none() {
     let mode = CompressNone;
 
     for i in range(0, test_strs.len()) {
-        (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == test_strs[i])
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
+        assert_eq!(&trimmed_str, &test_strs[i])
     }
 }
 
@@ -163,12 +163,12 @@ fn test_transform_discard_newline() {
                                    ~"foo bar baz",
                                    ~"foobarbaz"];
 
-    assert!(test_strs.len() == oracle_strs.len());
+    assert_eq!(test_strs.len(), oracle_strs.len());
     let mode = DiscardNewline;
 
     for i in range(0, test_strs.len()) {
-        (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == oracle_strs[i])
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
+        assert_eq!(&trimmed_str, &oracle_strs[i])
     }
 }
 
@@ -190,12 +190,12 @@ fn test_transform_compress_whitespace() {
                                  ~"foo bar baz",
                                  ~"foobarbaz\n\n"];
 
-    assert!(test_strs.len() == oracle_strs.len());
+    assert_eq!(test_strs.len(), oracle_strs.len());
     let mode = CompressWhitespace;
 
     for i in range(0, test_strs.len()) {
-        (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == oracle_strs[i])
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
+        assert_eq!(&trimmed_str, &oracle_strs[i])
     }
 }
 
@@ -217,17 +217,17 @@ fn test_transform_compress_whitespace_newline() {
                                  ~"foo bar baz",
                                  ~"foobarbaz "];
 
-    assert!(test_strs.len() == oracle_strs.len());
+    assert_eq!(test_strs.len(), oracle_strs.len());
     let mode = CompressWhitespaceNewline;
 
     for i in range(0, test_strs.len()) {
-        (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == oracle_strs[i])
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
+        assert_eq!(&trimmed_str, &oracle_strs[i])
     }
 }
 
 #[test]
-fn test_transform_compress_whitespace_newline() {
+fn test_transform_compress_whitespace_newline_no_incoming() {
     let  test_strs : ~[~str] = ~[~"  foo bar",
                                  ~"\nfoo bar",
                                  ~"foo bar  ",
@@ -246,11 +246,11 @@ fn test_transform_compress_whitespace_newline() {
                                  ~"foo bar baz",
                                  ~"foobarbaz "];
 
-    assert!(test_strs.len() == oracle_strs.len());
+    assert_eq!(test_strs.len(), oracle_strs.len());
     let mode = CompressWhitespaceNewline;
 
     for i in range(0, test_strs.len()) {
-        (trimmed_str, _out) = transform_text(test_strs[i], mode, false);
-        assert!(trimmed_str == oracle_strs[i])
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, false);
+        assert_eq!(&trimmed_str, &oracle_strs[i])
     }
 }

src/components/net/resource_task.rs

@@ -15,6 +15,9 @@ use extra::url::Url;
 use util::spawn_listener;
 use http::headers::content_type::MediaType;
 
+#[cfg(test)]
+use std::from_str::FromStr;
+
 pub enum ControlMsg {
     /// Request the data associated with a particular URL
     Load(Url, Chan<LoadResponse>),
@@ -191,28 +194,40 @@ fn test_exit() {
 #[test]
 fn test_bad_scheme() {
     let resource_task = ResourceTask();
-    let progress = Port();
-    resource_task.send(Load(url::from_str(~"bogus://whatever").get(), progress.chan()));
-    match progress.recv() {
+    let (start, start_chan) = comm::stream();
+    resource_task.send(Load(FromStr::from_str("bogus://whatever").unwrap(), start_chan));
+    let response = start.recv();
+    match response.progress_port.recv() {
       Done(result) => { assert!(result.is_err()) }
-      _ => fail
+      _ => fail!("bleh")
     }
     resource_task.send(Exit);
 }
 
-#[test]
-fn should_delegate_to_scheme_loader() {
-    let payload = ~[1, 2, 3];
-    let loader_factory = |url: Url, start_chan: Chan<LoadResponse>| {
+#[cfg(test)]
+static snicklefritz_payload: [u8, ..3] = [1, 2, 3];
+
+#[cfg(test)]
+fn snicklefritz_loader_factory() -> LoaderTask {
+    let f: LoaderTask = |url: Url, start_chan: Chan<LoadResponse>| {
         let progress_chan = start_sending(start_chan, Metadata::default(url));
-        progress_chan.send(Payload(payload.clone()));
+        progress_chan.send(Payload(snicklefritz_payload.into_owned()));
         progress_chan.send(Done(Ok(())));
     };
-    let loader_factories = ~[(~"snicklefritz", loader_factory)];
+    f
+}
+
+#[test]
+fn should_delegate_to_scheme_loader() {
+    let loader_factories = ~[(~"snicklefritz", snicklefritz_loader_factory)];
     let resource_task = create_resource_task_with_loaders(loader_factories);
-    let progress = Port();
-    resource_task.send(Load(url::from_str(~"snicklefritz://heya").get(), progress.chan()));
-    assert!(progress.recv() == Payload(payload));
+    let (start, start_chan) = comm::stream();
+    resource_task.send(Load(FromStr::from_str("snicklefritz://heya").unwrap(), start_chan));
+
+    let response = start.recv();
+    let progress = response.progress_port;
+
+    assert!(progress.recv() == Payload(snicklefritz_payload.into_owned()));
     assert!(progress.recv() == Done(Ok(())));
     resource_task.send(Exit);
 }

src/components/util/cache.rs

@@ -51,10 +51,10 @@ impl<K: Clone + Eq, V: Clone> Cache<K,V> for MonoCache<K,V> {
 
 #[test]
 fn test_monocache() {
-    let cache = MonoCache::new(10);
+    let mut cache = MonoCache::new(10);
     let one = @"one";
     let two = @"two";
-    cache.insert(&1, one);
+    cache.insert(1, one);
 
     assert!(cache.find(&1).is_some());
     assert!(cache.find(&2).is_none());
@@ -98,11 +98,11 @@ impl<K: Clone + Eq + Hash, V: Clone> Cache<K,V> for HashCache<K,V> {
 
 #[test]
 fn test_hashcache() {
-    let cache = HashCache::new();
+    let mut cache = HashCache::new();
     let one = @"one";
     let two = @"two";
 
-    cache.insert(&1, one);
+    cache.insert(1, one);
     assert!(cache.find(&1).is_some());
     assert!(cache.find(&2).is_none());
 
@@ -173,17 +173,17 @@ fn test_lru_cache() {
     let four = @"four";
 
     // Test normal insertion.
-    let cache = LRUCache::new(2); // (_, _) (cache is empty)
-    cache.insert(&1, one);    // (1, _)
-    cache.insert(&2, two);    // (1, 2)
-    cache.insert(&3, three);  // (2, 3)
+    let mut cache = LRUCache::new(2); // (_, _) (cache is empty)
+    cache.insert(1, one);    // (1, _)
+    cache.insert(2, two);    // (1, 2)
+    cache.insert(3, three);  // (2, 3)
 
     assert!(cache.find(&1).is_none());  // (2, 3) (no change)
     assert!(cache.find(&3).is_some());  // (2, 3)
     assert!(cache.find(&2).is_some());  // (3, 2)
 
     // Test that LRU works (this insertion should replace 3, not 2).
-    cache.insert(&4, four); // (2, 4)
+    cache.insert(4, four); // (2, 4)
 
     assert!(cache.find(&1).is_none());  // (2, 4) (no change)
     assert!(cache.find(&2).is_some());  // (4, 2)
@@ -191,7 +191,7 @@ fn test_lru_cache() {
     assert!(cache.find(&4).is_some());  // (2, 4) (no change)
 
     // Test find_or_create.
-    do cache.find_or_create(&1) |_| { one } // (4, 1)
+    do cache.find_or_create(&1) |_| { one }; // (4, 1)
 
     assert!(cache.find(&1).is_some()); // (4, 1) (no change)
     assert!(cache.find(&2).is_none()); // (4, 1) (no change)

src/components/util/time.rs

@@ -200,12 +200,9 @@ pub fn time<T>(msg: &str, callback: &fn() -> T) -> T{
     return val;
 }
 
-#[cfg(test)]
-mod test {
-    // ensure that the order of the buckets matches the order of the enum categories
-    #[test]
-    fn check_order() {
-        let buckets = ProfilerCategory::empty_buckets();
-        assert!(buckets.len() == NumBuckets as uint);
-    }
+// ensure that the order of the buckets matches the order of the enum categories
+#[test]
+fn check_order() {
+    let buckets = ProfilerCategory::empty_buckets();
+    assert!(buckets.len() == NumBuckets as uint);
 }

src/components/util/url.rs

@@ -77,7 +77,10 @@ pub fn make_url(str_url: ~str, current_url: Option<Url>) -> Url {
     url::from_str(str_url).unwrap()
 }
 
+#[cfg(test)]
 mod make_url_tests {
+    use super::make_url;
+    use std::os;
 
     #[test]
     fn should_create_absolute_file_url_if_current_url_is_none_and_str_url_looks_filey() {