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);
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == test_strs[i])
+        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);
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == oracle_strs[i])
+        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);
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == oracle_strs[i])
+        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);
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, true);
-        assert!(trimmed_str == oracle_strs[i])
+        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);
+        let (trimmed_str, _out) = transform_text(test_strs[i], mode, false);
-        assert!(trimmed_str == oracle_strs[i])
+        assert_eq!(&trimmed_str, &oracle_strs[i])
     }
 }

src/components/net/image_cache_task.rs

@@ -22,14 +22,16 @@ pub enum Msg {
     Prefetch(Url),
 
     // FIXME: We can probably get rid of this Cell now
+    // FIXME: make this priv after visibility rules change
     /// Used be the prefetch tasks to post back image binaries
-    priv StorePrefetchedImageData(Url, Result<Cell<~[u8]>, ()>),
+    StorePrefetchedImageData(Url, Result<Cell<~[u8]>, ()>),
 
     /// Tell the cache to decode an image. Must be posted before GetImage/WaitForImage
     Decode(Url),
 
     /// Used by the decoder tasks to post decoded images back to the cache
-    priv StoreImage(Url, Option<Arc<~Image>>),
+    // FIXME: make this priv after visibility rules change
+    StoreImage(Url, Option<Arc<~Image>>),
 
     /// Request an Image object for a URL. If the image is not is not immediately
     /// available then ImageNotReady is returned.
@@ -39,7 +41,8 @@ pub enum Msg {
     WaitForImage(Url, Chan<ImageResponseMsg>),
 
     /// For testing
-    priv OnMsg(~fn(msg: &Msg)),
+    // FIXME: make this priv after visibility rules change
+    OnMsg(~fn(msg: &Msg)),
 
     /// Clients must wait for a response before shutting down the ResourceTask
     Exit(Chan<()>),
@@ -114,7 +117,8 @@ pub fn ImageCacheTask_(resource_task: ResourceTask, decoder_factory: DecoderFact
     chan
 }
 
-fn SyncImageCacheTask(resource_task: ResourceTask) -> ImageCacheTask {
+// FIXME: make this priv after visibility rules change
+pub fn SyncImageCacheTask(resource_task: ResourceTask) -> ImageCacheTask {
     let (port, chan) = stream();
     let port_cell = Cell::new(port);
 
@@ -464,24 +468,40 @@ fn default_decoder_factory() -> ~fn(&[u8]) -> Option<Image> {
 }
 
 #[cfg(test)]
+mod tests {
+    use super::*;
+
+    use std::comm;
+    use std::comm::{Port, SharedChan};
+    use std::result;
+    use std::cell::Cell;
+
+    use resource_task;
+    use resource_task::{ResourceTask, Metadata, start_sending};
+    use image::base::{Image, test_image_bin, load_from_memory};
+    use util::spawn_listener;
+    use servo_util::url::make_url;
+
     fn mock_resource_task(on_load: ~fn(resource: Chan<resource_task::ProgressMsg>)) -> ResourceTask {
-    do spawn_listener |port: Port<resource_task::ControlMsg>| {
+        let chan = do spawn_listener |port: Port<resource_task::ControlMsg>| {
             loop {
                 match port.recv() {
                     resource_task::Load(_, response) => {
-                on_load(response);
+                        let chan = start_sending(response, Metadata::default(make_url(~"file:///fake", None)));
+                        on_load(chan);
                     }
                     resource_task::Exit => break
                 }
             }
-    }
+        };
+        SharedChan::new(chan)
     }
 
     #[test]
     fn should_exit_on_request() {
         let mock_resource_task = mock_resource_task(|_response| () );
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let _url = make_url(~"file", None);
 
         image_cache_task.exit();
@@ -493,25 +513,24 @@ fn should_exit_on_request() {
     fn should_fail_if_unprefetched_image_is_requested() {
         let mock_resource_task = mock_resource_task(|_response| () );
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
-    let (chan, port) = stream();
+        let (port, chan) = stream();
         image_cache_task.send(GetImage(url, chan));
         port.recv();
     }
 
     #[test]
     fn should_request_url_from_resource_task_on_prefetch() {
-    let url_requested = Port();
+        let (url_requested, url_requested_chan) = comm::stream();
-    let url_requested_chan = url_requested.chan();
 
         let mock_resource_task = do mock_resource_task |response| {
             url_requested_chan.send(());
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url));
@@ -526,7 +545,7 @@ fn should_request_url_from_resource_task_on_prefetch() {
     fn should_fail_if_requesting_decode_of_an_unprefetched_image() {
         let mock_resource_task = mock_resource_task(|_response| () );
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Decode(url));
@@ -540,13 +559,13 @@ fn should_fail_if_requesting_image_before_requesting_decode() {
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
         // no decode message
 
-    let (chan, _port) = stream();
+        let (_port, chan) = stream();
         image_cache_task.send(GetImage(url, chan));
 
         image_cache_task.exit();
@@ -555,15 +574,14 @@ fn should_fail_if_requesting_image_before_requesting_decode() {
 
     #[test]
     fn should_not_request_url_from_resource_task_on_multiple_prefetches() {
-    let url_requested = comm::Port();
+        let (url_requested, url_requested_chan) = comm::stream();
-    let url_requested_chan = url_requested.chan();
 
         let mock_resource_task = do mock_resource_task |response| {
             url_requested_chan.send(());
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
@@ -576,7 +594,7 @@ fn should_not_request_url_from_resource_task_on_multiple_prefetches() {
 
     #[test]
     fn should_return_image_not_ready_if_data_has_not_arrived() {
-    let (wait_chan, wait_port) = pipes::stream();
+        let (wait_port, wait_chan) = comm::stream();
 
         let mock_resource_task = do mock_resource_task |response| {
             // Don't send the data until after the client requests
@@ -586,12 +604,12 @@ fn should_return_image_not_ready_if_data_has_not_arrived() {
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
         image_cache_task.send(Decode(url.clone()));
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(GetImage(url, response_chan));
         assert!(response_port.recv() == ImageNotReady);
         wait_chan.send(());
@@ -606,48 +624,10 @@ fn should_return_decoded_image_data_if_data_has_arrived() {
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
-    let wait_for_image = comm::Port();
+        let (wait_for_image, wait_for_image_chan) = comm::stream();
-    let wait_for_image_chan = wait_for_image.chan();
-
-    image_cache_task.send(OnMsg(|msg| {
-        match *msg {
-          StoreImage(*) => wait_for_image_chan.send(()),
-          _ => ()
-        }
-    }));
-
-    image_cache_task.send(Prefetch(url.clone()));
-    image_cache_task.send(Decode(url.clone()));
-
-    // Wait until our mock resource task has sent the image to the image cache
-    wait_for_image_chan.recv();
-
-    let (response_chan, response_port) = stream();
-    image_cache_task.send(GetImage(url, response_chan));
-    match response_port.recv() {
-      ImageReady(_) => (),
-      _ => fail
-    }
-
-    image_cache_task.exit();
-    mock_resource_task.send(resource_task::Exit);
-}
-
-#[test]
-fn should_return_decoded_image_data_for_multiple_requests() {
-    let mock_resource_task = do mock_resource_task |response| {
-        response.send(resource_task::Payload(test_image_bin()));
-        response.send(resource_task::Done(result::Ok(())));
-    };
-
-    let image_cache_task = ImageCacheTask(mock_resource_task);
-    let url = make_url(~"file", None);
-
-    let wait_for_image = comm::Port();
-    let wait_for_image_chan = wait_for_image.chan();
 
         image_cache_task.send(OnMsg(|msg| {
             match *msg {
@@ -662,12 +642,48 @@ fn should_return_decoded_image_data_for_multiple_requests() {
         // Wait until our mock resource task has sent the image to the image cache
         wait_for_image.recv();
 
-    for _ in iter::repeat(2) {
+        let (response_port, response_chan) = stream();
-        let (response_chan, response_port) = stream();
+        image_cache_task.send(GetImage(url, response_chan));
+        match response_port.recv() {
+          ImageReady(_) => (),
+          _ => fail!("bleh")
+        }
+
+        image_cache_task.exit();
+        mock_resource_task.send(resource_task::Exit);
+    }
+
+    #[test]
+    fn should_return_decoded_image_data_for_multiple_requests() {
+        let mock_resource_task = do mock_resource_task |response| {
+            response.send(resource_task::Payload(test_image_bin()));
+            response.send(resource_task::Done(result::Ok(())));
+        };
+
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
+        let url = make_url(~"file", None);
+
+        let (wait_for_image, wait_for_image_chan) = comm::stream();
+
+        image_cache_task.send(OnMsg(|msg| {
+            match *msg {
+              StoreImage(*) => wait_for_image_chan.send(()),
+              _ => ()
+            }
+        }));
+
+        image_cache_task.send(Prefetch(url.clone()));
+        image_cache_task.send(Decode(url.clone()));
+
+        // Wait until our mock resource task has sent the image to the image cache
+        wait_for_image.recv();
+
+        for _ in range(0,2) {
+            let (response_port, response_chan) = stream();
             image_cache_task.send(GetImage(url.clone(), response_chan));
             match response_port.recv() {
               ImageReady(_) => (),
-          _ => fail
+              _ => fail!("bleh")
             }
         }
 
@@ -677,18 +693,17 @@ fn should_return_decoded_image_data_for_multiple_requests() {
 
     #[test]
     fn should_not_request_image_from_resource_task_if_image_is_already_available() {
-    let image_bin_sent = comm::Port();
+        let (image_bin_sent, image_bin_sent_chan) = comm::stream();
-    let image_bin_sent_chan = image_bin_sent.chan();
 
-    let resource_task_exited = comm::Port();
+        let (resource_task_exited, resource_task_exited_chan) = comm::stream();
-    let resource_task_exited_chan = resource_task_exited.chan();
 
         let mock_resource_task = do spawn_listener |port: comm::Port<resource_task::ControlMsg>| {
             loop {
                 match port.recv() {
                     resource_task::Load(_, response) => {
-                    response.send(resource_task::Payload(test_image_bin()));
+                        let chan = start_sending(response, Metadata::default(make_url(~"file:///fake", None)));
-                    response.send(resource_task::Done(result::Ok(())));
+                        chan.send(resource_task::Payload(test_image_bin()));
+                        chan.send(resource_task::Done(result::Ok(())));
                         image_bin_sent_chan.send(());
                     }
                     resource_task::Exit => {
@@ -698,8 +713,9 @@ fn should_not_request_image_from_resource_task_if_image_is_already_available() {
                 }
             }
         };
+        let mock_resource_task = SharedChan::new(mock_resource_task);
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
@@ -721,18 +737,17 @@ fn should_not_request_image_from_resource_task_if_image_is_already_available() {
 
     #[test]
     fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
-    let image_bin_sent = comm::Port();
+        let (image_bin_sent, image_bin_sent_chan) = comm::stream();
-    let image_bin_sent_chan = image_bin_sent.chan();
 
-    let resource_task_exited = comm::Port();
+        let (resource_task_exited, resource_task_exited_chan) = comm::stream();
-    let resource_task_exited_chan = resource_task_exited.chan();
 
         let mock_resource_task = do spawn_listener |port: comm::Port<resource_task::ControlMsg>| {
             loop {
                 match port.recv() {
                     resource_task::Load(_, response) => {
-                    response.send(resource_task::Payload(test_image_bin()));
+                        let chan = start_sending(response, Metadata::default(make_url(~"file:///fake", None)));
-                    response.send(resource_task::Done(result::Err(())));
+                        chan.send(resource_task::Payload(test_image_bin()));
+                        chan.send(resource_task::Done(result::Err(())));
                         image_bin_sent_chan.send(());
                     }
                     resource_task::Exit => {
@@ -742,8 +757,9 @@ fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
                 }
             }
         };
+        let mock_resource_task = SharedChan::new(mock_resource_task);
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
@@ -773,11 +789,10 @@ fn should_return_failed_if_image_bin_cannot_be_fetched() {
             response.send(resource_task::Done(result::Err(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
-    let wait_for_prefetech = comm::Port();
+        let (wait_for_prefetech, wait_for_prefetech_chan) = comm::stream();
-    let wait_for_prefetech_chan = wait_for_prefetech.chan();
 
         image_cache_task.send(OnMsg(|msg| {
             match *msg {
@@ -792,11 +807,11 @@ fn should_return_failed_if_image_bin_cannot_be_fetched() {
         // Wait until our mock resource task has sent the image to the image cache
         wait_for_prefetech.recv();
 
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(GetImage(url, response_chan));
         match response_port.recv() {
           ImageFailed => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         image_cache_task.exit();
@@ -811,11 +826,10 @@ fn should_return_failed_for_multiple_get_image_requests_if_image_bin_cannot_be_f
             response.send(resource_task::Done(result::Err(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
-    let wait_for_prefetech = comm::Port();
+        let (wait_for_prefetech, wait_for_prefetech_chan) = comm::stream();
-    let wait_for_prefetech_chan = wait_for_prefetech.chan();
 
         image_cache_task.send(OnMsg(|msg| {
             match *msg {
@@ -830,19 +844,19 @@ fn should_return_failed_for_multiple_get_image_requests_if_image_bin_cannot_be_f
         // Wait until our mock resource task has sent the image to the image cache
         wait_for_prefetech.recv();
 
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(GetImage(url.clone(), response_chan));
         match response_port.recv() {
           ImageFailed => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         // And ask again, we should get the same response
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(GetImage(url, response_chan));
         match response_port.recv() {
           ImageFailed => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         image_cache_task.exit();
@@ -851,15 +865,15 @@ fn should_return_failed_for_multiple_get_image_requests_if_image_bin_cannot_be_f
 
     #[test]
     fn should_return_not_ready_if_image_is_still_decoding() {
-    let (wait_to_decode_chan, wait_to_decode_port) = pipes::stream();
+        let (wait_to_decode_port, wait_to_decode_chan) = comm::stream();
 
         let mock_resource_task = do mock_resource_task |response| {
             response.send(resource_task::Payload(test_image_bin()));
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let wait_to_decode_port_cell = Cell(wait_to_decode_port);
+        let wait_to_decode_port_cell = Cell::new(wait_to_decode_port);
-    let decoder_factory = || {
+        let decoder_factory: ~fn:Send() -> ~fn:Send(&[u8]) -> Option<Image> = || {
             let wait_to_decode_port = wait_to_decode_port_cell.take();
             |data: &[u8]| {
                 // Don't decode until after the client requests the image
@@ -868,11 +882,10 @@ fn should_return_not_ready_if_image_is_still_decoding() {
             }
         };
 
-    let image_cache_task = ImageCacheTask_(mock_resource_task, decoder_factory);
+        let image_cache_task = ImageCacheTask_(mock_resource_task.clone(), decoder_factory);
         let url = make_url(~"file", None);
 
-    let wait_for_prefetech = comm::Port();
+        let (wait_for_prefetech, wait_for_prefetech_chan) = comm::stream();
-    let wait_for_prefetech_chan = wait_for_prefetech.chan();
 
         image_cache_task.send(OnMsg(|msg| {
             match *msg {
@@ -888,12 +901,12 @@ fn should_return_not_ready_if_image_is_still_decoding() {
         wait_for_prefetech.recv();
 
         // Make the request
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(GetImage(url, response_chan));
 
         match response_port.recv() {
           ImageNotReady => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         // Now decode
@@ -911,11 +924,10 @@ fn should_return_failed_if_image_decode_fails() {
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
-    let wait_for_decode = comm::Port();
+        let (wait_for_decode, wait_for_decode_chan) = comm::stream();
-    let wait_for_decode_chan = wait_for_decode.chan();
 
         image_cache_task.send(OnMsg(|msg| {
             match *msg {
@@ -931,12 +943,12 @@ fn should_return_failed_if_image_decode_fails() {
         wait_for_decode.recv();
 
         // Make the request
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(GetImage(url, response_chan));
 
         match response_port.recv() {
           ImageFailed => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         image_cache_task.exit();
@@ -950,11 +962,10 @@ fn should_return_image_on_wait_if_image_is_already_loaded() {
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
-    let wait_for_decode = comm::Port();
+        let (wait_for_decode, wait_for_decode_chan) = comm::stream();
-    let wait_for_decode_chan = wait_for_decode.chan();
 
         image_cache_task.send(OnMsg(|msg| {
             match *msg {
@@ -969,11 +980,11 @@ fn should_return_image_on_wait_if_image_is_already_loaded() {
         // Wait until our mock resource task has sent the image to the image cache
         wait_for_decode.recv();
 
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(WaitForImage(url, response_chan));
         match response_port.recv() {
           ImageReady(*) => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         image_cache_task.exit();
@@ -982,7 +993,7 @@ fn should_return_image_on_wait_if_image_is_already_loaded() {
 
     #[test]
     fn should_return_image_on_wait_if_image_is_not_yet_loaded() {
-    let (wait_chan, wait_port) = pipes::stream();
+        let (wait_port, wait_chan) = comm::stream();
 
         let mock_resource_task = do mock_resource_task |response| {
             wait_port.recv();
@@ -990,20 +1001,20 @@ fn should_return_image_on_wait_if_image_is_not_yet_loaded() {
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
         image_cache_task.send(Decode(url.clone()));
 
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(WaitForImage(url, response_chan));
 
         wait_chan.send(());
 
         match response_port.recv() {
           ImageReady(*) => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         image_cache_task.exit();
@@ -1012,7 +1023,7 @@ fn should_return_image_on_wait_if_image_is_not_yet_loaded() {
 
     #[test]
     fn should_return_image_failed_on_wait_if_image_fails_to_load() {
-    let (wait_chan, wait_port) = pipes::stream();
+        let (wait_port, wait_chan) = comm::stream();
 
         let mock_resource_task = do mock_resource_task |response| {
             wait_port.recv();
@@ -1020,20 +1031,20 @@ fn should_return_image_failed_on_wait_if_image_fails_to_load() {
             response.send(resource_task::Done(result::Err(())));
         };
 
-    let image_cache_task = ImageCacheTask(mock_resource_task);
+        let image_cache_task = ImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
         image_cache_task.send(Decode(url.clone()));
 
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(WaitForImage(url, response_chan));
 
         wait_chan.send(());
 
         match response_port.recv() {
           ImageFailed => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         image_cache_task.exit();
@@ -1047,20 +1058,20 @@ fn sync_cache_should_wait_for_images() {
             response.send(resource_task::Done(result::Ok(())));
         };
 
-    let image_cache_task = SyncImageCacheTask(mock_resource_task);
+        let image_cache_task = SyncImageCacheTask(mock_resource_task.clone());
         let url = make_url(~"file", None);
 
         image_cache_task.send(Prefetch(url.clone()));
         image_cache_task.send(Decode(url.clone()));
 
-    let (response_chan, response_port) = stream();
+        let (response_port, response_chan) = stream();
         image_cache_task.send(GetImage(url, response_chan));
         match response_port.recv() {
           ImageReady(_) => (),
-      _ => fail
+          _ => fail!("bleh")
         }
 
         image_cache_task.exit();
         mock_resource_task.send(resource_task::Exit);
     }
-
+}

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();
+    let (start, start_chan) = comm::stream();
-    resource_task.send(Load(url::from_str(~"bogus://whatever").get(), progress.chan()));
+    resource_task.send(Load(FromStr::from_str("bogus://whatever").unwrap(), start_chan));
-    match progress.recv() {
+    let response = start.recv();
+    match response.progress_port.recv() {
       Done(result) => { assert!(result.is_err()) }
-      _ => fail
+      _ => fail!("bleh")
     }
     resource_task.send(Exit);
 }
 
-#[test]
+#[cfg(test)]
-fn should_delegate_to_scheme_loader() {
+static snicklefritz_payload: [u8, ..3] = [1, 2, 3];
-    let payload = ~[1, 2, 3];
+
-    let loader_factory = |url: Url, start_chan: Chan<LoadResponse>| {
+#[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();
+    let (start, start_chan) = comm::stream();
-    resource_task.send(Load(url::from_str(~"snicklefritz://heya").get(), progress.chan()));
+    resource_task.send(Load(FromStr::from_str("snicklefritz://heya").unwrap(), start_chan));
-    assert!(progress.recv() == Payload(payload));
+
+    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)
+    let mut cache = LRUCache::new(2); // (_, _) (cache is empty)
-    cache.insert(&1, one);    // (1, _)
+    cache.insert(1, one);    // (1, _)
-    cache.insert(&2, two);    // (1, 2)
+    cache.insert(2, two);    // (1, 2)
-    cache.insert(&3, three);  // (2, 3)
+    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);
 }
-}

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() {