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

Fix unit tests.

Browse source
This commit is contained in:
Josh Matthews 2015-02-21 12:25:06 -05:00
parent 23ae940abf
commit 4a78da1158
3 changed files with 20 additions and 39 deletions
Download patch file Download diff file Expand all files Collapse all files

6
components/net/data_loader.rs
View file

@ -13,15 +13,15 @@ use hyper::mime::Mime;
use std::sync::Arc;
use url::{percent_decode, SchemeData};
pub fn factory(load_data: LoadData, classifier: Arc<MIMEClassifier>) {
pub fn factory(load_data: LoadData, _classifier: Arc<MIMEClassifier>) {
// NB: we don't spawn a new task.
// Hypothesis: data URLs are too small for parallel base64 etc. to be worth it.
// Should be tested at some point.
// Left in separate function to allow easy moving to a task, if desired.
load(load_data, classifier)
load(load_data)
}
fn load(load_data: LoadData, _classifier: Arc<MIMEClassifier>) {
fn load(load_data: LoadData) {
let start_chan = load_data.consumer;
let url = load_data.url;
assert!(&*url.scheme == "data");

24
components/net/image_cache_task.rs
View file

@ -428,11 +428,10 @@ mod tests {
use net_traits::image_cache_task::ImageResponseMsg::*;
use net_traits::image_cache_task::Msg::*;
use resource_task::{start_sending, ResponseSenders};
use resource_task::start_sending;
use net_traits::{ControlMsg, Metadata, ProgressMsg, ResourceTask};
use net_traits::image_cache_task::{ImageCacheTask, ImageResponseMsg, Msg};
use net_traits::ProgressMsg::{Payload, Done};
use sniffer_task;
use profile::time;
use std::sync::mpsc::{Sender, channel, Receiver};
use url::Url;
@ -534,12 +533,7 @@ mod tests {
loop {
match port.recv().unwrap() {
ControlMsg::Load(response) => {
let sniffer_task = sniffer_task::new_sniffer_task();
let senders = ResponseSenders {
immediate_consumer: sniffer_task,
eventual_consumer: response.consumer.clone(),
};
let chan = start_sending(senders, Metadata::default(
let chan = start_sending(response.consumer, Metadata::default(
Url::parse("file:///fake").unwrap()));
on_load.invoke(chan);
}
@ -709,12 +703,7 @@ mod tests {
loop {
match port.recv().unwrap() {
ControlMsg::Load(response) => {
let sniffer_task = sniffer_task::new_sniffer_task();
let senders = ResponseSenders {
immediate_consumer: sniffer_task,
eventual_consumer: response.consumer.clone(),
};
let chan = start_sending(senders, Metadata::default(
let chan = start_sending(response.consumer, Metadata::default(
Url::parse("file:///fake").unwrap()));
chan.send(Payload(test_image_bin()));
chan.send(Done(Ok(())));
@ -763,12 +752,7 @@ mod tests {
loop {
match port.recv().unwrap() {
ControlMsg::Load(response) => {
let sniffer_task = sniffer_task::new_sniffer_task();
let senders = ResponseSenders {
immediate_consumer: sniffer_task,
eventual_consumer: response.consumer.clone(),
};
let chan = start_sending(senders, Metadata::default(
let chan = start_sending(response.consumer, Metadata::default(
Url::parse("file:///fake").unwrap()));
chan.send(Payload(test_image_bin()));
chan.send(Done(Err("".to_string())));

29
components/net/mime_classifier.rs
View file

@ -983,7 +983,7 @@ impl ByteMatcher {
#[cfg(test)]
mod tests {
use std::io::File;
use std::old_io::File;
use std::os;
use super::Mp4Matcher;
use super::MIMEClassifier;
@ -998,7 +998,7 @@ mod tests {
let read_result = file.read_to_end();
match read_result {
Ok(data) => {
println!("Data Length {:u}",data.len());
println!("Data Length {:?}",data.len());
if !matcher.matches(&data) {
panic!("Didn't read mime type")
}
@ -1010,7 +1010,7 @@ mod tests {
#[cfg(test)]
fn test_sniff_full(filename_orig: &Path,type_string: &str,subtype_string: &str,
supplied_type: Option<(&'static str,&'static str)>){
let current_working_directory = os::getcwd();
let current_working_directory = os::getcwd().unwrap();
println!("The current directory is {}", current_working_directory.display());
let mut filename = Path::new("../../tests/content/parsable_mime/");
@ -1018,28 +1018,25 @@ mod tests {
filename.push(filename_orig);
let classifier = MIMEClassifier::new();
let mut file = File::open(&filename);
let read_result = file.read_to_end();
match read_result {
Ok(data) => {
match classifier.classify(false,false,&as_string_option(supplied_type),&data)
{
Some(mime) => {
let parsed_type=mime.ref0().as_slice();
let parsed_subtp=mime.ref1().as_slice();
if (parsed_type!=type_string)||
(parsed_subtp!=subtype_string) {
match classifier.classify(false, false, &as_string_option(supplied_type), &data) {
Some((parsed_type, parsed_subtp)) => {
if (parsed_type.as_slice() != type_string) ||
(parsed_subtp.as_slice() != subtype_string) {
panic!("File {} parsed incorrectly should be {}/{}, parsed as {}/{}",
filename.as_str(),type_string,subtype_string,parsed_type,
parsed_subtp);
filename.as_str().unwrap(), type_string, subtype_string,
parsed_type, parsed_subtp);
}
}
None => {panic!("No classification found for {} with supplied type {}",filename.as_str(),supplied_type);}
None => panic!("No classification found for {} with supplied type {:?}",
filename.as_str().unwrap(), supplied_type),
}
}
Err(e) => {panic!("Couldn't read from file {} with error {}",filename.as_str(),e);}
Err(e) => panic!("Couldn't read from file {} with error {}",
filename.as_str().unwrap(), e),
}
}