Fix unit tests.

components/net/data_loader.rs

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

components/net/image_cache_task.rs

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

components/net/mime_classifier.rs

@@ -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,36 +1010,33 @@ 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/");
 
         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),
         }
     }