Fix tests

Author: brson

color.rs

@@ -191,61 +191,60 @@ pub mod parsing {
 mod test {
     use super::{rgb, rgba};
     use super::css_colors::*;
-    use option::unwrap;
     use super::parsing::parse_color;
 
     #[test]
     fn test_parse_by_name() {
-        assert!(red().eq(&unwrap(parse_color(~"red"))));
-        assert!(lime().eq(&unwrap(parse_color(~"Lime"))));
-        assert!(blue().eq(&unwrap(parse_color(~"BLUE"))));
-        assert!(green().eq(&unwrap(parse_color(~"GreEN"))));
-        assert!(white().eq(&unwrap(parse_color(~"white"))));
-        assert!(black().eq(&unwrap(parse_color(~"Black"))));
-        assert!(gray().eq(&unwrap(parse_color(~"Gray"))));
-        assert!(silver().eq(&unwrap(parse_color(~"SiLvEr"))));
-        assert!(maroon().eq(&unwrap(parse_color(~"maroon"))));
-        assert!(purple().eq(&unwrap(parse_color(~"PURPLE"))));
-        assert!(fuchsia().eq(&unwrap(parse_color(~"FUCHSIA"))));
-        assert!(olive().eq(&unwrap(parse_color(~"oLiVe"))));
-        assert!(yellow().eq(&unwrap(parse_color(~"yellow"))));
-        assert!(navy().eq(&unwrap(parse_color(~"NAVY"))));
-        assert!(teal().eq(&unwrap(parse_color(~"Teal"))));
-        assert!(aqua().eq(&unwrap(parse_color(~"Aqua"))));
+        assert!(red().eq(&parse_color(~"red").unwrap()));
+        assert!(lime().eq(&parse_color(~"Lime").unwrap()));
+        assert!(blue().eq(&parse_color(~"BLUE").unwrap()));
+        assert!(green().eq(&parse_color(~"GreEN").unwrap()));
+        assert!(white().eq(&parse_color(~"white").unwrap()));
+        assert!(black().eq(&parse_color(~"Black").unwrap()));
+        assert!(gray().eq(&parse_color(~"Gray").unwrap()));
+        assert!(silver().eq(&parse_color(~"SiLvEr").unwrap()));
+        assert!(maroon().eq(&parse_color(~"maroon").unwrap()));
+        assert!(purple().eq(&parse_color(~"PURPLE").unwrap()));
+        assert!(fuchsia().eq(&parse_color(~"FUCHSIA").unwrap()));
+        assert!(olive().eq(&parse_color(~"oLiVe").unwrap()));
+        assert!(yellow().eq(&parse_color(~"yellow").unwrap()));
+        assert!(navy().eq(&parse_color(~"NAVY").unwrap()));
+        assert!(teal().eq(&parse_color(~"Teal").unwrap()));
+        assert!(aqua().eq(&parse_color(~"Aqua").unwrap()));
         assert!(None == parse_color(~"foobarbaz"));
     }
 
     #[test]
     fn test_parsing_rgb() {
-        assert!(red().eq(&unwrap(parse_color(~"rgb(255,0,0)"))));
-        assert!(red().eq(&unwrap(parse_color(~"rgba(255,0,0,1.0)"))));
-        assert!(red().eq(&unwrap(parse_color(~"rgba(255,0,0,1)"))));
-        assert!(lime().eq(&unwrap(parse_color(~"rgba(0,255,0,1.00)"))));
-        assert!(rgb(1u8,2u8,3u8).eq(&unwrap(parse_color(~"rgb(1,2,03)"))));
-        assert!(rgba(15u8,250u8,3u8,0.5).eq(&unwrap(parse_color(~"rgba(15,250,3,.5)"))));
-        assert!(rgba(15u8,250u8,3u8,0.5).eq(&unwrap(parse_color(~"rgba(15,250,3,0.5)"))));
+        assert!(red().eq(&parse_color(~"rgb(255,0,0)").unwrap()));
+        assert!(red().eq(&parse_color(~"rgba(255,0,0,1.0)").unwrap()));
+        assert!(red().eq(&parse_color(~"rgba(255,0,0,1)").unwrap()));
+        assert!(lime().eq(&parse_color(~"rgba(0,255,0,1.00)").unwrap()));
+        assert!(rgb(1u8,2u8,3u8).eq(&parse_color(~"rgb(1,2,03)").unwrap()));
+        assert!(rgba(15u8,250u8,3u8,0.5).eq(&parse_color(~"rgba(15,250,3,.5)").unwrap()));
+        assert!(rgba(15u8,250u8,3u8,0.5).eq(&parse_color(~"rgba(15,250,3,0.5)").unwrap()));
         assert!(None == parse_color(~"rbga(1,2,3)"));
     }
 
     #[test]
     fn test_parsing_hsl() {
-        assert!(red().eq(&unwrap(parse_color(~"hsl(0,1,.5)"))));
-        assert!(lime().eq(&unwrap(parse_color(~"hsl(120.0,1.0,.5)"))));
-        assert!(blue().eq(&unwrap(parse_color(~"hsl(240.0,1.0,.5)"))));
-        assert!(green().eq(&unwrap(parse_color(~"hsl(120.0,1.0,.25)"))));
-        assert!(white().eq(&unwrap(parse_color(~"hsl(1.0,1.,1.0)"))));
-        assert!(white().eq(&unwrap(parse_color(~"hsl(129.0,0.3,1.0)"))));
-        assert!(black().eq(&unwrap(parse_color(~"hsl(231.2,0.75,0.0)"))));
-        assert!(black().eq(&unwrap(parse_color(~"hsl(11.2,0.0,0.0)"))));
-        assert!(gray().eq(&unwrap(parse_color(~"hsl(0.0,0.0,0.5)"))));
-        assert!(maroon().eq(&unwrap(parse_color(~"hsl(0.0,1.0,0.25)"))));
-        assert!(purple().eq(&unwrap(parse_color(~"hsl(300.0,1.0,0.25)"))));
-        assert!(fuchsia().eq(&unwrap(parse_color(~"hsl(300,1.0,0.5)"))));
-        assert!(olive().eq(&unwrap(parse_color(~"hsl(60.,1.0,0.25)"))));
-        assert!(yellow().eq(&unwrap(parse_color(~"hsl(60.,1.0,0.5)"))));
-        assert!(navy().eq(&unwrap(parse_color(~"hsl(240.0,1.0,.25)"))));
-        assert!(teal().eq(&unwrap(parse_color(~"hsl(180.0,1.0,.25)"))));
-        assert!(aqua().eq(&unwrap(parse_color(~"hsl(180.0,1.0,.5)"))));
+        assert!(red().eq(&parse_color(~"hsl(0,1,.5)").unwrap()));
+        assert!(lime().eq(&parse_color(~"hsl(120.0,1.0,.5)").unwrap()));
+        assert!(blue().eq(&parse_color(~"hsl(240.0,1.0,.5)").unwrap()));
+        assert!(green().eq(&parse_color(~"hsl(120.0,1.0,.25)").unwrap()));
+        assert!(white().eq(&parse_color(~"hsl(1.0,1.,1.0)").unwrap()));
+        assert!(white().eq(&parse_color(~"hsl(129.0,0.3,1.0)").unwrap()));
+        assert!(black().eq(&parse_color(~"hsl(231.2,0.75,0.0)").unwrap()));
+        assert!(black().eq(&parse_color(~"hsl(11.2,0.0,0.0)").unwrap()));
+        assert!(gray().eq(&parse_color(~"hsl(0.0,0.0,0.5)").unwrap()));
+        assert!(maroon().eq(&parse_color(~"hsl(0.0,1.0,0.25)").unwrap()));
+        assert!(purple().eq(&parse_color(~"hsl(300.0,1.0,0.25)").unwrap()));
+        assert!(fuchsia().eq(&parse_color(~"hsl(300,1.0,0.5)").unwrap()));
+        assert!(olive().eq(&parse_color(~"hsl(60.,1.0,0.25)").unwrap()));
+        assert!(yellow().eq(&parse_color(~"hsl(60.,1.0,0.5)").unwrap()));
+        assert!(navy().eq(&parse_color(~"hsl(240.0,1.0,.25)").unwrap()));
+        assert!(teal().eq(&parse_color(~"hsl(180.0,1.0,.25)").unwrap()));
+        assert!(aqua().eq(&parse_color(~"hsl(180.0,1.0,.5)").unwrap()));
         assert!(None == parse_color(~"hsl(1,2,3,.4)"));
     }
 }

test.rs

@@ -4,14 +4,14 @@
 
 use std::net::url::Url;
 use url_from_str = std::net::url::from_str;
-use std::cell::Cell;
+use core::cell::Cell;
 use util::{DataStream, VoidPtrLike};
 use values::*;
 use types::*;
 use units::*;
 use select::*;
 use color;
-use color::{Color, rgb};
+use color::rgb;
 use stylesheet::Stylesheet;
 use computed::ComputedStyle;
 use complete::CompleteSelectResults;
@@ -38,7 +38,7 @@ struct NodeData {
     name: ~str,
     id: ~str,
     children: ~[TestNode],
-    mut parent: Option<TestNode>
+    parent: @mut Option<TestNode>
 }
 
 impl VoidPtrLike for TestNode {
@@ -69,29 +69,29 @@ impl TestHandler {
 }
 
 impl SelectHandler<TestNode> for TestHandler {
-    fn with_node_name<R>(node: &TestNode, f: &fn(&str) -> R) -> R {
+    fn with_node_name<R>(&self, node: &TestNode, f: &fn(&str) -> R) -> R {
         f((*node).name)
     }
-    fn with_node_id<R>(node: &TestNode, f: &fn(Option<&str>) -> R) -> R {
+    fn with_node_id<R>(&self, node: &TestNode, f: &fn(Option<&str>) -> R) -> R {
         let s: &str = (*node).id;
         f(Some(s))
     }
-    fn named_parent_node(node: &TestNode, name: &str) -> Option<TestNode> {
+    fn named_parent_node(&self, node: &TestNode, name: &str) -> Option<TestNode> {
         match (**node).parent {
-            Some(parent) => {
+            @Some(parent) => {
                 if name == (**parent).name {
                     Some(parent)
                 } else {
                     None
                 }
             }
-            None => None
+            @None => None
         }
     }
-    fn parent_node(node: &TestNode) -> Option<TestNode> { (**node).parent }
-    fn node_has_id(node: &TestNode, name: &str) -> bool { name == node.id }
-    fn named_ancestor_node(node: &TestNode, name: &str) -> Option<TestNode> { fail!(~"TODO") }
-    fn node_is_root(node: &TestNode) -> bool { self.parent_node(node).is_none() }
+    fn parent_node(&self, node: &TestNode) -> Option<TestNode> { *(**node).parent }
+    fn node_has_id(&self, node: &TestNode, name: &str) -> bool { name == node.id }
+    fn named_ancestor_node(&self, _node: &TestNode, _name: &str) -> Option<TestNode> { fail!(~"TODO") }
+    fn node_is_root(&self, node: &TestNode) -> bool { self.parent_node(node).is_none() }
 }
 
 fn single_div_test(style: &str, f: &fn(&ComputedStyle)) {
@@ -103,7 +103,7 @@ fn single_div_test(style: &str, f: &fn(&ComputedStyle)) {
         name: ~"div",
         id: ~"id1",
         children: ~[],
-        parent: None
+        parent: @mut None
     });
     let style = select_ctx.select_style(dom, handler);
     let computed = style.computed_style();
@@ -370,15 +370,15 @@ fn child_test(style: &str, f: &fn(&ComputedStyle)) {
         name: ~"span",
         id: ~"id1",
         children: ~[],
-        parent: None
+        parent: @mut None
     });
     let parent = TestNode(@NodeData {
         name: ~"div",
         id: ~"id2",
         children: ~[child],
-        parent: None
+        parent: @mut None
     });
-    child.parent = Some(parent);
+    *child.parent = Some(parent);
     let style = select_ctx.select_style(&child, handler);
     let computed = style.computed_style();
     f(&computed);
@@ -428,15 +428,15 @@ fn test_compose() {
         name: ~"span",
         id: ~"id1",
         children: ~[],
-        parent: None
+        parent: @mut None
     });
     let parent = TestNode(@NodeData {
         name: ~"div",
         id: ~"id2",
         children: ~[child],
-        parent: None
+        parent: @mut None
     });
-    child.parent = Some(parent);
+    *child.parent = Some(parent);
     let parent_results = select_ctx.select_style(&parent, handler);
     let child_results = select_ctx.select_style(&child, handler);