Mirrors/servo
1
0
Fork 0
mirror of https://github.com/servo/servo.git synced 2025-08-05 05:30:08 +01:00
Code Issues Projects Releases Packages Wiki Activity

Fix bitrotten tests

Browse source
This commit is contained in:
Keegan McAllister 2013-10-10 16:39:48 -07:00
parent bb4b9d6195
commit b33af8852e
6 changed files with 592 additions and 566 deletions
Download patch file Download diff file Expand all files Collapse all files

32
src/components/gfx/text/util.rs
View file

@ -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])
}
}

367
src/components/net/image_cache_task.rs
View file

@ -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,106 +468,120 @@ fn default_decoder_factory() -> ~fn(&[u8]) -> Option<Image> {
}
#[cfg(test)]
fn mock_resource_task(on_load: ~fn(resource: Chan<resource_task::ProgressMsg>)) -> ResourceTask {
do spawn_listener |port: Port<resource_task::ControlMsg>| {
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 {
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() {
#[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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
#[should_fail]
fn should_fail_if_unprefetched_image_is_requested() {
#[test]
#[should_fail]
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_chan = url_requested.chan();
#[test]
fn should_request_url_from_resource_task_on_prefetch() {
let (url_requested, url_requested_chan) = comm::stream();
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));
url_requested.recv();
image_cache_task.exit();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
#[should_fail]
fn should_fail_if_requesting_decode_of_an_unprefetched_image() {
#[test]
#[should_fail]
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));
image_cache_task.exit();
}
}
#[test]
#[should_fail]
fn should_fail_if_requesting_image_before_requesting_decode() {
#[test]
#[should_fail]
fn should_fail_if_requesting_image_before_requesting_decode() {
let mock_resource_task = do mock_resource_task |response| {
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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_not_request_url_from_resource_task_on_multiple_prefetches() {
let url_requested = comm::Port();
let url_requested_chan = url_requested.chan();
#[test]
fn should_not_request_url_from_resource_task_on_multiple_prefetches() {
let (url_requested, url_requested_chan) = comm::stream();
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()));
@ -572,11 +590,11 @@ fn should_not_request_url_from_resource_task_on_multiple_prefetches() {
image_cache_task.exit();
mock_resource_task.send(resource_task::Exit);
assert!(!url_requested.peek())
}
}
#[test]
fn should_return_image_not_ready_if_data_has_not_arrived() {
let (wait_chan, wait_port) = pipes::stream();
#[test]
fn should_return_image_not_ready_if_data_has_not_arrived() {
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,68 +604,30 @@ 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(());
image_cache_task.exit();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_return_decoded_image_data_if_data_has_arrived() {
#[test]
fn should_return_decoded_image_data_if_data_has_arrived() {
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 image_cache_task = ImageCacheTask(mock_resource_task.clone());
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 {
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();
let (wait_for_image, wait_for_image_chan) = comm::stream();
image_cache_task.send(OnMsg(|msg| {
match *msg {
@ -662,33 +642,68 @@ 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_chan, response_port) = stream();
let (response_port, response_chan) = 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")
}
}
image_cache_task.exit();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_not_request_image_from_resource_task_if_image_is_already_available() {
let image_bin_sent = comm::Port();
let image_bin_sent_chan = image_bin_sent.chan();
#[test]
fn should_not_request_image_from_resource_task_if_image_is_already_available() {
let (image_bin_sent, image_bin_sent_chan) = comm::stream();
let resource_task_exited = comm::Port();
let resource_task_exited_chan = resource_task_exited.chan();
let (resource_task_exited, resource_task_exited_chan) = comm::stream();
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()));
response.send(resource_task::Done(result::Ok(())));
let chan = start_sending(response, Metadata::default(make_url(~"file:///fake", None)));
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()));
@ -717,22 +733,21 @@ fn should_not_request_image_from_resource_task_if_image_is_already_available() {
// Our resource task should not have received another request for the image
// because it's already cached
assert!(!image_bin_sent.peek());
}
}
#[test]
fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
let image_bin_sent = comm::Port();
let image_bin_sent_chan = image_bin_sent.chan();
#[test]
fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
let (image_bin_sent, image_bin_sent_chan) = comm::stream();
let resource_task_exited = comm::Port();
let resource_task_exited_chan = resource_task_exited.chan();
let (resource_task_exited, resource_task_exited_chan) = comm::stream();
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()));
response.send(resource_task::Done(result::Err(())));
let chan = start_sending(response, Metadata::default(make_url(~"file:///fake", None)));
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()));
@ -763,21 +779,20 @@ fn should_not_request_image_from_resource_task_if_image_fetch_already_failed() {
// Our resource task should not have received another request for the image
// because it's already cached
assert!(!image_bin_sent.peek());
}
}
#[test]
fn should_return_failed_if_image_bin_cannot_be_fetched() {
#[test]
fn should_return_failed_if_image_bin_cannot_be_fetched() {
let mock_resource_task = do mock_resource_task |response| {
response.send(resource_task::Payload(test_image_bin()));
// ERROR fetching image
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_chan = wait_for_prefetech.chan();
let (wait_for_prefetech, wait_for_prefetech_chan) = comm::stream();
image_cache_task.send(OnMsg(|msg| {
match *msg {
@ -792,30 +807,29 @@ 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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_return_failed_for_multiple_get_image_requests_if_image_bin_cannot_be_fetched() {
#[test]
fn should_return_failed_for_multiple_get_image_requests_if_image_bin_cannot_be_fetched() {
let mock_resource_task = do mock_resource_task |response | {
response.send(resource_task::Payload(test_image_bin()));
// ERROR fetching image
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_chan = wait_for_prefetech.chan();
let (wait_for_prefetech, wait_for_prefetech_chan) = comm::stream();
image_cache_task.send(OnMsg(|msg| {
match *msg {
@ -830,36 +844,36 @@ 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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_return_not_ready_if_image_is_still_decoding() {
let (wait_to_decode_chan, wait_to_decode_port) = pipes::stream();
#[test]
fn should_return_not_ready_if_image_is_still_decoding() {
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 decoder_factory = || {
let wait_to_decode_port_cell = Cell::new(wait_to_decode_port);
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_chan = wait_for_prefetech.chan();
let (wait_for_prefetech, wait_for_prefetech_chan) = comm::stream();
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
@ -901,21 +914,20 @@ fn should_return_not_ready_if_image_is_still_decoding() {
image_cache_task.exit();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_return_failed_if_image_decode_fails() {
#[test]
fn should_return_failed_if_image_decode_fails() {
let mock_resource_task = do mock_resource_task |response| {
// Bogus data
response.send(resource_task::Payload(~[]));
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_chan = wait_for_decode.chan();
let (wait_for_decode, wait_for_decode_chan) = comm::stream();
image_cache_task.send(OnMsg(|msg| {
match *msg {
@ -931,30 +943,29 @@ 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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_return_image_on_wait_if_image_is_already_loaded() {
#[test]
fn should_return_image_on_wait_if_image_is_already_loaded() {
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 image_cache_task = ImageCacheTask(mock_resource_task.clone());
let url = make_url(~"file", None);
let wait_for_decode = comm::Port();
let wait_for_decode_chan = wait_for_decode.chan();
let (wait_for_decode, wait_for_decode_chan) = comm::stream();
image_cache_task.send(OnMsg(|msg| {
match *msg {
@ -969,20 +980,20 @@ 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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_return_image_on_wait_if_image_is_not_yet_loaded() {
let (wait_chan, wait_port) = pipes::stream();
#[test]
fn should_return_image_on_wait_if_image_is_not_yet_loaded() {
let (wait_port, wait_chan) = comm::stream();
let mock_resource_task = do mock_resource_task |response| {
wait_port.recv();
@ -990,29 +1001,29 @@ 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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn should_return_image_failed_on_wait_if_image_fails_to_load() {
let (wait_chan, wait_port) = pipes::stream();
#[test]
fn should_return_image_failed_on_wait_if_image_fails_to_load() {
let (wait_port, wait_chan) = comm::stream();
let mock_resource_task = do mock_resource_task |response| {
wait_port.recv();
@ -1020,47 +1031,47 @@ 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();
mock_resource_task.send(resource_task::Exit);
}
}
#[test]
fn sync_cache_should_wait_for_images() {
#[test]
fn sync_cache_should_wait_for_images() {
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 = 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);
}
}

41
src/components/net/resource_task.rs
View file

@ -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);
}

20
src/components/util/cache.rs
View file

@ -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)

9
src/components/util/time.rs
View file

@ -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() {
// 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);
}
}

3
src/components/util/url.rs
View file

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