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

Format remaining files

Browse source
This commit is contained in:
Pyfisch 2018-11-06 13:01:35 +01:00
parent bf47f90da6
commit cb07debcb6
252 changed files with 5944 additions and 3744 deletions
Download patch file Download diff file Expand all files Collapse all files

28
tests/unit/malloc_size_of/lib.rs
View file

@ -25,9 +25,9 @@ pub mod does_not_impl_malloc_size_of {
```compile_fail,E0277
extern crate malloc_size_of;
extern crate servo_arc;
fn sizeable<T: malloc_size_of::MallocSizeOf>() {}
fn main() {
sizeable::<servo_arc::Arc<i32>>();
}
@ -35,13 +35,12 @@ pub mod does_not_impl_malloc_size_of {
*/
pub fn servo_arc() {}
/**
```compile_fail,E0277
extern crate malloc_size_of;
fn sizeable<T: malloc_size_of::MallocSizeOf>() {}
fn main() {
sizeable::<std::sync::Arc<i32>>();
}
@ -49,13 +48,12 @@ pub mod does_not_impl_malloc_size_of {
*/
pub fn std_arc() {}
/**
```compile_fail,E0277
extern crate malloc_size_of;
fn sizeable<T: malloc_size_of::MallocSizeOf>() {}
fn main() {
sizeable::<std::rc::Rc<i32>>();
}
@ -69,9 +67,9 @@ pub mod does_not_impl_malloc_shallow_size_of {
```compile_fail,E0277
extern crate malloc_size_of;
extern crate servo_arc;
fn shallow_sizeable<T: malloc_size_of::MallocShallowSizeOf>() {}
fn main() {
shallow_sizeable::<servo_arc::Arc<i32>>();
}
@ -79,13 +77,12 @@ pub mod does_not_impl_malloc_shallow_size_of {
*/
pub fn servo_arc() {}
/**
```compile_fail,E0277
extern crate malloc_size_of;
fn shallow_sizeable<T: malloc_size_of::MallocShallowSizeOf>() {}
fn main() {
shallow_sizeable::<std::sync::Arc<i32>>();
}
@ -93,13 +90,12 @@ pub mod does_not_impl_malloc_shallow_size_of {
*/
pub fn std_arc() {}
/**
```compile_fail,E0277
extern crate malloc_size_of;
fn shallow_sizeable<T: malloc_size_of::MallocShallowSizeOf>() {}
fn main() {
shallow_sizeable::<std::rc::Rc<i32>>();
}

27
tests/unit/metrics/interactive_time.rs
View file

@ -16,14 +16,11 @@ impl ProfilerMetadataFactory for DummyProfilerMetadataFactory {
}
}
fn test_interactive() -> InteractiveMetrics {
let (sender, _) = ipc::channel().unwrap();
let profiler_chan = ProfilerChan(sender);
let mut interactive = InteractiveMetrics::new(
profiler_chan,
ServoUrl::parse("about:blank").unwrap(),
);
let mut interactive =
InteractiveMetrics::new(profiler_chan, ServoUrl::parse("about:blank").unwrap());
assert_eq!((&interactive).get_navigation_start(), None);
assert_eq!(interactive.get_tti(), None);
@ -38,12 +35,18 @@ fn test_set_dcl() {
let profiler_metadata_factory = DummyProfilerMetadataFactory {};
let interactive = test_interactive();
interactive.maybe_set_tti(&profiler_metadata_factory, InteractiveFlag::DOMContentLoaded);
interactive.maybe_set_tti(
&profiler_metadata_factory,
InteractiveFlag::DOMContentLoaded,
);
let dcl = interactive.get_dom_content_loaded();
assert!(dcl.is_some());
//try to overwrite
interactive.maybe_set_tti(&profiler_metadata_factory, InteractiveFlag::DOMContentLoaded);
interactive.maybe_set_tti(
&profiler_metadata_factory,
InteractiveFlag::DOMContentLoaded,
);
assert_eq!(interactive.get_dom_content_loaded(), dcl);
assert_eq!(interactive.get_tti(), None);
}
@ -84,7 +87,10 @@ fn test_set_tti_dcl() {
let mta = interactive.get_main_thread_available();
assert!(mta.is_some());
interactive.maybe_set_tti(&profiler_metadata_factory, InteractiveFlag::DOMContentLoaded);
interactive.maybe_set_tti(
&profiler_metadata_factory,
InteractiveFlag::DOMContentLoaded,
);
let dcl = interactive.get_dom_content_loaded();
assert!(dcl.is_some());
@ -97,7 +103,10 @@ fn test_set_tti_mta() {
let profiler_metadata_factory = DummyProfilerMetadataFactory {};
let interactive = test_interactive();
interactive.maybe_set_tti(&profiler_metadata_factory, InteractiveFlag::DOMContentLoaded);
interactive.maybe_set_tti(
&profiler_metadata_factory,
InteractiveFlag::DOMContentLoaded,
);
let dcl = interactive.get_dom_content_loaded();
assert!(dcl.is_some());

2
tests/unit/metrics/paint_time.rs
View file

@ -125,7 +125,7 @@ fn test_first_contentful_paint_setter() {
image_rendering: ImageRendering::Auto,
alpha_type: AlphaType::PremultipliedAlpha,
color: ColorF::WHITE,
}
},
));
let display_list = DisplayList {
list: vec![image],

22
tests/unit/profile/time.rs
View file

@ -22,8 +22,9 @@ fn time_profiler_smoke_test() {
#[test]
fn time_profiler_stats_test() {
let even_data = vec![1.234, 3.24567, 3.54578, 5.0, 5.324, 7.345,
9.2345, 10.2342345, 13.2599, 15.0];
let even_data = vec![
1.234, 3.24567, 3.54578, 5.0, 5.324, 7.345, 9.2345, 10.2342345, 13.2599, 15.0,
];
let (even_mean, even_median, even_min, even_max) = time::Profiler::get_statistics(&even_data);
assert_eq!(7.34230845, even_mean);
@ -31,8 +32,9 @@ fn time_profiler_stats_test() {
assert_eq!(1.234, even_min);
assert_eq!(15.0, even_max);
let odd_data = vec![1.234, 3.24567, 3.54578, 5.0, 5.324, 7.345,
9.2345, 10.2342345, 13.2599];
let odd_data = vec![
1.234, 3.24567, 3.54578, 5.0, 5.324, 7.345, 9.2345, 10.2342345, 13.2599,
];
let (odd_mean, odd_median, odd_min, odd_max) = time::Profiler::get_statistics(&odd_data);
assert_eq!(6.491453833333334, odd_mean);
@ -54,14 +56,16 @@ fn channel_profiler_test() {
assert_eq!(val_profile_receiver, 43);
let (sender, receiver) = ipc::channel().unwrap();
chan.send(ProfilerMsg::Get((ProfilerCategory::IpcReceiver, None), sender.clone()));
chan.send(ProfilerMsg::Get(
(ProfilerCategory::IpcReceiver, None),
sender.clone(),
));
match receiver.recv().unwrap() {
// asserts that the time spent in the sleeping thread is more than 1500 milliseconds
ProfilerData::Record(time_data) => assert!(time_data[0] > 1.5e3),
ProfilerData::NoRecords => assert!(false),
};
}
#[test]
@ -77,14 +81,16 @@ fn bytes_channel_profiler_test() {
assert_eq!(val_profile_receiver, [1, 2, 3]);
let (sender, receiver) = ipc::channel().unwrap();
chan.send(ProfilerMsg::Get((ProfilerCategory::IpcBytesReceiver, None), sender.clone()));
chan.send(ProfilerMsg::Get(
(ProfilerCategory::IpcBytesReceiver, None),
sender.clone(),
));
match receiver.recv().unwrap() {
// asserts that the time spent in the sleeping thread is more than 1500 milliseconds
ProfilerData::Record(time_data) => assert!(time_data[0] > 1.5e3),
ProfilerData::NoRecords => assert!(false),
};
}
#[cfg(debug_assertions)]

18
tests/unit/script/headers.rs
View file

@ -34,7 +34,8 @@ fn test_normalize_non_empty_no_whitespace_bytestring() {
#[test]
fn test_normalize_non_empty_leading_whitespace_bytestring() {
// Non-empty, leading whitespace, no trailing whitespace ByteString test
let leading_whitespace_bytestring = ByteString::new(vec![b'\t', b'\n', b' ', b'\r', b'S', b'!']);
let leading_whitespace_bytestring =
ByteString::new(vec![b'\t', b'\n', b' ', b'\r', b'S', b'!']);
let actual = normalize_value(leading_whitespace_bytestring);
let expected = ByteString::new(vec![b'S', b'!']);
assert_eq!(actual, expected);
@ -43,7 +44,8 @@ fn test_normalize_non_empty_leading_whitespace_bytestring() {
#[test]
fn test_normalize_non_empty_no_leading_whitespace_trailing_whitespace_bytestring() {
// Non-empty, no leading whitespace, but with trailing whitespace ByteString test
let trailing_whitespace_bytestring = ByteString::new(vec![b'S', b'!', b'\t', b'\n', b' ', b'\r']);
let trailing_whitespace_bytestring =
ByteString::new(vec![b'S', b'!', b'\t', b'\n', b' ', b'\r']);
let actual = normalize_value(trailing_whitespace_bytestring);
let expected = ByteString::new(vec![b'S', b'!']);
assert_eq!(actual, expected);
@ -52,8 +54,9 @@ fn test_normalize_non_empty_no_leading_whitespace_trailing_whitespace_bytestring
#[test]
fn test_normalize_non_empty_leading_and_trailing_whitespace_bytestring() {
// Non-empty, leading whitespace, and trailing whitespace ByteString test
let whitespace_sandwich_bytestring =
ByteString::new(vec![b'\t', b'\n', b' ', b'\r', b'S', b'!', b'\t', b'\n', b' ', b'\r']);
let whitespace_sandwich_bytestring = ByteString::new(vec![
b'\t', b'\n', b' ', b'\r', b'S', b'!', b'\t', b'\n', b' ', b'\r',
]);
let actual = normalize_value(whitespace_sandwich_bytestring);
let expected = ByteString::new(vec![b'S', b'!']);
assert_eq!(actual, expected);
@ -63,10 +66,9 @@ fn test_normalize_non_empty_leading_and_trailing_whitespace_bytestring() {
fn test_normalize_non_empty_leading_trailing_and_internal_whitespace_bytestring() {
// Non-empty, leading whitespace, trailing whitespace,
// and internal whitespace ByteString test
let whitespace_bigmac_bytestring =
ByteString::new(vec![b'\t', b'\n', b' ', b'\r', b'S',
b'\t', b'\n', b' ', b'\r', b'!',
b'\t', b'\n', b' ', b'\r']);
let whitespace_bigmac_bytestring = ByteString::new(vec![
b'\t', b'\n', b' ', b'\r', b'S', b'\t', b'\n', b' ', b'\r', b'!', b'\t', b'\n', b' ', b'\r',
]);
let actual = normalize_value(whitespace_bigmac_bytestring);
let expected = ByteString::new(vec![b'S', b'\t', b'\n', b' ', b'\r', b'!']);
assert_eq!(actual, expected);

140
tests/unit/script/htmlareaelement.rs
View file

@ -28,14 +28,26 @@ fn delimiter_input() {
// Area::Circle tests
#[test]
fn valid_circle_inputs() {
assert_eq!(Area::parse("10.2, 3.4, 5.2", Shape::Circle),
Some(Area::Circle { left: 10.2, top: 3.4, radius: 5.2 }));
assert_eq!(
Area::parse("10.2, 3.4, 5.2", Shape::Circle),
Some(Area::Circle {
left: 10.2,
top: 3.4,
radius: 5.2
})
);
}
#[test]
fn valid_negative_circle_inputs() {
assert_eq!(Area::parse("-10.2, -3.4, 5.2", Shape::Circle),
Some(Area::Circle { left: -10.2, top: -3.4, radius: 5.2 }));
assert_eq!(
Area::parse("-10.2, -3.4, 5.2", Shape::Circle),
Some(Area::Circle {
left: -10.2,
top: -3.4,
radius: 5.2
})
);
}
#[test]
@ -46,77 +58,133 @@ fn invalid_negative_circle_radius() {
// Area::Rectangle tests
#[test]
fn rectangle_valid_input() {
assert_eq!(Area::parse("5.2, 1.1, 10.2, 3.4", Shape::Rectangle),
Some(Area::Rectangle { top_left: (5.2, 1.1),
bottom_right: (10.2, 3.4) }));
assert_eq!(
Area::parse("5.2, 1.1, 10.2, 3.4", Shape::Rectangle),
Some(Area::Rectangle {
top_left: (5.2, 1.1),
bottom_right: (10.2, 3.4)
})
);
}
#[test]
fn rectangle_valid_negative_input() {
assert_eq!(Area::parse("-10.2, -3.4, -5.2, -1.1", Shape::Rectangle),
Some(Area::Rectangle { top_left: (-10.2, -3.4),
bottom_right: (-5.2, -1.1) }));
assert_eq!(
Area::parse("-10.2, -3.4, -5.2, -1.1", Shape::Rectangle),
Some(Area::Rectangle {
top_left: (-10.2, -3.4),
bottom_right: (-5.2, -1.1)
})
);
}
#[test]
fn rectangle_invalid_input() {
assert_eq!(Area::parse("5.2, 4.3, 10.2, 1.1.2", Shape::Rectangle),
Some(Area::Rectangle { top_left: (5.2, 0.0),
bottom_right: (10.2, 4.3) }));
assert_eq!(
Area::parse("5.2, 4.3, 10.2, 1.1.2", Shape::Rectangle),
Some(Area::Rectangle {
top_left: (5.2, 0.0),
bottom_right: (10.2, 4.3)
})
);
}
#[test]
fn rectangle_unordered_input() {
assert_eq!(Area::parse("5.2, 1.1, 10.2, 4.3", Shape::Rectangle),
Some(Area::Rectangle { top_left: (5.2, 1.1),
bottom_right: (10.2, 4.3) }));
assert_eq!(
Area::parse("5.2, 1.1, 10.2, 4.3", Shape::Rectangle),
Some(Area::Rectangle {
top_left: (5.2, 1.1),
bottom_right: (10.2, 4.3)
})
);
}
// Area::Polygon tests
#[test]
fn polygon_six_points_valid_input() {
assert_eq!(Area::parse("1.1, 1.1, 6.1, 1.1, 3.1, 3.1", Shape::Polygon),
Some(Area::Polygon { points: vec![1.1, 1.1, 6.1, 1.1, 3.1, 3.1] }));
assert_eq!(
Area::parse("1.1, 1.1, 6.1, 1.1, 3.1, 3.1", Shape::Polygon),
Some(Area::Polygon {
points: vec![1.1, 1.1, 6.1, 1.1, 3.1, 3.1]
})
);
}
#[test]
fn polygon_six_points_valid_negative_input() {
assert_eq!(Area::parse("1.1, -1.1, 6.1, -1.1, 3.1, -3.1", Shape::Polygon),
Some(Area::Polygon { points: vec![1.1, -1.1, 6.1, -1.1, 3.1, -3.1] }));
assert_eq!(
Area::parse("1.1, -1.1, 6.1, -1.1, 3.1, -3.1", Shape::Polygon),
Some(Area::Polygon {
points: vec![1.1, -1.1, 6.1, -1.1, 3.1, -3.1]
})
);
}
#[test]
fn polygon_six_points_invalid_input() {
assert_eq!(Area::parse(";1.1, 1.1,'; 6.1,(*^() 1.1, 3.1, 3.1, 100.1 %$,;", Shape::Polygon),
Some(Area::Polygon { points: vec![1.1, 1.1, 6.1, 1.1, 3.1, 3.1] }));
assert_eq!(
Area::parse(
";1.1, 1.1,'; 6.1,(*^() 1.1, 3.1, 3.1, 100.1 %$,;",
Shape::Polygon
),
Some(Area::Polygon {
points: vec![1.1, 1.1, 6.1, 1.1, 3.1, 3.1]
})
);
}
#[test]
fn polygon_eight_points_invalid_input() {
assert_eq!(Area::parse("1.1, -1.1, 6.1, -1.1, 1.1, -3.1, 6.1, -3.1.2, 12.1", Shape::Polygon),
Some(Area::Polygon { points: vec![1.1, -1.1, 6.1, -1.1, 1.1, -3.1, 6.1, 0.0] }));
assert_eq!(
Area::parse(
"1.1, -1.1, 6.1, -1.1, 1.1, -3.1, 6.1, -3.1.2, 12.1",
Shape::Polygon
),
Some(Area::Polygon {
points: vec![1.1, -1.1, 6.1, -1.1, 1.1, -3.1, 6.1, 0.0]
})
);
}
#[test]
fn test_hit_test_circle() {
let circ1 = Area::Circle { left: 20.0, top: 10.0, radius: 5.0 };
assert!(!circ1.hit_test(&Point2D::new(10.0, 20.0)));
let circ2 = Area::Circle { left: 10.0, top: 10.0, radius: 5.0 };
assert!(circ2.hit_test(&Point2D::new(10.0, 12.0)));
let circ1 = Area::Circle {
left: 20.0,
top: 10.0,
radius: 5.0,
};
assert!(!circ1.hit_test(&Point2D::new(10.0, 20.0)));
let circ2 = Area::Circle {
left: 10.0,
top: 10.0,
radius: 5.0,
};
assert!(circ2.hit_test(&Point2D::new(10.0, 12.0)));
}
#[test]
fn test_hit_test_rectangle() {
let rect1 = Area::Rectangle { top_left: (1.0, 7.0), bottom_right: (15.0, 10.0) };
assert!(!rect1.hit_test(&Point2D::new(10.0, 5.0)));
let rect2 = Area::Rectangle { top_left: (8.0, 10.0), bottom_right: (20.0, 12.0) };
assert!(rect2.hit_test(&Point2D::new(10.0, 12.0)));
let rect1 = Area::Rectangle {
top_left: (1.0, 7.0),
bottom_right: (15.0, 10.0),
};
assert!(!rect1.hit_test(&Point2D::new(10.0, 5.0)));
let rect2 = Area::Rectangle {
top_left: (8.0, 10.0),
bottom_right: (20.0, 12.0),
};
assert!(rect2.hit_test(&Point2D::new(10.0, 12.0)));
}
#[test]
fn test_hit_test_polygon() {
let poly1 = Area::Polygon { points: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0] };
assert!(!poly1.hit_test(&Point2D::new(10.0, 5.0)));
let poly2 = Area::Polygon { points: vec![7.0, 7.5, 8.2, 9.0, 11.0, 12.0] };
assert!(!poly2.hit_test(&Point2D::new(10.0, 5.0)));
let poly1 = Area::Polygon {
points: vec![1.0, 2.0, 3.0, 4.0, 5.0, 6.0],
};
assert!(!poly1.hit_test(&Point2D::new(10.0, 5.0)));
let poly2 = Area::Polygon {
points: vec![7.0, 7.5, 8.2, 9.0, 11.0, 12.0],
};
assert!(!poly2.hit_test(&Point2D::new(10.0, 5.0)));
}

134
tests/unit/script/htmlimageelement.rs
View file

@ -12,48 +12,104 @@ fn no_value() {
#[test]
fn width_one_value() {
let first_descriptor = Descriptor { wid: Some(320), den: None };
let first_imagesource = ImageSource { url: "small-image.jpg".to_string(), descriptor: first_descriptor };
let first_descriptor = Descriptor {
wid: Some(320),
den: None,
};
let first_imagesource = ImageSource {
url: "small-image.jpg".to_string(),
descriptor: first_descriptor,
};
let sources = &[first_imagesource];
assert_eq!(parse_a_srcset_attribute("small-image.jpg, 320w"), sources);
}
#[test]
fn width_two_value() {
let first_descriptor = Descriptor { wid: Some(320), den: None };
let first_imagesource = ImageSource { url: "small-image.jpg".to_string(), descriptor: first_descriptor };
let second_descriptor = Descriptor { wid: Some(480), den: None };
let second_imagesource = ImageSource { url: "medium-image.jpg".to_string(), descriptor: second_descriptor };
let first_descriptor = Descriptor {
wid: Some(320),
den: None,
};
let first_imagesource = ImageSource {
url: "small-image.jpg".to_string(),
descriptor: first_descriptor,
};
let second_descriptor = Descriptor {
wid: Some(480),
den: None,
};
let second_imagesource = ImageSource {
url: "medium-image.jpg".to_string(),
descriptor: second_descriptor,
};
let sources = &[first_imagesource, second_imagesource];
assert_eq!(parse_a_srcset_attribute("small-image.jpg 320w, medium-image.jpg 480w"), sources);
assert_eq!(
parse_a_srcset_attribute("small-image.jpg 320w, medium-image.jpg 480w"),
sources
);
}
#[test]
fn width_three_value() {
let first_descriptor = Descriptor { wid: Some(320), den: None };
let first_imagesource = ImageSource { url: "smallImage.jpg".to_string(), descriptor: first_descriptor };
let second_descriptor = Descriptor { wid: Some(480), den: None };
let second_imagesource = ImageSource { url: "mediumImage.jpg".to_string(), descriptor: second_descriptor };
let third_descriptor = Descriptor { wid: Some(800), den: None };
let third_imagesource = ImageSource { url: "largeImage.jpg".to_string(), descriptor: third_descriptor };
let first_descriptor = Descriptor {
wid: Some(320),
den: None,
};
let first_imagesource = ImageSource {
url: "smallImage.jpg".to_string(),
descriptor: first_descriptor,
};
let second_descriptor = Descriptor {
wid: Some(480),
den: None,
};
let second_imagesource = ImageSource {
url: "mediumImage.jpg".to_string(),
descriptor: second_descriptor,
};
let third_descriptor = Descriptor {
wid: Some(800),
den: None,
};
let third_imagesource = ImageSource {
url: "largeImage.jpg".to_string(),
descriptor: third_descriptor,
};
let sources = &[first_imagesource, second_imagesource, third_imagesource];
assert_eq!(parse_a_srcset_attribute("smallImage.jpg 320w,
assert_eq!(
parse_a_srcset_attribute(
"smallImage.jpg 320w,
mediumImage.jpg 480w,
largeImage.jpg 800w"), sources);
largeImage.jpg 800w"
),
sources
);
}
#[test]
fn density_value() {
let first_descriptor = Descriptor { wid: None, den: Some(1.0) };
let first_imagesource = ImageSource { url: "small-image.jpg".to_string(), descriptor: first_descriptor };
let first_descriptor = Descriptor {
wid: None,
den: Some(1.0),
};
let first_imagesource = ImageSource {
url: "small-image.jpg".to_string(),
descriptor: first_descriptor,
};
let sources = &[first_imagesource];
assert_eq!(parse_a_srcset_attribute("small-image.jpg 1x"), sources);
}
#[test]
fn without_descriptor() {
let first_descriptor = Descriptor { wid: None, den: None };
let first_imagesource = ImageSource { url: "small-image.jpg".to_string(), descriptor: first_descriptor };
let first_descriptor = Descriptor {
wid: None,
den: None,
};
let first_imagesource = ImageSource {
url: "small-image.jpg".to_string(),
descriptor: first_descriptor,
};
let sources = &[first_imagesource];
assert_eq!(parse_a_srcset_attribute("small-image.jpg"), sources);
}
@ -62,23 +118,47 @@ fn without_descriptor() {
#[test]
fn two_descriptor() {
let empty_vec = Vec::new();
assert_eq!(parse_a_srcset_attribute("small-image.jpg 320w 1.1x"), empty_vec);
assert_eq!(
parse_a_srcset_attribute("small-image.jpg 320w 1.1x"),
empty_vec
);
}
#[test]
fn decimal_descriptor() {
let first_descriptor = Descriptor { wid: None, den: Some(2.2) };
let first_imagesource = ImageSource { url: "small-image.jpg".to_string(), descriptor: first_descriptor };
let first_descriptor = Descriptor {
wid: None,
den: Some(2.2),
};
let first_imagesource = ImageSource {
url: "small-image.jpg".to_string(),
descriptor: first_descriptor,
};
let sources = &[first_imagesource];
assert_eq!(parse_a_srcset_attribute("small-image.jpg 2.2x"), sources);
}
#[test]
fn different_descriptor() {
let first_descriptor = Descriptor { wid: Some(320), den: None };
let first_imagesource = ImageSource { url: "small-image.jpg".to_string(), descriptor: first_descriptor };
let second_descriptor = Descriptor { wid: None, den: Some(2.2) };
let second_imagesource = ImageSource { url: "medium-image.jpg".to_string(), descriptor: second_descriptor };
let first_descriptor = Descriptor {
wid: Some(320),
den: None,
};
let first_imagesource = ImageSource {
url: "small-image.jpg".to_string(),
descriptor: first_descriptor,
};
let second_descriptor = Descriptor {
wid: None,
den: Some(2.2),
};
let second_imagesource = ImageSource {
url: "medium-image.jpg".to_string(),
descriptor: second_descriptor,
};
let sources = &[first_imagesource, second_imagesource];
assert_eq!(parse_a_srcset_attribute("small-image.jpg 320w, medium-image.jpg 2.2x"), sources);
assert_eq!(
parse_a_srcset_attribute("small-image.jpg 320w, medium-image.jpg 2.2x"),
sources
);
}

34
tests/unit/script/lib.rs
View file

@ -2,19 +2,29 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#[cfg(test)] extern crate euclid;
#[cfg(test)] extern crate keyboard_types;
#[cfg(test)] extern crate script;
#[cfg(test)] extern crate servo_url;
#[cfg(test)] mod origin;
#[cfg(all(test, target_pointer_width = "64"))] mod size_of;
#[cfg(test)] mod textinput;
#[cfg(test)] mod headers;
#[cfg(test)] mod htmlareaelement;
#[cfg(test)] mod htmlimageelement;
#[cfg(test)] mod timeranges;
#[cfg(test)]
extern crate euclid;
#[cfg(test)]
extern crate keyboard_types;
#[cfg(test)]
extern crate script;
#[cfg(test)]
extern crate servo_url;
#[cfg(test)]
mod headers;
#[cfg(test)]
mod htmlareaelement;
#[cfg(test)]
mod htmlimageelement;
#[cfg(test)]
mod origin;
#[cfg(all(test, target_pointer_width = "64"))]
mod size_of;
#[cfg(test)]
mod textinput;
#[cfg(test)]
mod timeranges;
/**
```compile_fail,E0277

54
tests/unit/script/origin.rs
View file

@ -6,29 +6,57 @@ use servo_url::{ImmutableOrigin, MutableOrigin, ServoUrl};
#[test]
fn same_origin() {
let a = MutableOrigin::new(ServoUrl::parse("http://example.com/a.html").unwrap().origin());
let b = MutableOrigin::new(ServoUrl::parse("http://example.com/b.html").unwrap().origin());
let a = MutableOrigin::new(
ServoUrl::parse("http://example.com/a.html")
.unwrap()
.origin(),
);
let b = MutableOrigin::new(
ServoUrl::parse("http://example.com/b.html")
.unwrap()
.origin(),
);
assert!(a.same_origin(&b));
assert_eq!(a.is_tuple(), true);
}
#[test]
fn identical_origin() {
let a = MutableOrigin::new(ServoUrl::parse("http://example.com/a.html").unwrap().origin());
let a = MutableOrigin::new(
ServoUrl::parse("http://example.com/a.html")
.unwrap()
.origin(),
);
assert!(a.same_origin(&a));
}
#[test]
fn cross_origin() {
let a = MutableOrigin::new(ServoUrl::parse("http://example.com/a.html").unwrap().origin());
let b = MutableOrigin::new(ServoUrl::parse("http://example.org/b.html").unwrap().origin());
let a = MutableOrigin::new(
ServoUrl::parse("http://example.com/a.html")
.unwrap()
.origin(),
);
let b = MutableOrigin::new(
ServoUrl::parse("http://example.org/b.html")
.unwrap()
.origin(),
);
assert!(!a.same_origin(&b));
}
#[test]
fn clone_same_origin() {
let a = MutableOrigin::new(ServoUrl::parse("http://example.com/a.html").unwrap().origin());
let b = MutableOrigin::new(ServoUrl::parse("http://example.com/b.html").unwrap().origin());
let a = MutableOrigin::new(
ServoUrl::parse("http://example.com/a.html")
.unwrap()
.origin(),
);
let b = MutableOrigin::new(
ServoUrl::parse("http://example.com/b.html")
.unwrap()
.origin(),
);
let c = b.clone();
assert!(a.same_origin(&c));
assert!(b.same_origin(&b));
@ -38,8 +66,16 @@ fn clone_same_origin() {
#[test]
fn clone_cross_origin() {
let a = MutableOrigin::new(ServoUrl::parse("http://example.com/a.html").unwrap().origin());
let b = MutableOrigin::new(ServoUrl::parse("http://example.org/b.html").unwrap().origin());
let a = MutableOrigin::new(
ServoUrl::parse("http://example.com/a.html")
.unwrap()
.origin(),
);
let b = MutableOrigin::new(
ServoUrl::parse("http://example.org/b.html")
.unwrap()
.origin(),
);
let c = b.clone();
assert!(!a.same_origin(&c));
assert!(b.same_origin(&c));

102
tests/unit/script/textinput.rs
View file

@ -13,18 +13,25 @@ use script::test::DOMString;
use script::textinput::{TextInput, TextPoint, Selection, Lines, Direction, SelectionDirection};
fn text_input(lines: Lines, s: &str) -> TextInput<DummyClipboardContext> {
TextInput::new(lines,
DOMString::from(s),
DummyClipboardContext::new(""),
None,
None,
SelectionDirection::None)
TextInput::new(
lines,
DOMString::from(s),
DummyClipboardContext::new(""),
None,
None,
SelectionDirection::None,
)
}
#[test]
fn test_set_content_ignores_max_length() {
let mut textinput = TextInput::new(
Lines::Single, DOMString::from(""), DummyClipboardContext::new(""), Some(1), None, SelectionDirection::None
Lines::Single,
DOMString::from(""),
DummyClipboardContext::new(""),
Some(1),
None,
SelectionDirection::None,
);
textinput.set_content(DOMString::from("mozilla rocks"));
@ -64,7 +71,7 @@ fn test_textinput_when_inserting_multiple_lines_still_respects_max_length() {
DummyClipboardContext::new(""),
Some(17),
None,
SelectionDirection::None
SelectionDirection::None,
);
textinput.adjust_vertical(1, Selection::NotSelected);
@ -74,7 +81,8 @@ fn test_textinput_when_inserting_multiple_lines_still_respects_max_length() {
}
#[test]
fn test_textinput_when_content_is_already_longer_than_max_length_and_theres_no_selection_dont_insert_anything() {
fn test_textinput_when_content_is_already_longer_than_max_length_and_theres_no_selection_dont_insert_anything(
) {
let mut textinput = TextInput::new(
Lines::Single,
DOMString::from("abc"),
@ -90,7 +98,8 @@ fn test_textinput_when_content_is_already_longer_than_max_length_and_theres_no_s
}
#[test]
fn test_multi_line_textinput_with_maxlength_doesnt_allow_appending_characters_when_input_spans_lines() {
fn test_multi_line_textinput_with_maxlength_doesnt_allow_appending_characters_when_input_spans_lines(
) {
let mut textinput = TextInput::new(
Lines::Multiple,
DOMString::from("abc\nd"),
@ -106,7 +115,8 @@ fn test_multi_line_textinput_with_maxlength_doesnt_allow_appending_characters_wh
}
#[test]
fn test_single_line_textinput_with_max_length_doesnt_allow_appending_characters_when_replacing_a_selection() {
fn test_single_line_textinput_with_max_length_doesnt_allow_appending_characters_when_replacing_a_selection(
) {
let mut textinput = TextInput::new(
Lines::Single,
DOMString::from("abcde"),
@ -183,7 +193,8 @@ fn test_single_line_textinput_with_max_length_inside_char() {
}
#[test]
fn test_single_line_textinput_with_max_length_doesnt_allow_appending_characters_after_max_length_is_reached() {
fn test_single_line_textinput_with_max_length_doesnt_allow_appending_characters_after_max_length_is_reached(
) {
let mut textinput = TextInput::new(
Lines::Single,
DOMString::from("a"),
@ -430,23 +441,39 @@ fn test_navigation_keyboard_shortcuts() {
textinput.handle_keydown_aux(Key::ArrowLeft, Modifiers::META, true);
assert_eq!(textinput.edit_point().index, 0);
// Test that CTRL + ALT + E moves to the end of the current line also.
textinput.handle_keydown_aux(Key::Character("e".to_owned()), Modifiers::CONTROL | Modifiers::ALT, true);
textinput.handle_keydown_aux(
Key::Character("e".to_owned()),
Modifiers::CONTROL | Modifiers::ALT,
true,
);
assert_eq!(textinput.edit_point().index, 11);
// Test that CTRL + ALT + A moves to the beginning of the current line also.
textinput.handle_keydown_aux(Key::Character("a".to_owned()), Modifiers::CONTROL | Modifiers::ALT, true);
textinput.handle_keydown_aux(
Key::Character("a".to_owned()),
Modifiers::CONTROL | Modifiers::ALT,
true,
);
assert_eq!(textinput.edit_point().index, 0);
// Test that ALT + Right moves to the end of the word.
textinput.handle_keydown_aux(Key::ArrowRight, Modifiers::ALT, true);
assert_eq!(textinput.edit_point().index, 5);
// Test that CTRL + ALT + F moves to the end of the word also.
textinput.handle_keydown_aux(Key::Character("f".to_owned()), Modifiers::CONTROL | Modifiers::ALT, true);
textinput.handle_keydown_aux(
Key::Character("f".to_owned()),
Modifiers::CONTROL | Modifiers::ALT,
true,
);
assert_eq!(textinput.edit_point().index, 11);
// Test that ALT + Left moves to the end of the word.
textinput.handle_keydown_aux(Key::ArrowLeft, Modifiers::ALT, true);
assert_eq!(textinput.edit_point().index, 6);
// Test that CTRL + ALT + B moves to the end of the word also.
textinput.handle_keydown_aux(Key::Character("b".to_owned()), Modifiers::CONTROL | Modifiers::ALT, true);
textinput.handle_keydown_aux(
Key::Character("b".to_owned()),
Modifiers::CONTROL | Modifiers::ALT,
true,
);
assert_eq!(textinput.edit_point().index, 0);
}
@ -510,12 +537,14 @@ fn test_clipboard_paste() {
#[cfg(not(target_os = "macos"))]
const MODIFIERS: Modifiers = Modifiers::CONTROL;
let mut textinput = TextInput::new(Lines::Single,
DOMString::from("defg"),
DummyClipboardContext::new("abc"),
None,
None,
SelectionDirection::None);
let mut textinput = TextInput::new(
Lines::Single,
DOMString::from("defg"),
DummyClipboardContext::new("abc"),
None,
None,
SelectionDirection::None,
);
assert_eq!(textinput.get_content(), "defg");
assert_eq!(textinput.edit_point().index, 0);
textinput.handle_keydown_aux(Key::Character("v".to_owned()), MODIFIERS, false);
@ -547,7 +576,6 @@ fn test_textinput_cursor_position_correct_after_clearing_selection() {
textinput.adjust_horizontal_by_one(Direction::Backward, Selection::NotSelected);
assert_eq!(textinput.edit_point().index, 0);
let mut textinput = text_input(Lines::Multiple, "abc\nde\nf");
// Multiline - Forward
@ -576,7 +604,6 @@ fn test_textinput_cursor_position_correct_after_clearing_selection() {
assert_eq!(textinput.edit_point().line, 0);
}
#[test]
fn test_textinput_set_selection_with_direction() {
let mut textinput = text_input(Lines::Single, "abcdef");
@ -592,7 +619,10 @@ fn test_textinput_set_selection_with_direction() {
textinput.set_selection_range(2, 6, SelectionDirection::Backward);
assert_eq!(textinput.edit_point().line, 0);
assert_eq!(textinput.edit_point().index, 2);
assert_eq!(textinput.selection_direction(), SelectionDirection::Backward);
assert_eq!(
textinput.selection_direction(),
SelectionDirection::Backward
);
assert!(textinput.selection_origin().is_some());
assert_eq!(textinput.selection_origin().unwrap().line, 0);
@ -617,7 +647,6 @@ fn test_textinput_set_selection_with_direction() {
assert!(textinput.selection_origin().is_some());
assert_eq!(textinput.selection_origin().unwrap().line, 0);
assert_eq!(textinput.selection_origin().unwrap().index, 0);
}
#[test]
@ -634,19 +663,28 @@ fn test_textinput_unicode_handling() {
fn test_selection_bounds() {
let mut textinput = text_input(Lines::Single, "abcdef");
assert_eq!(TextPoint { line: 0, index: 0 }, textinput.selection_origin_or_edit_point());
assert_eq!(
TextPoint { line: 0, index: 0 },
textinput.selection_origin_or_edit_point()
);
assert_eq!(TextPoint { line: 0, index: 0 }, textinput.selection_start());
assert_eq!(TextPoint { line: 0, index: 0 }, textinput.selection_end());
textinput.set_selection_range(2, 5, SelectionDirection::Forward);
assert_eq!(TextPoint { line: 0, index: 2 }, textinput.selection_origin_or_edit_point());
assert_eq!(
TextPoint { line: 0, index: 2 },
textinput.selection_origin_or_edit_point()
);
assert_eq!(TextPoint { line: 0, index: 2 }, textinput.selection_start());
assert_eq!(TextPoint { line: 0, index: 5 }, textinput.selection_end());
assert_eq!(2, textinput.selection_start_offset());
assert_eq!(5, textinput.selection_end_offset());
textinput.set_selection_range(3, 6, SelectionDirection::Backward);
assert_eq!(TextPoint { line: 0, index: 6 }, textinput.selection_origin_or_edit_point());
assert_eq!(
TextPoint { line: 0, index: 6 },
textinput.selection_origin_or_edit_point()
);
assert_eq!(TextPoint { line: 0, index: 3 }, textinput.selection_start());
assert_eq!(TextPoint { line: 0, index: 6 }, textinput.selection_end());
assert_eq!(3, textinput.selection_start_offset());
@ -654,8 +692,10 @@ fn test_selection_bounds() {
textinput = text_input(Lines::Multiple, "\n\n");
textinput.set_selection_range(0, 1, SelectionDirection::Forward);
assert_eq!(TextPoint { line: 0, index: 0 }, textinput.selection_origin_or_edit_point());
assert_eq!(
TextPoint { line: 0, index: 0 },
textinput.selection_origin_or_edit_point()
);
assert_eq!(TextPoint { line: 0, index: 0 }, textinput.selection_start());
assert_eq!(TextPoint { line: 1, index: 0 }, textinput.selection_end());
}

22
tests/unit/script_plugins/lib.rs
View file

@ -7,13 +7,13 @@ pub mod unrooted_must_root {
```
#![feature(plugin)]
#![plugin(script_plugins)]
#[must_root] struct Foo(i32);
#[must_root] struct Bar(Foo);
fn foo1(_: &Foo) {}
fn foo2(_: &()) -> &Foo { unimplemented!() }
fn main() {}
```
*/
@ -23,10 +23,10 @@ pub mod unrooted_must_root {
```compile_fail
#![feature(plugin)]
#![plugin(script_plugins)]
#[must_root] struct Foo(i32);
struct Bar(Foo);
fn main() {}
```
*/
@ -36,11 +36,11 @@ pub mod unrooted_must_root {
```compile_fail
#![feature(plugin)]
#![plugin(script_plugins)]
#[must_root] struct Foo(i32);
fn foo1(_: Foo) {}
fn main() {}
```
*/
@ -50,11 +50,11 @@ pub mod unrooted_must_root {
```compile_fail
#![feature(plugin)]
#![plugin(script_plugins)]
#[must_root] struct Foo(i32);
fn foo2() -> Foo { unimplemented!() }
fn main() {}
```
*/

172
tests/unit/style/animated_properties.rs
View file

@ -11,53 +11,76 @@ fn interpolate_rgba(from: RGBA, to: RGBA, progress: f64) -> RGBA {
let from = from.to_animated_value();
let to = to.to_animated_value();
RGBA::from_animated_value(
from.animate(&to, Procedure::Interpolate { progress }).unwrap(),
from.animate(&to, Procedure::Interpolate { progress })
.unwrap(),
)
}
// Color
#[test]
fn test_rgba_color_interepolation_preserves_transparent() {
assert_eq!(interpolate_rgba(RGBA::transparent(),
RGBA::transparent(), 0.5),
RGBA::transparent());
assert_eq!(
interpolate_rgba(RGBA::transparent(), RGBA::transparent(), 0.5),
RGBA::transparent()
);
}
#[test]
fn test_rgba_color_interepolation_alpha() {
assert_eq!(interpolate_rgba(RGBA::new(200, 0, 0, 100),
RGBA::new(0, 200, 0, 200), 0.5),
RGBA::new(67, 133, 0, 150));
assert_eq!(
interpolate_rgba(RGBA::new(200, 0, 0, 100), RGBA::new(0, 200, 0, 200), 0.5),
RGBA::new(67, 133, 0, 150)
);
}
#[test]
fn test_rgba_color_interepolation_out_of_range_1() {
// Some cubic-bezier functions produce values that are out of range [0, 1].
// Unclamped cases.
assert_eq!(interpolate_rgba(RGBA::from_floats(0.3, 0.0, 0.0, 0.4),
RGBA::from_floats(0.0, 1.0, 0.0, 0.6), -0.5),
RGBA::new(154, 0, 0, 77));
assert_eq!(
interpolate_rgba(
RGBA::from_floats(0.3, 0.0, 0.0, 0.4),
RGBA::from_floats(0.0, 1.0, 0.0, 0.6),
-0.5
),
RGBA::new(154, 0, 0, 77)
);
}
#[test]
fn test_rgba_color_interepolation_out_of_range_2() {
assert_eq!(interpolate_rgba(RGBA::from_floats(1.0, 0.0, 0.0, 0.6),
RGBA::from_floats(0.0, 0.3, 0.0, 0.4), 1.5),
RGBA::new(0, 154, 0, 77));
assert_eq!(
interpolate_rgba(
RGBA::from_floats(1.0, 0.0, 0.0, 0.6),
RGBA::from_floats(0.0, 0.3, 0.0, 0.4),
1.5
),
RGBA::new(0, 154, 0, 77)
);
}
#[test]
fn test_rgba_color_interepolation_out_of_range_clamped_1() {
assert_eq!(interpolate_rgba(RGBA::from_floats(1.0, 0.0, 0.0, 0.8),
RGBA::from_floats(0.0, 1.0, 0.0, 0.2), -0.5),
RGBA::from_floats(1.0, 0.0, 0.0, 1.0));
assert_eq!(
interpolate_rgba(
RGBA::from_floats(1.0, 0.0, 0.0, 0.8),
RGBA::from_floats(0.0, 1.0, 0.0, 0.2),
-0.5
),
RGBA::from_floats(1.0, 0.0, 0.0, 1.0)
);
}
#[test]
fn test_rgba_color_interepolation_out_of_range_clamped_2() {
assert_eq!(interpolate_rgba(RGBA::from_floats(1.0, 0.0, 0.0, 0.8),
RGBA::from_floats(0.0, 1.0, 0.0, 0.2), 1.5),
RGBA::from_floats(0.0, 0.0, 0.0, 0.0));
assert_eq!(
interpolate_rgba(
RGBA::from_floats(1.0, 0.0, 0.0, 0.8),
RGBA::from_floats(0.0, 1.0, 0.0, 0.2),
1.5
),
RGBA::from_floats(0.0, 0.0, 0.0, 0.0)
);
}
// Transform
@ -65,16 +88,19 @@ fn test_rgba_color_interepolation_out_of_range_clamped_2() {
fn test_transform_interpolation_on_translate() {
use style::values::computed::{CalcLengthOrPercentage, Length, LengthOrPercentage};
let from = Transform(vec![
TransformOperation::Translate3D(LengthOrPercentage::Length(Length::new(0.)),
LengthOrPercentage::Length(Length::new(100.)),
Length::new(25.))]);
let to = Transform(vec![
TransformOperation::Translate3D(LengthOrPercentage::Length(Length::new(100.)),
LengthOrPercentage::Length(Length::new(0.)),
Length::new(75.))]);
let from = Transform(vec![TransformOperation::Translate3D(
LengthOrPercentage::Length(Length::new(0.)),
LengthOrPercentage::Length(Length::new(100.)),
Length::new(25.),
)]);
let to = Transform(vec![TransformOperation::Translate3D(
LengthOrPercentage::Length(Length::new(100.)),
LengthOrPercentage::Length(Length::new(0.)),
Length::new(75.),
)]);
assert_eq!(
from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(),
from.animate(&to, Procedure::Interpolate { progress: 0.5 })
.unwrap(),
Transform(vec![TransformOperation::Translate3D(
LengthOrPercentage::Length(Length::new(50.)),
LengthOrPercentage::Length(Length::new(50.)),
@ -87,19 +113,25 @@ fn test_transform_interpolation_on_translate() {
LengthOrPercentage::Percentage(Percentage(1.0)),
Length::new(25.),
)]);
let to = Transform(vec![
TransformOperation::Translate3D(LengthOrPercentage::Length(Length::new(100.)),
LengthOrPercentage::Length(Length::new(50.)),
Length::new(75.))]);
let to = Transform(vec![TransformOperation::Translate3D(
LengthOrPercentage::Length(Length::new(100.)),
LengthOrPercentage::Length(Length::new(50.)),
Length::new(75.),
)]);
assert_eq!(
from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(),
from.animate(&to, Procedure::Interpolate { progress: 0.5 })
.unwrap(),
Transform(vec![TransformOperation::Translate3D(
// calc(50px + 25%)
LengthOrPercentage::Calc(CalcLengthOrPercentage::new(Length::new(50.),
Some(Percentage(0.25)))),
LengthOrPercentage::Calc(CalcLengthOrPercentage::new(
Length::new(50.),
Some(Percentage(0.25))
)),
// calc(25px + 50%)
LengthOrPercentage::Calc(CalcLengthOrPercentage::new(Length::new(25.),
Some(Percentage(0.5)))),
LengthOrPercentage::Calc(CalcLengthOrPercentage::new(
Length::new(25.),
Some(Percentage(0.5))
)),
Length::new(50.),
)])
);
@ -110,7 +142,8 @@ fn test_transform_interpolation_on_scale() {
let from = Transform(vec![TransformOperation::Scale3D(1.0, 2.0, 1.0)]);
let to = Transform(vec![TransformOperation::Scale3D(2.0, 4.0, 2.0)]);
assert_eq!(
from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(),
from.animate(&to, Procedure::Interpolate { progress: 0.5 })
.unwrap(),
Transform(vec![TransformOperation::Scale3D(1.5, 3.0, 1.5)])
);
}
@ -119,15 +152,27 @@ fn test_transform_interpolation_on_scale() {
fn test_transform_interpolation_on_rotate() {
use style::values::computed::Angle;
let from = Transform(vec![TransformOperation::Rotate3D(0.0, 0.0, 1.0,
Angle::from_radians(0.0))]);
let to = Transform(vec![TransformOperation::Rotate3D(0.0, 0.0, 1.0,
Angle::from_radians(100.0))]);
let from = Transform(vec![TransformOperation::Rotate3D(
0.0,
0.0,
1.0,
Angle::from_radians(0.0),
)]);
let to = Transform(vec![TransformOperation::Rotate3D(
0.0,
0.0,
1.0,
Angle::from_radians(100.0),
)]);
assert_eq!(
from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(),
Transform(vec![
TransformOperation::Rotate3D(0.0, 0.0, 1.0, Angle::from_radians(50.0)),
])
from.animate(&to, Procedure::Interpolate { progress: 0.5 })
.unwrap(),
Transform(vec![TransformOperation::Rotate3D(
0.0,
0.0,
1.0,
Angle::from_radians(50.0)
)])
);
}
@ -135,12 +180,17 @@ fn test_transform_interpolation_on_rotate() {
fn test_transform_interpolation_on_skew() {
use style::values::computed::Angle;
let from = Transform(vec![TransformOperation::Skew(Angle::from_radians(0.0),
Some(Angle::from_radians(100.0)))]);
let to = Transform(vec![TransformOperation::Skew(Angle::from_radians(100.0),
Some(Angle::from_radians(0.0)))]);
let from = Transform(vec![TransformOperation::Skew(
Angle::from_radians(0.0),
Some(Angle::from_radians(100.0)),
)]);
let to = Transform(vec![TransformOperation::Skew(
Angle::from_radians(100.0),
Some(Angle::from_radians(0.0)),
)]);
assert_eq!(
from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(),
from.animate(&to, Procedure::Interpolate { progress: 0.5 })
.unwrap(),
Transform(vec![TransformOperation::Skew(
Angle::from_radians(50.0),
Some(Angle::from_radians(50.0)),
@ -152,14 +202,20 @@ fn test_transform_interpolation_on_skew() {
fn test_transform_interpolation_on_mismatched_lists() {
use style::values::computed::{Angle, Length, LengthOrPercentage};
let from = Transform(vec![TransformOperation::Rotate3D(0.0, 0.0, 1.0,
Angle::from_radians(100.0))]);
let to = Transform(vec![
TransformOperation::Translate3D(LengthOrPercentage::Length(Length::new(100.)),
LengthOrPercentage::Length(Length::new(0.)),
Length::new(0.))]);
let from = Transform(vec![TransformOperation::Rotate3D(
0.0,
0.0,
1.0,
Angle::from_radians(100.0),
)]);
let to = Transform(vec![TransformOperation::Translate3D(
LengthOrPercentage::Length(Length::new(100.)),
LengthOrPercentage::Length(Length::new(0.)),
Length::new(0.),
)]);
assert_eq!(
from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(),
from.animate(&to, Procedure::Interpolate { progress: 0.5 })
.unwrap(),
Transform(vec![TransformOperation::InterpolateMatrix {
from_list: from.clone(),
to_list: to.clone(),

26
tests/unit/style/attr.rs
View file

@ -23,7 +23,7 @@ fn test_parse_double() {
let value = String::from("432.5e2");
match AttrValue::from_double(value, 0.0) {
AttrValue::Double(_, num) => assert_eq!(num, 43250f64),
_ => panic!("expected a double value")
_ => panic!("expected a double value"),
}
}
@ -32,7 +32,7 @@ fn test_parse_double_negative_prefix() {
let value = String::from("-5.6");
match AttrValue::from_double(value, 0.0) {
AttrValue::Double(_, num) => assert_eq!(num, -5.6f64),
_ => panic!("expected a double value")
_ => panic!("expected a double value"),
}
}
@ -41,7 +41,7 @@ fn test_parse_double_positive_prefix() {
let value = String::from("+5.6");
match AttrValue::from_double(value, 0.0) {
AttrValue::Double(_, num) => assert_eq!(num, 5.6f64),
_ => panic!("expected a double value")
_ => panic!("expected a double value"),
}
}
@ -50,7 +50,7 @@ fn test_from_limited_i32_should_be_default_when_less_than_0() {
let value = String::from("-1");
match AttrValue::from_limited_i32(value, 0) {
AttrValue::Int(_, 0) => (),
_ => panic!("expected an IndexSize error")
_ => panic!("expected an IndexSize error"),
}
}
@ -58,17 +58,15 @@ fn test_from_limited_i32_should_be_default_when_less_than_0() {
fn test_from_limited_i32_should_parse_a_uint_when_value_is_0_or_greater() {
match AttrValue::from_limited_i32(String::from("1"), 0) {
AttrValue::Int(_, 1) => (),
_ => panic!("expected an successful parsing")
_ => panic!("expected an successful parsing"),
}
}
#[test]
fn test_from_limited_i32_should_keep_parsed_value_when_not_an_int() {
match AttrValue::from_limited_i32(String::from("parsed-value"), 0) {
AttrValue::Int(p, 0) => {
assert_eq!(p, String::from("parsed-value"))
},
_ => panic!("expected an successful parsing")
AttrValue::Int(p, 0) => assert_eq!(p, String::from("parsed-value")),
_ => panic!("expected an successful parsing"),
}
}
@ -82,7 +80,13 @@ pub fn test_parse_length() {
check("0", LengthOrPercentageOrAuto::Length(Au::from_px(0)));
check("0.000%", LengthOrPercentageOrAuto::Percentage(0.0));
check("+5.82%", LengthOrPercentageOrAuto::Percentage(0.0582));
check("5.82", LengthOrPercentageOrAuto::Length(Au::from_f64_px(5.82)));
check(
"5.82",
LengthOrPercentageOrAuto::Length(Au::from_f64_px(5.82)),
);
check("invalid", LengthOrPercentageOrAuto::Auto);
check("12 followed by invalid", LengthOrPercentageOrAuto::Length(Au::from_px(12)));
check(
"12 followed by invalid",
LengthOrPercentageOrAuto::Length(Au::from_px(12)),
);
}

29
tests/unit/style/custom_properties.rs
View file

@ -12,11 +12,17 @@ fn cascade(
name_and_value: &[(&str, &str)],
inherited: Option<&Arc<CustomPropertiesMap>>,
) -> Option<Arc<CustomPropertiesMap>> {
let values = name_and_value.iter().map(|&(name, value)| {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
(Name::from(name), SpecifiedValue::parse(&mut parser).unwrap())
}).collect::<Vec<_>>();
let values = name_and_value
.iter()
.map(|&(name, value)| {
let mut input = ParserInput::new(value);
let mut parser = Parser::new(&mut input);
(
Name::from(name),
SpecifiedValue::parse(&mut parser).unwrap(),
)
})
.collect::<Vec<_>>();
let env = CssEnvironment;
let mut builder = CustomPropertiesBuilder::new(inherited, &env);
@ -31,14 +37,11 @@ fn cascade(
#[bench]
fn cascade_custom_simple(b: &mut Bencher) {
b.iter(|| {
let parent = cascade(&[
("foo", "10px"),
("bar", "100px"),
], None);
let parent = cascade(&[("foo", "10px"), ("bar", "100px")], None);
test::black_box(cascade(&[
("baz", "calc(40em + 4px)"),
("bazz", "calc(30em + 4px)"),
], parent.as_ref()))
test::black_box(cascade(
&[("baz", "calc(40em + 4px)"), ("bazz", "calc(30em + 4px)")],
parent.as_ref(),
))
})
}

9
tests/unit/style/lib.rs
View file

@ -8,7 +8,8 @@
extern crate app_units;
extern crate cssparser;
extern crate euclid;
#[macro_use] extern crate html5ever;
#[macro_use]
extern crate html5ever;
extern crate parking_lot;
extern crate rayon;
extern crate selectors;
@ -17,8 +18,10 @@ extern crate servo_arc;
extern crate servo_atoms;
extern crate servo_config;
extern crate servo_url;
#[macro_use] extern crate size_of_test;
#[macro_use] extern crate style;
#[macro_use]
extern crate size_of_test;
#[macro_use]
extern crate style;
extern crate style_traits;
extern crate test;

24
tests/unit/style/parsing/animation.rs
View file

@ -14,14 +14,22 @@ use style_traits::ToCss;
fn test_animation_name() {
use self::animation_name::single_value::SpecifiedValue as SingleValue;
let other_name = Atom::from("other-name");
assert_eq!(parse_longhand!(animation_name, "none"),
animation_name::SpecifiedValue(vec![SingleValue(None)]));
assert_eq!(parse_longhand!(animation_name, "other-name, none, 'other-name', \"other-name\""),
animation_name::SpecifiedValue(
vec![SingleValue(Some(KeyframesName::Ident(CustomIdent(other_name.clone())))),
SingleValue(None),
SingleValue(Some(KeyframesName::QuotedString(other_name.clone()))),
SingleValue(Some(KeyframesName::QuotedString(other_name.clone())))]));
assert_eq!(
parse_longhand!(animation_name, "none"),
animation_name::SpecifiedValue(vec![SingleValue(None)])
);
assert_eq!(
parse_longhand!(
animation_name,
"other-name, none, 'other-name', \"other-name\""
),
animation_name::SpecifiedValue(vec![
SingleValue(Some(KeyframesName::Ident(CustomIdent(other_name.clone())))),
SingleValue(None),
SingleValue(Some(KeyframesName::QuotedString(other_name.clone()))),
SingleValue(Some(KeyframesName::QuotedString(other_name.clone())))
])
);
}
#[test]

211
tests/unit/style/parsing/background.rs
View file

@ -13,72 +13,179 @@ fn background_shorthand_should_parse_all_available_properties_when_specified() {
let input = "url(\"http://servo/test.png\") top center / 200px 200px repeat-x fixed padding-box content-box red";
let result = parse(background::parse_value, input).unwrap();
assert_eq!(result.background_image, parse_longhand!(background_image, "url(\"http://servo/test.png\")"));
assert_eq!(result.background_position_x, parse_longhand!(background_position_x, "center"));
assert_eq!(result.background_position_y, parse_longhand!(background_position_y, "top"));
assert_eq!(result.background_size, parse_longhand!(background_size, "200px 200px"));
assert_eq!(result.background_repeat, parse_longhand!(background_repeat, "repeat-x"));
assert_eq!(result.background_attachment, parse_longhand!(background_attachment, "fixed"));
assert_eq!(result.background_origin, parse_longhand!(background_origin, "padding-box"));
assert_eq!(result.background_clip, parse_longhand!(background_clip, "content-box"));
assert_eq!(result.background_color, parse_longhand!(background_color, "red"));
assert_eq!(
result.background_image,
parse_longhand!(background_image, "url(\"http://servo/test.png\")")
);
assert_eq!(
result.background_position_x,
parse_longhand!(background_position_x, "center")
);
assert_eq!(
result.background_position_y,
parse_longhand!(background_position_y, "top")
);
assert_eq!(
result.background_size,
parse_longhand!(background_size, "200px 200px")
);
assert_eq!(
result.background_repeat,
parse_longhand!(background_repeat, "repeat-x")
);
assert_eq!(
result.background_attachment,
parse_longhand!(background_attachment, "fixed")
);
assert_eq!(
result.background_origin,
parse_longhand!(background_origin, "padding-box")
);
assert_eq!(
result.background_clip,
parse_longhand!(background_clip, "content-box")
);
assert_eq!(
result.background_color,
parse_longhand!(background_color, "red")
);
}
#[test]
fn background_shorthand_should_parse_when_some_fields_set() {
let result = parse(background::parse_value, "14px 40px repeat-y").unwrap();
assert_eq!(result.background_position_x, parse_longhand!(background_position_x, "14px"));
assert_eq!(result.background_position_y, parse_longhand!(background_position_y, "40px"));
assert_eq!(result.background_repeat, parse_longhand!(background_repeat, "repeat-y"));
assert_eq!(
result.background_position_x,
parse_longhand!(background_position_x, "14px")
);
assert_eq!(
result.background_position_y,
parse_longhand!(background_position_y, "40px")
);
assert_eq!(
result.background_repeat,
parse_longhand!(background_repeat, "repeat-y")
);
let result = parse(background::parse_value, "url(\"http://servo/test.png\") repeat blue").unwrap();
let result = parse(
background::parse_value,
"url(\"http://servo/test.png\") repeat blue",
)
.unwrap();
assert_eq!(result.background_image, parse_longhand!(background_image, "url(\"http://servo/test.png\")"));
assert_eq!(result.background_repeat, parse_longhand!(background_repeat, "repeat"));
assert_eq!(result.background_color, parse_longhand!(background_color, "blue"));
assert_eq!(
result.background_image,
parse_longhand!(background_image, "url(\"http://servo/test.png\")")
);
assert_eq!(
result.background_repeat,
parse_longhand!(background_repeat, "repeat")
);
assert_eq!(
result.background_color,
parse_longhand!(background_color, "blue")
);
let result = parse(background::parse_value, "padding-box").unwrap();
assert_eq!(result.background_origin, parse_longhand!(background_origin, "padding-box"));
assert_eq!(result.background_clip, parse_longhand!(background_clip, "padding-box"));
assert_eq!(
result.background_origin,
parse_longhand!(background_origin, "padding-box")
);
assert_eq!(
result.background_clip,
parse_longhand!(background_clip, "padding-box")
);
let result = parse(background::parse_value, "url(\"http://servo/test.png\")").unwrap();
assert_eq!(result.background_image, parse_longhand!(background_image, "url(\"http://servo/test.png\")"));
assert_eq!(
result.background_image,
parse_longhand!(background_image, "url(\"http://servo/test.png\")")
);
}
#[test]
fn background_shorthand_should_parse_comma_separated_declarations() {
let input = "url(\"http://servo/test.png\") top left no-repeat, url(\"http://servo/test.png\") \
center / 100% 100% no-repeat, white";
let input =
"url(\"http://servo/test.png\") top left no-repeat, url(\"http://servo/test.png\") \
center / 100% 100% no-repeat, white";
let result = parse(background::parse_value, input).unwrap();
assert_eq!(result.background_image, parse_longhand!(background_image, "url(\"http://servo/test.png\"), \
url(\"http://servo/test.png\"), none"));
assert_eq!(result.background_position_x, parse_longhand!(background_position_x, "left, center, 0%"));
assert_eq!(result.background_position_y, parse_longhand!(background_position_y, "top, center, 0%"));
assert_eq!(result.background_repeat, parse_longhand!(background_repeat, "no-repeat, no-repeat, repeat"));
assert_eq!(result.background_clip, parse_longhand!(background_clip, "border-box, border-box, border-box"));
assert_eq!(result.background_origin, parse_longhand!(background_origin, "padding-box, padding-box, \
padding-box"));
assert_eq!(result.background_size, parse_longhand!(background_size, "auto auto, 100% 100%, auto auto"));
assert_eq!(result.background_attachment, parse_longhand!(background_attachment, "scroll, scroll, scroll"));
assert_eq!(result.background_color, parse_longhand!(background_color, "white"));
assert_eq!(
result.background_image,
parse_longhand!(
background_image,
"url(\"http://servo/test.png\"), \
url(\"http://servo/test.png\"), none"
)
);
assert_eq!(
result.background_position_x,
parse_longhand!(background_position_x, "left, center, 0%")
);
assert_eq!(
result.background_position_y,
parse_longhand!(background_position_y, "top, center, 0%")
);
assert_eq!(
result.background_repeat,
parse_longhand!(background_repeat, "no-repeat, no-repeat, repeat")
);
assert_eq!(
result.background_clip,
parse_longhand!(background_clip, "border-box, border-box, border-box")
);
assert_eq!(
result.background_origin,
parse_longhand!(
background_origin,
"padding-box, padding-box, \
padding-box"
)
);
assert_eq!(
result.background_size,
parse_longhand!(background_size, "auto auto, 100% 100%, auto auto")
);
assert_eq!(
result.background_attachment,
parse_longhand!(background_attachment, "scroll, scroll, scroll")
);
assert_eq!(
result.background_color,
parse_longhand!(background_color, "white")
);
}
#[test]
fn background_shorthand_should_parse_position_and_size_correctly() {
let result = parse(background::parse_value, "7px 4px").unwrap();
assert_eq!(result.background_position_x, parse_longhand!(background_position_x, "7px"));
assert_eq!(result.background_position_y, parse_longhand!(background_position_y, "4px"));
assert_eq!(
result.background_position_x,
parse_longhand!(background_position_x, "7px")
);
assert_eq!(
result.background_position_y,
parse_longhand!(background_position_y, "4px")
);
let result = parse(background::parse_value, "7px 4px / 30px 20px").unwrap();
assert_eq!(result.background_position_x, parse_longhand!(background_position_x, "7px"));
assert_eq!(result.background_position_y, parse_longhand!(background_position_y, "4px"));
assert_eq!(result.background_size, parse_longhand!(background_size, "30px 20px"));
assert_eq!(
result.background_position_x,
parse_longhand!(background_position_x, "7px")
);
assert_eq!(
result.background_position_y,
parse_longhand!(background_position_y, "4px")
);
assert_eq!(
result.background_size,
parse_longhand!(background_size, "30px 20px")
);
assert!(parse(background::parse_value, "/ 30px 20px").is_err());
@ -89,16 +196,34 @@ fn background_shorthand_should_parse_position_and_size_correctly() {
fn background_shorthand_should_parse_origin_and_clip_correctly() {
let result = parse(background::parse_value, "padding-box content-box").unwrap();
assert_eq!(result.background_origin, parse_longhand!(background_origin, "padding-box"));
assert_eq!(result.background_clip, parse_longhand!(background_clip, "content-box"));
assert_eq!(
result.background_origin,
parse_longhand!(background_origin, "padding-box")
);
assert_eq!(
result.background_clip,
parse_longhand!(background_clip, "content-box")
);
let result = parse(background::parse_value, "padding-box padding-box").unwrap();
assert_eq!(result.background_origin, parse_longhand!(background_origin, "padding-box"));
assert_eq!(result.background_clip, parse_longhand!(background_clip, "padding-box"));
assert_eq!(
result.background_origin,
parse_longhand!(background_origin, "padding-box")
);
assert_eq!(
result.background_clip,
parse_longhand!(background_clip, "padding-box")
);
let result = parse(background::parse_value, "padding-box").unwrap();
assert_eq!(result.background_origin, parse_longhand!(background_origin, "padding-box"));
assert_eq!(result.background_clip, parse_longhand!(background_clip, "padding-box"));
assert_eq!(
result.background_origin,
parse_longhand!(background_origin, "padding-box")
);
assert_eq!(
result.background_clip,
parse_longhand!(background_clip, "padding-box")
);
}

59
tests/unit/style/parsing/border.rs
View file

@ -13,31 +13,60 @@ use style_traits::ToCss;
macro_rules! assert_longhand {
($parsed_shorthand: expr, $prop: ident, $value_string: expr) => {
assert_eq!($parsed_shorthand.$prop, parse_longhand!($prop, $value_string).maybe_boxed())
}
assert_eq!(
$parsed_shorthand.$prop,
parse_longhand!($prop, $value_string).maybe_boxed()
)
};
}
macro_rules! assert_initial {
($parsed_shorthand: expr, $prop: ident) => {
assert_eq!($parsed_shorthand.$prop, $prop::get_initial_specified_value().maybe_boxed())
}
assert_eq!(
$parsed_shorthand.$prop,
$prop::get_initial_specified_value().maybe_boxed()
)
};
}
macro_rules! assert_border_radius_values {
($input:expr; $tlw:expr, $trw:expr, $brw:expr, $blw:expr ;
$tlh:expr, $trh:expr, $brh:expr, $blh:expr) => {
let input = parse(BorderRadius::parse, $input)
.expect(&format!("Failed parsing {} as border radius",
$input));
assert_eq!(::style_traits::ToCss::to_css_string(&input.top_left.0.width()), $tlw);
assert_eq!(::style_traits::ToCss::to_css_string(&input.top_right.0.width()), $trw);
assert_eq!(::style_traits::ToCss::to_css_string(&input.bottom_right.0.width()), $brw);
assert_eq!(::style_traits::ToCss::to_css_string(&input.bottom_left.0.width()), $blw);
assert_eq!(::style_traits::ToCss::to_css_string(&input.top_left.0.height()), $tlh);
assert_eq!(::style_traits::ToCss::to_css_string(&input.top_right.0.height()), $trh);
assert_eq!(::style_traits::ToCss::to_css_string(&input.bottom_right.0.height()), $brh);
assert_eq!(::style_traits::ToCss::to_css_string(&input.bottom_left.0.height()), $blh);
}
.expect(&format!("Failed parsing {} as border radius", $input));
assert_eq!(
::style_traits::ToCss::to_css_string(&input.top_left.0.width()),
$tlw
);
assert_eq!(
::style_traits::ToCss::to_css_string(&input.top_right.0.width()),
$trw
);
assert_eq!(
::style_traits::ToCss::to_css_string(&input.bottom_right.0.width()),
$brw
);
assert_eq!(
::style_traits::ToCss::to_css_string(&input.bottom_left.0.width()),
$blw
);
assert_eq!(
::style_traits::ToCss::to_css_string(&input.top_left.0.height()),
$tlh
);
assert_eq!(
::style_traits::ToCss::to_css_string(&input.top_right.0.height()),
$trh
);
assert_eq!(
::style_traits::ToCss::to_css_string(&input.bottom_right.0.height()),
$brh
);
assert_eq!(
::style_traits::ToCss::to_css_string(&input.bottom_left.0.height()),
$blh
);
};
}
#[test]

38
tests/unit/style/parsing/effects.rs
View file

@ -16,18 +16,26 @@ fn test_clip() {
assert_roundtrip_with_context!(clip::parse, "rect(auto, auto, auto, auto)");
// Non-standard syntax
assert_roundtrip_with_context!(clip::parse,
"rect(1px 2px 3px 4px)",
"rect(1px, 2px, 3px, 4px)");
assert_roundtrip_with_context!(clip::parse,
"rect(auto 2px 3px auto)",
"rect(auto, 2px, 3px, auto)");
assert_roundtrip_with_context!(clip::parse,
"rect(1px auto auto 4px)",
"rect(1px, auto, auto, 4px)");
assert_roundtrip_with_context!(clip::parse,
"rect(auto auto auto auto)",
"rect(auto, auto, auto, auto)");
assert_roundtrip_with_context!(
clip::parse,
"rect(1px 2px 3px 4px)",
"rect(1px, 2px, 3px, 4px)"
);
assert_roundtrip_with_context!(
clip::parse,
"rect(auto 2px 3px auto)",
"rect(auto, 2px, 3px, auto)"
);
assert_roundtrip_with_context!(
clip::parse,
"rect(1px auto auto 4px)",
"rect(1px, auto, auto, 4px)"
);
assert_roundtrip_with_context!(
clip::parse,
"rect(auto auto auto auto)",
"rect(auto, auto, auto, auto)"
);
}
#[test]
@ -85,7 +93,7 @@ fn test_parse_factor() {
#[test]
fn blur_radius_should_not_accept_negavite_values() {
use style::properties::longhands::box_shadow;
assert!(parse(box_shadow::parse, "1px 1px -1px").is_err());// for -ve values
assert!(parse(box_shadow::parse, "1px 1px 0").is_ok());// for zero
assert!(parse(box_shadow::parse, "1px 1px 1px").is_ok());// for +ve value
assert!(parse(box_shadow::parse, "1px 1px -1px").is_err()); // for -ve values
assert!(parse(box_shadow::parse, "1px 1px 0").is_ok()); // for zero
assert!(parse(box_shadow::parse, "1px 1px 1px").is_ok()); // for +ve value
}

162
tests/unit/style/parsing/image.rs
View file

@ -33,72 +33,122 @@ fn test_linear_gradient() {
#[test]
fn test_radial_gradient() {
// Parsing with all values
assert_roundtrip_with_context!(Image::parse, "radial-gradient(circle closest-side at 20px 30px, red, green)");
assert_roundtrip_with_context!(Image::parse, "radial-gradient(ellipse closest-side at 20px 30px, red, green)",
"radial-gradient(closest-side at 20px 30px, red, green)");
assert_roundtrip_with_context!(Image::parse, "radial-gradient(closest-side circle at 20px 30px, red, green)",
"radial-gradient(circle closest-side at 20px 30px, red, green)");
assert_roundtrip_with_context!(Image::parse, "radial-gradient(closest-side ellipse at 20px 30px, red, green)",
"radial-gradient(closest-side at 20px 30px, red, green)");
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(circle closest-side at 20px 30px, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(ellipse closest-side at 20px 30px, red, green)",
"radial-gradient(closest-side at 20px 30px, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(closest-side circle at 20px 30px, red, green)",
"radial-gradient(circle closest-side at 20px 30px, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(closest-side ellipse at 20px 30px, red, green)",
"radial-gradient(closest-side at 20px 30px, red, green)"
);
// Parsing with <shape-keyword> and <size> reversed
assert_roundtrip_with_context!(Image::parse, "radial-gradient(closest-side circle at 20px 30px, red, green)",
"radial-gradient(circle closest-side at 20px 30px, red, green)");
assert_roundtrip_with_context!(Image::parse, "radial-gradient(closest-corner ellipse at 20px 30px, red, green)",
"radial-gradient(closest-corner at 20px 30px, red, green)");
assert_roundtrip_with_context!(Image::parse, "radial-gradient(30px circle, red, green)",
"radial-gradient(30px at center center, red, green)");
assert_roundtrip_with_context!(Image::parse, "radial-gradient(30px 40px ellipse, red, green)",
"radial-gradient(30px 40px at center center, red, green)");
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(closest-side circle at 20px 30px, red, green)",
"radial-gradient(circle closest-side at 20px 30px, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(closest-corner ellipse at 20px 30px, red, green)",
"radial-gradient(closest-corner at 20px 30px, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(30px circle, red, green)",
"radial-gradient(30px at center center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(30px 40px ellipse, red, green)",
"radial-gradient(30px 40px at center center, red, green)"
);
// Parsing without <size>
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(circle, red, green)",
"radial-gradient(circle at center center, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(ellipse, red, green)",
"radial-gradient(at center center, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(circle at 20px 30px, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(ellipse at 20px 30px, red, green)",
"radial-gradient(at 20px 30px, red, green)");
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(circle, red, green)",
"radial-gradient(circle at center center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(ellipse, red, green)",
"radial-gradient(at center center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(circle at 20px 30px, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(ellipse at 20px 30px, red, green)",
"radial-gradient(at 20px 30px, red, green)"
);
// Parsing without <shape-keyword>
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(20px at 20px 30px, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(20px 30px at left center, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(closest-side at center, red, green)",
"radial-gradient(closest-side at center center, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(20px, red, green)",
"radial-gradient(20px at center center, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(20px 30px, red, green)",
"radial-gradient(20px 30px at center center, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(closest-side, red, green)",
"radial-gradient(closest-side at center center, red, green)");
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(20px at 20px 30px, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(20px 30px at left center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(closest-side at center, red, green)",
"radial-gradient(closest-side at center center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(20px, red, green)",
"radial-gradient(20px at center center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(20px 30px, red, green)",
"radial-gradient(20px 30px at center center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(closest-side, red, green)",
"radial-gradient(closest-side at center center, red, green)"
);
// Parsing without <shape-keyword> and <size>
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(at center, red, green)",
"radial-gradient(at center center, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(at center bottom, red, green)");
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(at 40px 50px, red, green)");
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(at center, red, green)",
"radial-gradient(at center center, red, green)"
);
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(at center bottom, red, green)"
);
assert_roundtrip_with_context!(Image::parse, "radial-gradient(at 40px 50px, red, green)");
// Parsing with just color stops
assert_roundtrip_with_context!(Image::parse,
"radial-gradient(red, green)",
"radial-gradient(at center center, red, green)");
assert_roundtrip_with_context!(
Image::parse,
"radial-gradient(red, green)",
"radial-gradient(at center center, red, green)"
);
// Parsing repeating radial gradient
assert_roundtrip_with_context!(Image::parse,
"repeating-radial-gradient(red, green)",
"repeating-radial-gradient(at center center, red, green)");
assert_roundtrip_with_context!(
Image::parse,
"repeating-radial-gradient(red, green)",
"repeating-radial-gradient(at center center, red, green)"
);
}

10
tests/unit/style/parsing/inherited_text.rs
View file

@ -11,7 +11,9 @@ fn negative_letter_spacing_should_parse_properly() {
use style::values::specified::length::{Length, NoCalcLength, FontRelativeLength};
let negative_value = parse_longhand!(letter_spacing, "-0.5em");
let expected = Spacing::Value(Length::NoCalc(NoCalcLength::FontRelative(FontRelativeLength::Em(-0.5))));
let expected = Spacing::Value(Length::NoCalc(NoCalcLength::FontRelative(
FontRelativeLength::Em(-0.5),
)));
assert_eq!(negative_value, expected);
}
@ -21,9 +23,9 @@ fn negative_word_spacing_should_parse_properly() {
use style::values::specified::length::{NoCalcLength, LengthOrPercentage, FontRelativeLength};
let negative_value = parse_longhand!(word_spacing, "-0.5em");
let expected = Spacing::Value(LengthOrPercentage::Length(
NoCalcLength::FontRelative(FontRelativeLength::Em(-0.5))
));
let expected = Spacing::Value(LengthOrPercentage::Length(NoCalcLength::FontRelative(
FontRelativeLength::Em(-0.5),
)));
assert_eq!(negative_value, expected);
}

92
tests/unit/style/parsing/mod.rs
View file

@ -11,13 +11,17 @@ use style::stylesheets::{CssRuleType, Origin};
use style_traits::{ParsingMode, ParseError};
fn parse<T, F>(f: F, s: &'static str) -> Result<T, ParseError<'static>>
where F: for<'t> Fn(&ParserContext, &mut Parser<'static, 't>) -> Result<T, ParseError<'static>> {
where
F: for<'t> Fn(&ParserContext, &mut Parser<'static, 't>) -> Result<T, ParseError<'static>>,
{
let mut input = ParserInput::new(s);
parse_input(f, &mut input)
}
fn parse_input<'i: 't, 't, T, F>(f: F, input: &'t mut ParserInput<'i>) -> Result<T, ParseError<'i>>
where F: Fn(&ParserContext, &mut Parser<'i, 't>) -> Result<T, ParseError<'i>> {
where
F: Fn(&ParserContext, &mut Parser<'i, 't>) -> Result<T, ParseError<'i>>,
{
let url = ::servo_url::ServoUrl::parse("http://localhost").unwrap();
let context = ParserContext::new(
Origin::Author,
@ -33,14 +37,24 @@ where F: Fn(&ParserContext, &mut Parser<'i, 't>) -> Result<T, ParseError<'i>> {
}
fn parse_entirely<T, F>(f: F, s: &'static str) -> Result<T, ParseError<'static>>
where F: for<'t> Fn(&ParserContext, &mut Parser<'static, 't>) -> Result<T, ParseError<'static>> {
where
F: for<'t> Fn(&ParserContext, &mut Parser<'static, 't>) -> Result<T, ParseError<'static>>,
{
let mut input = ParserInput::new(s);
parse_entirely_input(f, &mut input)
}
fn parse_entirely_input<'i: 't, 't, T, F>(f: F, input: &'t mut ParserInput<'i>) -> Result<T, ParseError<'i>>
where F: Fn(&ParserContext, &mut Parser<'i, 't>) -> Result<T, ParseError<'i>> {
parse_input(|context, parser| parser.parse_entirely(|p| f(context, p)), input)
fn parse_entirely_input<'i: 't, 't, T, F>(
f: F,
input: &'t mut ParserInput<'i>,
) -> Result<T, ParseError<'i>>
where
F: Fn(&ParserContext, &mut Parser<'i, 't>) -> Result<T, ParseError<'i>>,
{
parse_input(
|context, parser| parser.parse_entirely(|p| f(context, p)),
input,
)
}
// This is a macro so that the file/line information
@ -51,24 +65,31 @@ macro_rules! assert_roundtrip_with_context {
};
($fun:expr, $input:expr, $output:expr) => {{
let mut input = ::cssparser::ParserInput::new($input);
let serialized = super::parse_input(|context, i| {
let parsed = $fun(context, i)
.expect(&format!("Failed to parse {}", $input));
let serialized = ToCss::to_css_string(&parsed);
assert_eq!(serialized, $output);
Ok(serialized)
}, &mut input).unwrap();
let serialized = super::parse_input(
|context, i| {
let parsed = $fun(context, i).expect(&format!("Failed to parse {}", $input));
let serialized = ToCss::to_css_string(&parsed);
assert_eq!(serialized, $output);
Ok(serialized)
},
&mut input,
)
.unwrap();
let mut input = ::cssparser::ParserInput::new(&serialized);
let unwrapped = super::parse_input(|context, i| {
let re_parsed = $fun(context, i)
.expect(&format!("Failed to parse serialization {}", $input));
let re_serialized = ToCss::to_css_string(&re_parsed);
assert_eq!(serialized, re_serialized);
Ok(())
}, &mut input).unwrap();
let unwrapped = super::parse_input(
|context, i| {
let re_parsed =
$fun(context, i).expect(&format!("Failed to parse serialization {}", $input));
let re_serialized = ToCss::to_css_string(&re_parsed);
assert_eq!(serialized, re_serialized);
Ok(())
},
&mut input,
)
.unwrap();
unwrapped
}}
}};
}
macro_rules! assert_roundtrip {
@ -78,34 +99,37 @@ macro_rules! assert_roundtrip {
($fun:expr, $input:expr, $output:expr) => {
let mut input = ParserInput::new($input);
let mut parser = Parser::new(&mut input);
let parsed = $fun(&mut parser)
.expect(&format!("Failed to parse {}", $input));
let parsed = $fun(&mut parser).expect(&format!("Failed to parse {}", $input));
let serialized = ToCss::to_css_string(&parsed);
assert_eq!(serialized, $output);
let mut input = ParserInput::new(&serialized);
let mut parser = Parser::new(&mut input);
let re_parsed = $fun(&mut parser)
.expect(&format!("Failed to parse serialization {}", $input));
let re_parsed =
$fun(&mut parser).expect(&format!("Failed to parse serialization {}", $input));
let re_serialized = ToCss::to_css_string(&re_parsed);
assert_eq!(serialized, re_serialized)
}
};
}
macro_rules! assert_parser_exhausted {
($fun:expr, $string:expr, $should_exhausted:expr) => {{
parse(|context, input| {
let parsed = $fun(context, input);
assert_eq!(parsed.is_ok(), true);
assert_eq!(input.is_exhausted(), $should_exhausted);
Ok(())
}, $string).unwrap()
}}
parse(
|context, input| {
let parsed = $fun(context, input);
assert_eq!(parsed.is_ok(), true);
assert_eq!(input.is_exhausted(), $should_exhausted);
Ok(())
},
$string,
)
.unwrap()
}};
}
macro_rules! parse_longhand {
($name:ident, $s:expr) => {
parse($name::parse, $s).unwrap()
parse($name::parse, $s).unwrap()
};
}

1
tests/unit/style/parsing/position.rs
View file

@ -143,4 +143,3 @@ fn test_vertical_position() {
assert!(parse(VerticalPosition::parse, "y-start").is_err());
assert!(parse(VerticalPosition::parse, "y-end").is_err());
}

9
tests/unit/style/parsing/selectors.rs
View file

@ -8,7 +8,9 @@ use style::selector_parser::{SelectorImpl, SelectorParser};
use style::stylesheets::{Origin, Namespaces};
use style_traits::ParseError;
fn parse_selector<'i, 't>(input: &mut Parser<'i, 't>) -> Result<SelectorList<SelectorImpl>, ParseError<'i>> {
fn parse_selector<'i, 't>(
input: &mut Parser<'i, 't>,
) -> Result<SelectorList<SelectorImpl>, ParseError<'i>> {
let mut ns = Namespaces::default();
ns.prefixes.insert("svg".into(), ns!(svg));
let parser = SelectorParser {
@ -24,7 +26,10 @@ fn test_selectors() {
assert_roundtrip!(parse_selector, "div");
assert_roundtrip!(parse_selector, "svg|circle");
assert_roundtrip!(parse_selector, "p:before", "p::before");
assert_roundtrip!(parse_selector, "[border=\"0\"]:-servo-nonzero-border ~ ::-servo-details-summary");
assert_roundtrip!(
parse_selector,
"[border=\"0\"]:-servo-nonzero-border ~ ::-servo-details-summary"
);
assert_roundtrip!(parse_selector, "* > *");
assert_roundtrip!(parse_selector, "*|* + *", "* + *");
}

5
tests/unit/style/parsing/supports.rs
View file

@ -10,7 +10,10 @@ use style_traits::ToCss;
fn test_supports_condition() {
assert_roundtrip!(SupportsCondition::parse, "(margin: 1px)");
assert_roundtrip!(SupportsCondition::parse, "not (--be: to be)");
assert_roundtrip!(SupportsCondition::parse, "(color: blue) and future-extension(4)");
assert_roundtrip!(
SupportsCondition::parse,
"(color: blue) and future-extension(4)"
);
assert_roundtrip!(SupportsCondition::parse, "future-\\1 extension(4)");
assert_roundtrip!(SupportsCondition::parse, "((test))");
}

45
tests/unit/style/parsing/transition_timing_function.rs
View file

@ -8,14 +8,41 @@ use style_traits::ToCss;
#[test]
fn test_cubic_bezier() {
assert_roundtrip_with_context!(transition_timing_function::parse, "cubic-bezier(0, 0, 0, 0)");
assert_roundtrip_with_context!(transition_timing_function::parse, "cubic-bezier(0.25, 0, 0.5, 0)");
assert_roundtrip_with_context!(transition_timing_function::parse, "cubic-bezier(1, 1, 1, 1)");
assert_roundtrip_with_context!(
transition_timing_function::parse,
"cubic-bezier(0, 0, 0, 0)"
);
assert_roundtrip_with_context!(
transition_timing_function::parse,
"cubic-bezier(0.25, 0, 0.5, 0)"
);
assert_roundtrip_with_context!(
transition_timing_function::parse,
"cubic-bezier(1, 1, 1, 1)"
);
// p1x and p2x values must be in range [0, 1]
assert!(parse(transition_timing_function::parse, "cubic-bezier(-1, 0, 0, 0").is_err());
assert!(parse(transition_timing_function::parse, "cubic-bezier(0, 0, -1, 0").is_err());
assert!(parse(transition_timing_function::parse, "cubic-bezier(-1, 0, -1, 0").is_err());
assert!(
parse(
transition_timing_function::parse,
"cubic-bezier(-1, 0, 0, 0"
)
.is_err()
);
assert!(
parse(
transition_timing_function::parse,
"cubic-bezier(0, 0, -1, 0"
)
.is_err()
);
assert!(
parse(
transition_timing_function::parse,
"cubic-bezier(-1, 0, -1, 0"
)
.is_err()
);
assert!(parse(transition_timing_function::parse, "cubic-bezier(2, 0, 0, 0").is_err());
assert!(parse(transition_timing_function::parse, "cubic-bezier(0, 0, 2, 0").is_err());
@ -27,7 +54,11 @@ fn test_steps() {
assert_roundtrip_with_context!(transition_timing_function::parse, "steps(1)");
assert_roundtrip_with_context!(transition_timing_function::parse, "steps( 1)", "steps(1)");
assert_roundtrip_with_context!(transition_timing_function::parse, "steps(1, start)");
assert_roundtrip_with_context!(transition_timing_function::parse, "steps(2, end) ", "steps(2)");
assert_roundtrip_with_context!(
transition_timing_function::parse,
"steps(2, end) ",
"steps(2)"
);
// Step interval value must be an integer greater than 0
assert!(parse(transition_timing_function::parse, "steps(0)").is_err());

42
tests/unit/style/properties/mod.rs
View file

@ -10,10 +10,7 @@ use style_traits::{ParsingMode, ParseError};
fn parse<T, F>(f: F, s: &'static str) -> Result<T, ParseError<'static>>
where
F: for<'t> Fn(
&ParserContext,
&mut Parser<'static, 't>,
) -> Result<T, ParseError<'static>>
F: for<'t> Fn(&ParserContext, &mut Parser<'static, 't>) -> Result<T, ParseError<'static>>,
{
let mut input = ParserInput::new(s);
parse_input(f, &mut input)
@ -42,24 +39,31 @@ macro_rules! assert_roundtrip_with_context {
assert_roundtrip_with_context!($fun, $string, $string);
};
($fun:expr, $input:expr, $output:expr) => {{
let serialized = parse(|context, i| {
let parsed = $fun(context, i)
.expect(&format!("Failed to parse {}", $input));
let serialized = ToCss::to_css_string(&parsed);
assert_eq!(serialized, $output);
Ok(serialized)
}, $input).unwrap();
let serialized = parse(
|context, i| {
let parsed = $fun(context, i).expect(&format!("Failed to parse {}", $input));
let serialized = ToCss::to_css_string(&parsed);
assert_eq!(serialized, $output);
Ok(serialized)
},
$input,
)
.unwrap();
let mut input = ::cssparser::ParserInput::new(&serialized);
let unwrapped = parse_input(|context, i| {
let re_parsed = $fun(context, i)
.expect(&format!("Failed to parse serialization {}", $input));
let re_serialized = ToCss::to_css_string(&re_parsed);
assert_eq!(serialized, re_serialized);
Ok(())
}, &mut input).unwrap();
let unwrapped = parse_input(
|context, i| {
let re_parsed =
$fun(context, i).expect(&format!("Failed to parse serialization {}", $input));
let re_serialized = ToCss::to_css_string(&re_parsed);
assert_eq!(serialized, re_serialized);
Ok(())
},
&mut input,
)
.unwrap();
unwrapped
}}
}};
}
mod scaffolding;

40
tests/unit/style/properties/scaffolding.rs
View file

@ -10,13 +10,24 @@ use std::process::Command;
#[test]
fn properties_list_json() {
let top = Path::new(&env::var("CARGO_MANIFEST_DIR").unwrap()).join("..").join("..").join("..");
let json = top.join("target").join("doc").join("servo").join("css-properties.json");
let top = Path::new(&env::var("CARGO_MANIFEST_DIR").unwrap())
.join("..")
.join("..")
.join("..");
let json = top
.join("target")
.join("doc")
.join("servo")
.join("css-properties.json");
if json.exists() {
remove_file(&json).unwrap()
}
let python = env::var("PYTHON").ok().unwrap_or_else(find_python);
let script = top.join("components").join("style").join("properties").join("build.py");
let script = top
.join("components")
.join("style")
.join("properties")
.join("build.py");
let status = Command::new(python)
.arg(&script)
.arg("servo")
@ -34,11 +45,19 @@ fn properties_list_json() {
#[cfg(windows)]
fn find_python() -> String {
if Command::new("python2.7.exe").arg("--version").output().is_ok() {
if Command::new("python2.7.exe")
.arg("--version")
.output()
.is_ok()
{
return "python2.7.exe".to_owned();
}
if Command::new("python27.exe").arg("--version").output().is_ok() {
if Command::new("python27.exe")
.arg("--version")
.output()
.is_ok()
{
return "python27.exe".to_owned();
}
@ -51,9 +70,16 @@ fn find_python() -> String {
#[cfg(not(windows))]
fn find_python() -> String {
if Command::new("python2.7").arg("--version").output().unwrap().status.success() {
if Command::new("python2.7")
.arg("--version")
.output()
.unwrap()
.status
.success()
{
"python2.7"
} else {
"python"
}.to_owned()
}
.to_owned()
}

395
tests/unit/style/properties/serialization.rs
View file

@ -32,28 +32,36 @@ fn property_declaration_block_should_serialize_correctly() {
use style::properties::longhands::overflow_x::SpecifiedValue as OverflowValue;
let declarations = vec![
(PropertyDeclaration::Width(
LengthOrPercentageOrAuto::Length(NoCalcLength::from_px(70f32))),
Importance::Normal),
(PropertyDeclaration::MinHeight(
LengthOrPercentage::Length(NoCalcLength::from_px(20f32))),
Importance::Normal),
(PropertyDeclaration::Height(
LengthOrPercentageOrAuto::Length(NoCalcLength::from_px(20f32))),
Importance::Important),
(PropertyDeclaration::Display(Display::InlineBlock),
Importance::Normal),
(PropertyDeclaration::OverflowX(
OverflowValue::Auto),
Importance::Normal),
(PropertyDeclaration::OverflowY(
OverflowValue::Auto),
Importance::Normal),
(
PropertyDeclaration::Width(LengthOrPercentageOrAuto::Length(NoCalcLength::from_px(
70f32,
))),
Importance::Normal,
),
(
PropertyDeclaration::MinHeight(LengthOrPercentage::Length(NoCalcLength::from_px(
20f32,
))),
Importance::Normal,
),
(
PropertyDeclaration::Height(LengthOrPercentageOrAuto::Length(NoCalcLength::from_px(
20f32,
))),
Importance::Important,
),
(
PropertyDeclaration::Display(Display::InlineBlock),
Importance::Normal,
),
(
PropertyDeclaration::OverflowX(OverflowValue::Auto),
Importance::Normal,
),
(
PropertyDeclaration::OverflowY(OverflowValue::Auto),
Importance::Normal,
),
];
let block = block_from(declarations);
@ -147,62 +155,65 @@ mod shorthand_serialization {
#[test]
fn different_longhands_should_serialize_to_long_form() {
let mut properties = Vec::new();
let mut properties = Vec::new();
let solid = BorderStyle::Solid;
let solid = BorderStyle::Solid;
properties.push(PropertyDeclaration::BorderTopStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderRightStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderBottomStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderLeftStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderTopStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderRightStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderBottomStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderLeftStyle(solid.clone()));
let px_30 = BorderSideWidth::Length(Length::from_px(30f32));
let px_10 = BorderSideWidth::Length(Length::from_px(10f32));
let px_30 = BorderSideWidth::Length(Length::from_px(30f32));
let px_10 = BorderSideWidth::Length(Length::from_px(10f32));
properties.push(PropertyDeclaration::BorderTopWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderRightWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderBottomWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderLeftWidth(px_10.clone()));
properties.push(PropertyDeclaration::BorderTopWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderRightWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderBottomWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderLeftWidth(px_10.clone()));
let blue = Color::rgba(RGBA::new(0, 0, 255, 255));
let blue = Color::rgba(RGBA::new(0, 0, 255, 255));
properties.push(PropertyDeclaration::BorderTopColor(blue.clone()));
properties.push(PropertyDeclaration::BorderRightColor(blue.clone()));
properties.push(PropertyDeclaration::BorderBottomColor(blue.clone()));
properties.push(PropertyDeclaration::BorderLeftColor(blue.clone()));
properties.push(PropertyDeclaration::BorderTopColor(blue.clone()));
properties.push(PropertyDeclaration::BorderRightColor(blue.clone()));
properties.push(PropertyDeclaration::BorderBottomColor(blue.clone()));
properties.push(PropertyDeclaration::BorderLeftColor(blue.clone()));
let serialization = shorthand_properties_to_string(properties);
assert_eq!(serialization,
let serialization = shorthand_properties_to_string(properties);
assert_eq!(serialization,
"border-style: solid; border-width: 30px 30px 30px 10px; border-color: rgb(0, 0, 255);");
}
#[test]
fn same_longhands_should_serialize_correctly() {
let mut properties = Vec::new();
let mut properties = Vec::new();
let solid = BorderStyle::Solid;
let solid = BorderStyle::Solid;
properties.push(PropertyDeclaration::BorderTopStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderRightStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderBottomStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderLeftStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderTopStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderRightStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderBottomStyle(solid.clone()));
properties.push(PropertyDeclaration::BorderLeftStyle(solid.clone()));
let px_30 = BorderSideWidth::Length(Length::from_px(30f32));
let px_30 = BorderSideWidth::Length(Length::from_px(30f32));
properties.push(PropertyDeclaration::BorderTopWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderRightWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderBottomWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderLeftWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderTopWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderRightWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderBottomWidth(px_30.clone()));
properties.push(PropertyDeclaration::BorderLeftWidth(px_30.clone()));
let blue = Color::rgba(RGBA::new(0, 0, 255, 255));
let blue = Color::rgba(RGBA::new(0, 0, 255, 255));
properties.push(PropertyDeclaration::BorderTopColor(blue.clone()));
properties.push(PropertyDeclaration::BorderRightColor(blue.clone()));
properties.push(PropertyDeclaration::BorderBottomColor(blue.clone()));
properties.push(PropertyDeclaration::BorderLeftColor(blue.clone()));
properties.push(PropertyDeclaration::BorderTopColor(blue.clone()));
properties.push(PropertyDeclaration::BorderRightColor(blue.clone()));
properties.push(PropertyDeclaration::BorderBottomColor(blue.clone()));
properties.push(PropertyDeclaration::BorderLeftColor(blue.clone()));
let serialization = shorthand_properties_to_string(properties);
assert_eq!(serialization, "border-style: solid; border-width: 30px; border-color: rgb(0, 0, 255);");
let serialization = shorthand_properties_to_string(properties);
assert_eq!(
serialization,
"border-style: solid; border-width: 30px; border-color: rgb(0, 0, 255);"
);
}
#[test]
@ -274,7 +285,10 @@ mod shorthand_serialization {
let serialization = shorthand_properties_to_string(properties);
// TODO: Make the rgb test show border-color as blue red instead of below tuples
assert_eq!(serialization, "border-color: rgb(0, 0, 255) rgb(255, 0, 0);");
assert_eq!(
serialization,
"border-color: rgb(0, 0, 255) rgb(255, 0, 0);"
);
}
#[test]
@ -297,41 +311,42 @@ mod shorthand_serialization {
#[test]
fn border_radius_should_serialize_correctly() {
let mut properties = Vec::new();
properties.push(PropertyDeclaration::BorderTopLeftRadius(Box::new(BorderCornerRadius::new(
Percentage::new(0.01).into(), Percentage::new(0.05).into()
))));
properties.push(PropertyDeclaration::BorderTopRightRadius(Box::new(BorderCornerRadius::new(
Percentage::new(0.02).into(), Percentage::new(0.06).into()
))));
properties.push(PropertyDeclaration::BorderBottomRightRadius(Box::new(BorderCornerRadius::new(
Percentage::new(0.03).into(), Percentage::new(0.07).into()
))));
properties.push(PropertyDeclaration::BorderBottomLeftRadius(Box::new(BorderCornerRadius::new(
Percentage::new(0.04).into(), Percentage::new(0.08).into()
))));
properties.push(PropertyDeclaration::BorderTopLeftRadius(Box::new(
BorderCornerRadius::new(Percentage::new(0.01).into(), Percentage::new(0.05).into()),
)));
properties.push(PropertyDeclaration::BorderTopRightRadius(Box::new(
BorderCornerRadius::new(Percentage::new(0.02).into(), Percentage::new(0.06).into()),
)));
properties.push(PropertyDeclaration::BorderBottomRightRadius(Box::new(
BorderCornerRadius::new(Percentage::new(0.03).into(), Percentage::new(0.07).into()),
)));
properties.push(PropertyDeclaration::BorderBottomLeftRadius(Box::new(
BorderCornerRadius::new(Percentage::new(0.04).into(), Percentage::new(0.08).into()),
)));
let serialization = shorthand_properties_to_string(properties);
assert_eq!(serialization, "border-radius: 1% 2% 3% 4% / 5% 6% 7% 8%;");
}
}
mod border_shorthands {
use super::*;
#[test]
fn border_top_and_color() {
let mut properties = Vec::new();
properties.push(PropertyDeclaration::BorderTopWidth(BorderSideWidth::Length(Length::from_px(1.))));
properties.push(PropertyDeclaration::BorderTopWidth(
BorderSideWidth::Length(Length::from_px(1.)),
));
properties.push(PropertyDeclaration::BorderTopStyle(BorderStyle::Solid));
let c = Color::Numeric {
parsed: RGBA::new(255, 0, 0, 255),
authored: Some("green".to_string().into_boxed_str())
authored: Some("green".to_string().into_boxed_str()),
};
properties.push(PropertyDeclaration::BorderTopColor(c));
let c = Color::Numeric {
parsed: RGBA::new(0, 255, 0, 255),
authored: Some("red".to_string().into_boxed_str())
authored: Some("red".to_string().into_boxed_str()),
};
properties.push(PropertyDeclaration::BorderTopColor(c.clone()));
properties.push(PropertyDeclaration::BorderBottomColor(c.clone()));
@ -339,31 +354,39 @@ mod shorthand_serialization {
properties.push(PropertyDeclaration::BorderRightColor(c.clone()));
let serialization = shorthand_properties_to_string(properties);
assert_eq!(serialization, "border-top: 1px solid red; border-color: red;");
assert_eq!(
serialization,
"border-top: 1px solid red; border-color: red;"
);
}
#[test]
fn border_color_and_top() {
let mut properties = Vec::new();
let c = Color::Numeric {
let c = Color::Numeric {
parsed: RGBA::new(0, 255, 0, 255),
authored: Some("red".to_string().into_boxed_str())
authored: Some("red".to_string().into_boxed_str()),
};
properties.push(PropertyDeclaration::BorderTopColor(c.clone()));
properties.push(PropertyDeclaration::BorderBottomColor(c.clone()));
properties.push(PropertyDeclaration::BorderLeftColor(c.clone()));
properties.push(PropertyDeclaration::BorderRightColor(c.clone()));
properties.push(PropertyDeclaration::BorderTopWidth(BorderSideWidth::Length(Length::from_px(1.))));
properties.push(PropertyDeclaration::BorderTopWidth(
BorderSideWidth::Length(Length::from_px(1.)),
));
properties.push(PropertyDeclaration::BorderTopStyle(BorderStyle::Solid));
let c = Color::Numeric {
parsed: RGBA::new(255, 0, 0, 255),
authored: Some("green".to_string().into_boxed_str())
authored: Some("green".to_string().into_boxed_str()),
};
properties.push(PropertyDeclaration::BorderTopColor(c));
let serialization = shorthand_properties_to_string(properties);
assert_eq!(serialization, "border-color: green red red; border-top: 1px solid green;");
assert_eq!(
serialization,
"border-color: green red red; border-top: 1px solid green;"
);
}
// we can use border-top as a base to test out the different combinations
@ -386,9 +409,11 @@ mod shorthand_serialization {
}
fn get_border_property_values() -> (BorderSideWidth, BorderStyle, Color) {
(BorderSideWidth::Length(Length::from_px(4f32)),
BorderStyle::Solid,
Color::currentcolor())
(
BorderSideWidth::Length(Length::from_px(4f32)),
BorderStyle::Solid,
Color::currentcolor(),
)
}
#[test]
@ -445,13 +470,14 @@ mod shorthand_serialization {
// the ‘border’ shorthand resets ‘border-image’ to its initial value. To verify the
// serialization of 'border' shorthand, we need to set 'border-image' as well.
let block_text = "\
border-top: 4px solid; \
border-right: 4px solid; \
border-bottom: 4px solid; \
border-left: 4px solid; \
border-image: none;";
border-top: 4px solid; \
border-right: 4px solid; \
border-bottom: 4px solid; \
border-left: 4px solid; \
border-image: none;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
@ -483,7 +509,10 @@ mod shorthand_serialization {
properties.push(PropertyDeclaration::ListStyleType(style_type));
let serialization = shorthand_properties_to_string(properties);
assert_eq!(serialization, "list-style: inside url(\"http://servo/test.png\") disc;");
assert_eq!(
serialization,
"list-style: inside url(\"http://servo/test.png\") disc;"
);
}
}
@ -493,65 +522,68 @@ mod shorthand_serialization {
#[test]
fn background_should_serialize_all_available_properties_when_specified() {
let block_text = "\
background-color: rgb(255, 0, 0); \
background-image: url(\"http://servo/test.png\"); \
background-repeat: repeat-x; \
background-attachment: scroll; \
background-size: 70px 50px; \
background-position-x: 7px; \
background-position-y: bottom 4px; \
background-origin: border-box; \
background-clip: padding-box;";
background-color: rgb(255, 0, 0); \
background-image: url(\"http://servo/test.png\"); \
background-repeat: repeat-x; \
background-attachment: scroll; \
background-size: 70px 50px; \
background-position-x: 7px; \
background-position-y: bottom 4px; \
background-origin: border-box; \
background-clip: padding-box;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(
serialization,
"background: rgb(255, 0, 0) url(\"http://servo/test.png\") repeat-x \
scroll left 7px bottom 4px / 70px 50px border-box padding-box;"
scroll left 7px bottom 4px / 70px 50px border-box padding-box;"
);
}
#[test]
fn background_should_combine_origin_and_clip_properties_when_equal() {
let block_text = "\
background-color: rgb(255, 0, 0); \
background-image: url(\"http://servo/test.png\"); \
background-repeat: repeat-x; \
background-attachment: scroll; \
background-size: 70px 50px; \
background-position-x: 7px; \
background-position-y: 4px; \
background-origin: padding-box; \
background-clip: padding-box;";
background-color: rgb(255, 0, 0); \
background-image: url(\"http://servo/test.png\"); \
background-repeat: repeat-x; \
background-attachment: scroll; \
background-size: 70px 50px; \
background-position-x: 7px; \
background-position-y: 4px; \
background-origin: padding-box; \
background-clip: padding-box;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(
serialization,
"background: rgb(255, 0, 0) url(\"http://servo/test.png\") repeat-x \
scroll 7px 4px / 70px 50px padding-box;"
scroll 7px 4px / 70px 50px padding-box;"
);
}
#[test]
fn serialize_multiple_backgrounds() {
let block_text = "\
background-color: rgb(0, 0, 255); \
background-image: url(\"http://servo/test.png\"), none; \
background-repeat: repeat-x, repeat-y; \
background-attachment: scroll, scroll; \
background-size: 70px 50px, 20px 30px; \
background-position-x: 7px, 70px; \
background-position-y: 4px, 40px; \
background-origin: border-box, padding-box; \
background-clip: padding-box, padding-box;";
background-color: rgb(0, 0, 255); \
background-image: url(\"http://servo/test.png\"), none; \
background-repeat: repeat-x, repeat-y; \
background-attachment: scroll, scroll; \
background-size: 70px 50px, 20px 30px; \
background-position-x: 7px, 70px; \
background-position-y: 4px, 40px; \
background-origin: border-box, padding-box; \
background-clip: padding-box, padding-box;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
@ -573,16 +605,17 @@ mod shorthand_serialization {
// multiple backgrounds.
// Below background-origin only has one value.
let block_text = "\
background-color: rgb(0, 0, 255); \
background-image: url(\"http://servo/test.png\"), none; \
background-repeat: repeat-x, repeat-y; \
background-attachment: scroll, scroll; \
background-size: 70px 50px, 20px 30px; \
background-position: 7px 4px, 5px 6px; \
background-origin: border-box; \
background-clip: padding-box, padding-box;";
background-color: rgb(0, 0, 255); \
background-image: url(\"http://servo/test.png\"), none; \
background-repeat: repeat-x, repeat-y; \
background-attachment: scroll, scroll; \
background-size: 70px 50px, 20px 30px; \
background-position: 7px 4px, 5px 6px; \
background-origin: border-box; \
background-clip: padding-box, padding-box;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
@ -594,18 +627,20 @@ mod shorthand_serialization {
// If there is any longhand consisted of both keyword and position,
// the shorthand result should be the 4-value format.
let block_text = "\
background-position-x: 30px;\
background-position-y: bottom 20px;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
background-position-x: 30px;\
background-position-y: bottom 20px;";
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(serialization, "background-position: left 30px bottom 20px;");
// If there is no longhand consisted of both keyword and position,
// the shorthand result should be the 2-value format.
let block_text = "\
background-position-x: center;\
background-position-y: 20px;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
background-position-x: center;\
background-position-y: 20px;";
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(serialization, "background-position: center 20px;");
}
@ -628,41 +663,48 @@ mod shorthand_serialization {
#[test]
fn serialize_single_animation() {
let block_text = "\
animation-name: bounce;\
animation-duration: 1s;\
animation-timing-function: ease-in;\
animation-delay: 0s;\
animation-direction: normal;\
animation-fill-mode: forwards;\
animation-iteration-count: infinite;\
animation-play-state: paused;";
animation-name: bounce;\
animation-duration: 1s;\
animation-timing-function: ease-in;\
animation-delay: 0s;\
animation-direction: normal;\
animation-fill-mode: forwards;\
animation-iteration-count: infinite;\
animation-play-state: paused;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(serialization, "animation: 1s ease-in 0s infinite normal forwards paused bounce;")
assert_eq!(
serialization,
"animation: 1s ease-in 0s infinite normal forwards paused bounce;"
)
}
#[test]
fn serialize_multiple_animations() {
let block_text = "\
animation-name: bounce, roll;\
animation-duration: 1s, 0.2s;\
animation-timing-function: ease-in, linear;\
animation-delay: 0s, 1s;\
animation-direction: normal, reverse;\
animation-fill-mode: forwards, backwards;\
animation-iteration-count: infinite, 2;\
animation-play-state: paused, running;";
animation-name: bounce, roll;\
animation-duration: 1s, 0.2s;\
animation-timing-function: ease-in, linear;\
animation-delay: 0s, 1s;\
animation-direction: normal, reverse;\
animation-fill-mode: forwards, backwards;\
animation-iteration-count: infinite, 2;\
animation-play-state: paused, running;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(serialization,
"animation: 1s ease-in 0s infinite normal forwards paused bounce, \
0.2s linear 1s 2 reverse backwards running roll;");
assert_eq!(
serialization,
"animation: 1s ease-in 0s infinite normal forwards paused bounce, \
0.2s linear 1s 2 reverse backwards running roll;"
);
}
#[test]
@ -673,16 +715,17 @@ mod shorthand_serialization {
// lists have the same length (this affects background, transition and animation).
// https://github.com/servo/servo/issues/15398 )
let block_text = "\
animation-name: bounce, roll, flip, jump; \
animation-duration: 1s, 0.2s; \
animation-timing-function: ease-in, linear; \
animation-delay: 0s, 1s, 0.5s; \
animation-direction: normal; \
animation-fill-mode: forwards, backwards; \
animation-iteration-count: infinite, 2; \
animation-play-state: paused, running;";
animation-name: bounce, roll, flip, jump; \
animation-duration: 1s, 0.2s; \
animation-timing-function: ease-in, linear; \
animation-delay: 0s, 1s, 0.5s; \
animation-direction: normal; \
animation-fill-mode: forwards, backwards; \
animation-iteration-count: infinite, 2; \
animation-play-state: paused, running;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
@ -699,7 +742,8 @@ mod shorthand_serialization {
animation-iteration-count: infinite, 2; \
animation-play-state: paused, running;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
@ -712,7 +756,8 @@ mod shorthand_serialization {
#[test]
fn css_wide_keywords_should_be_parsed() {
let block_text = "--a:inherit;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(serialization, "--a: inherit;");
@ -721,7 +766,8 @@ mod shorthand_serialization {
#[test]
fn non_keyword_custom_property_should_be_unparsed() {
let block_text = "--main-color: #06c;";
let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let block =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap();
let serialization = block.to_css_string();
assert_eq!(serialization, block_text);
@ -751,7 +797,8 @@ mod shorthand_serialization {
let shadow_decl = BoxShadowList(vec![shadow_val]);
properties.push(PropertyDeclaration::BoxShadow(shadow_decl));
let shadow_css = "box-shadow: 1px 2px 3px 4px;";
let shadow = parse(|c, i| Ok(parse_property_declaration_list(c, i)), shadow_css).unwrap();
let shadow =
parse(|c, i| Ok(parse_property_declaration_list(c, i)), shadow_css).unwrap();
assert_eq!(shadow.to_css_string(), shadow_css);
}

115
tests/unit/style/rule_tree/bench.rs
View file

@ -18,11 +18,14 @@ use test::{self, Bencher};
struct ErrorringErrorReporter;
impl ParseErrorReporter for ErrorringErrorReporter {
fn report_error(&self,
url: &ServoUrl,
location: SourceLocation,
error: ContextualParseError) {
panic!("CSS error: {}\t\n{}:{} {}", url.as_str(), location.line, location.column, error);
fn report_error(&self, url: &ServoUrl, location: SourceLocation, error: ContextualParseError) {
panic!(
"CSS error: {}\t\n{}:{} {}",
url.as_str(),
location.line,
location.column,
error
);
}
}
@ -38,9 +41,10 @@ impl<'a> Drop for AutoGCRuleTree<'a> {
fn drop(&mut self) {
unsafe {
self.0.gc();
assert!(::std::thread::panicking() ||
!self.0.root().has_children_for_testing(),
"No rule nodes other than the root shall remain!");
assert!(
::std::thread::panicking() || !self.0.root().has_children_for_testing(),
"No rule nodes other than the root shall remain!"
);
}
}
}
@ -49,41 +53,51 @@ fn parse_rules(css: &str) -> Vec<(StyleSource, CascadeLevel)> {
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
let s = Stylesheet::from_str(css,
ServoUrl::parse("http://localhost").unwrap(),
Origin::Author,
media,
lock,
None,
Some(&ErrorringErrorReporter),
QuirksMode::NoQuirks,
0);
let s = Stylesheet::from_str(
css,
ServoUrl::parse("http://localhost").unwrap(),
Origin::Author,
media,
lock,
None,
Some(&ErrorringErrorReporter),
QuirksMode::NoQuirks,
0,
);
let guard = s.shared_lock.read();
let rules = s.contents.rules.read_with(&guard);
rules.0.iter().filter_map(|rule| {
match *rule {
rules
.0
.iter()
.filter_map(|rule| match *rule {
CssRule::Style(ref style_rule) => Some((
StyleSource::from_rule(style_rule.clone()),
CascadeLevel::UserNormal,
)),
_ => None,
}
}).collect()
})
.collect()
}
fn test_insertion(rule_tree: &RuleTree, rules: Vec<(StyleSource, CascadeLevel)>) -> StrongRuleNode {
rule_tree.insert_ordered_rules(rules.into_iter())
}
fn test_insertion_style_attribute(rule_tree: &RuleTree, rules: &[(StyleSource, CascadeLevel)],
shared_lock: &SharedRwLock)
-> StrongRuleNode {
fn test_insertion_style_attribute(
rule_tree: &RuleTree,
rules: &[(StyleSource, CascadeLevel)],
shared_lock: &SharedRwLock,
) -> StrongRuleNode {
let mut rules = rules.to_vec();
rules.push((StyleSource::from_declarations(Arc::new(shared_lock.wrap(PropertyDeclarationBlock::with_one(
PropertyDeclaration::Display(
longhands::display::SpecifiedValue::Block),
Importance::Normal
)))), CascadeLevel::UserNormal));
rules.push((
StyleSource::from_declarations(Arc::new(shared_lock.wrap(
PropertyDeclarationBlock::with_one(
PropertyDeclaration::Display(longhands::display::SpecifiedValue::Block),
Importance::Normal,
),
))),
CascadeLevel::UserNormal,
));
test_insertion(rule_tree, rules)
}
@ -95,7 +109,8 @@ fn bench_insertion_basic(b: &mut Bencher) {
let rules_matched = parse_rules(
".foo { width: 200px; } \
.bar { height: 500px; } \
.baz { display: block; }");
.baz { display: block; }",
);
b.iter(|| {
let _gc = AutoGCRuleTree::new(&r);
@ -114,7 +129,8 @@ fn bench_insertion_basic_per_element(b: &mut Bencher) {
let rules_matched = parse_rules(
".foo { width: 200px; } \
.bar { height: 500px; } \
.baz { display: block; }");
.baz { display: block; }",
);
b.iter(|| {
let _gc = AutoGCRuleTree::new(&r);
@ -134,14 +150,19 @@ fn bench_expensive_insertion(b: &mut Bencher) {
let rules_matched = parse_rules(
".foo { width: 200px; } \
.bar { height: 500px; } \
.baz { display: block; }");
.baz { display: block; }",
);
let shared_lock = SharedRwLock::new();
b.iter(|| {
let _gc = AutoGCRuleTree::new(&r);
for _ in 0..(4000 + 400) {
test::black_box(test_insertion_style_attribute(&r, &rules_matched, &shared_lock));
test::black_box(test_insertion_style_attribute(
&r,
&rules_matched,
&shared_lock,
));
}
});
}
@ -154,7 +175,8 @@ fn bench_insertion_basic_parallel(b: &mut Bencher) {
let rules_matched = parse_rules(
".foo { width: 200px; } \
.bar { height: 500px; } \
.baz { display: block; }");
.baz { display: block; }",
);
b.iter(|| {
let _gc = AutoGCRuleTree::new(&r);
@ -163,13 +185,11 @@ fn bench_insertion_basic_parallel(b: &mut Bencher) {
for _ in 0..4 {
s.spawn(|s| {
for _ in 0..1000 {
test::black_box(test_insertion(&r,
rules_matched.clone()));
test::black_box(test_insertion(&r, rules_matched.clone()));
}
s.spawn(|_| {
for _ in 0..100 {
test::black_box(test_insertion(&r,
rules_matched.clone()));
test::black_box(test_insertion(&r, rules_matched.clone()));
}
})
})
@ -186,7 +206,8 @@ fn bench_expensive_insertion_parallel(b: &mut Bencher) {
let rules_matched = parse_rules(
".foo { width: 200px; } \
.bar { height: 500px; } \
.baz { display: block; }");
.baz { display: block; }",
);
let shared_lock = SharedRwLock::new();
b.iter(|| {
@ -196,15 +217,19 @@ fn bench_expensive_insertion_parallel(b: &mut Bencher) {
for _ in 0..4 {
s.spawn(|s| {
for _ in 0..1000 {
test::black_box(test_insertion_style_attribute(&r,
&rules_matched,
&shared_lock));
test::black_box(test_insertion_style_attribute(
&r,
&rules_matched,
&shared_lock,
));
}
s.spawn(|_| {
for _ in 0..100 {
test::black_box(test_insertion_style_attribute(&r,
&rules_matched,
&shared_lock));
test::black_box(test_insertion_style_attribute(
&r,
&rules_matched,
&shared_lock,
));
}
})
})

42
tests/unit/style/size_of.rs
View file

@ -8,16 +8,44 @@ use style::properties;
size_of_test!(test_size_of_dependency, Dependency, 16);
size_of_test!(test_size_of_property_declaration, properties::PropertyDeclaration, 32);
size_of_test!(
test_size_of_property_declaration,
properties::PropertyDeclaration,
32
);
// This is huge, but we allocate it on the stack and then never move it,
// we only pass `&mut SourcePropertyDeclaration` references around.
size_of_test!(test_size_of_parsed_declaration, properties::SourcePropertyDeclaration, 568);
size_of_test!(
test_size_of_parsed_declaration,
properties::SourcePropertyDeclaration,
568
);
size_of_test!(test_size_of_selector_parse_error_kind, SelectorParseErrorKind, 40);
size_of_test!(test_size_of_style_parse_error_kind, ::style_traits::StyleParseErrorKind, 56);
size_of_test!(test_size_of_value_parse_error_kind, ::style_traits::ValueParseErrorKind, 40);
size_of_test!(
test_size_of_selector_parse_error_kind,
SelectorParseErrorKind,
40
);
size_of_test!(
test_size_of_style_parse_error_kind,
::style_traits::StyleParseErrorKind,
56
);
size_of_test!(
test_size_of_value_parse_error_kind,
::style_traits::ValueParseErrorKind,
40
);
size_of_test!(test_size_of_selector_parse_error, SelectorParseError, 56);
size_of_test!(test_size_of_style_traits_parse_error, ::style_traits::ParseError, 72);
size_of_test!(test_size_of_value_parse_error, ::style_traits::ValueParseError, 56);
size_of_test!(
test_size_of_style_traits_parse_error,
::style_traits::ParseError,
72
);
size_of_test!(
test_size_of_value_parse_error,
::style_traits::ValueParseError,
56
);

6
tests/unit/style/str.rs
View file

@ -7,7 +7,11 @@ use style::str::{split_html_space_chars, str_join, starts_with_ignore_ascii_case
#[test]
pub fn split_html_space_chars_whitespace() {
assert!(split_html_space_chars("").collect::<Vec<_>>().is_empty());
assert!(split_html_space_chars("\u{0020}\u{0009}\u{000a}\u{000c}\u{000d}").collect::<Vec<_>>().is_empty());
assert!(
split_html_space_chars("\u{0020}\u{0009}\u{000a}\u{000c}\u{000d}")
.collect::<Vec<_>>()
.is_empty()
);
}
#[test]

565
tests/unit/style/stylesheets.rs
View file

@ -31,7 +31,9 @@ use style::values::specified::{LengthOrPercentageOrAuto, PositionComponent};
use style::values::specified::TimingFunction;
pub fn block_from<I>(iterable: I) -> PropertyDeclarationBlock
where I: IntoIterator<Item=(PropertyDeclaration, Importance)> {
where
I: IntoIterator<Item = (PropertyDeclaration, Importance)>,
{
let mut block = PropertyDeclarationBlock::new();
for (d, i) in iterable {
block.push(d, i);
@ -69,8 +71,17 @@ fn test_parse_stylesheet() {
let url = ServoUrl::parse("about::test").unwrap();
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
let stylesheet = Stylesheet::from_str(css, url.clone(), Origin::UserAgent, media, lock,
None, None, QuirksMode::NoQuirks, 0);
let stylesheet = Stylesheet::from_str(
css,
url.clone(),
Origin::UserAgent,
media,
lock,
None,
None,
QuirksMode::NoQuirks,
0,
);
let mut namespaces = Namespaces::default();
namespaces.default = Some(ns!(html));
let expected = Stylesheet {
@ -79,180 +90,245 @@ fn test_parse_stylesheet() {
namespaces: RwLock::new(namespaces),
url_data: RwLock::new(url),
quirks_mode: QuirksMode::NoQuirks,
rules: CssRules::new(vec![
CssRule::Namespace(Arc::new(stylesheet.shared_lock.wrap(NamespaceRule {
prefix: None,
url: NsAtom::from("http://www.w3.org/1999/xhtml"),
source_location: SourceLocation {
line: 1,
column: 19,
},
}))),
CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
selectors: SelectorList::from_vec(vec!(
Selector::from_vec(vec!(
Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
Component::LocalName(LocalName {
name: local_name!("input"),
lower_name: local_name!("input"),
}),
Component::AttributeInNoNamespace {
local_name: local_name!("type"),
operator: AttrSelectorOperator::Equal,
value: "hidden".to_owned(),
case_sensitivity: ParsedCaseSensitivity::AsciiCaseInsensitive,
never_matches: false,
}
), (0 << 20) + (1 << 10) + (1 << 0))
)),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(
PropertyDeclaration::Display(longhands::display::SpecifiedValue::None),
Importance::Important,
),
(
PropertyDeclaration::Custom(CustomDeclaration {
name: Atom::from("a"),
value: CustomDeclarationValue::CSSWideKeyword(CSSWideKeyword::Inherit),
}),
Importance::Important,
),
]))),
source_location: SourceLocation {
line: 3,
column: 9,
},
}))),
CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
selectors: SelectorList::from_vec(vec!(
Selector::from_vec(vec!(
Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
rules: CssRules::new(
vec![
CssRule::Namespace(Arc::new(stylesheet.shared_lock.wrap(NamespaceRule {
prefix: None,
url: NsAtom::from("http://www.w3.org/1999/xhtml"),
source_location: SourceLocation {
line: 1,
column: 19,
},
}))),
CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
selectors: SelectorList::from_vec(vec![Selector::from_vec(
vec![
Component::DefaultNamespace(NsAtom::from(
"http://www.w3.org/1999/xhtml",
)),
Component::LocalName(LocalName {
name: local_name!("html"),
lower_name: local_name!("html"),
name: local_name!("input"),
lower_name: local_name!("input"),
}),
), (0 << 20) + (0 << 10) + (1 << 0)),
Selector::from_vec(vec!(
Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
Component::LocalName(LocalName {
name: local_name!("body"),
lower_name: local_name!("body"),
})
), (0 << 20) + (0 << 10) + (1 << 0)
),
)),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(PropertyDeclaration::Display(longhands::display::SpecifiedValue::Block),
Importance::Normal),
]))),
source_location: SourceLocation {
line: 11,
column: 9,
},
}))),
CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
selectors: SelectorList::from_vec(vec!(
Selector::from_vec(vec!(
Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
Component::ID(Atom::from("d1")),
Component::Combinator(Combinator::Child),
Component::DefaultNamespace(NsAtom::from("http://www.w3.org/1999/xhtml")),
Component::Class(Atom::from("ok"))
), (1 << 20) + (1 << 10) + (0 << 0))
)),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(PropertyDeclaration::BackgroundColor(
longhands::background_color::SpecifiedValue::Numeric {
authored: Some("blue".to_owned().into_boxed_str()),
parsed: cssparser::RGBA::new(0, 0, 255, 255),
}
),
Importance::Normal),
(PropertyDeclaration::BackgroundPositionX(
longhands::background_position_x::SpecifiedValue(
vec![PositionComponent::zero()])),
Importance::Normal),
(PropertyDeclaration::BackgroundPositionY(
longhands::background_position_y::SpecifiedValue(
vec![PositionComponent::zero()])),
Importance::Normal),
(PropertyDeclaration::BackgroundRepeat(
longhands::background_repeat::SpecifiedValue(
vec![longhands::background_repeat::single_value
::get_initial_specified_value()])),
Importance::Normal),
(PropertyDeclaration::BackgroundAttachment(
longhands::background_attachment::SpecifiedValue(
vec![longhands::background_attachment::single_value
::get_initial_specified_value()])),
Importance::Normal),
(PropertyDeclaration::BackgroundImage(
longhands::background_image::SpecifiedValue(
vec![longhands::background_image::single_value
::get_initial_specified_value()])),
Importance::Normal),
(PropertyDeclaration::BackgroundSize(
longhands::background_size::SpecifiedValue(
vec![longhands::background_size::single_value
::get_initial_specified_value()])),
Importance::Normal),
(PropertyDeclaration::BackgroundOrigin(
longhands::background_origin::SpecifiedValue(
vec![longhands::background_origin::single_value
::get_initial_specified_value()])),
Importance::Normal),
(PropertyDeclaration::BackgroundClip(
longhands::background_clip::SpecifiedValue(
vec![longhands::background_clip::single_value
::get_initial_specified_value()])),
Importance::Normal),
]))),
source_location: SourceLocation {
line: 15,
column: 9,
},
}))),
CssRule::Keyframes(Arc::new(stylesheet.shared_lock.wrap(KeyframesRule {
name: KeyframesName::Ident(CustomIdent("foo".into())),
keyframes: vec![
Arc::new(stylesheet.shared_lock.wrap(Keyframe {
selector: KeyframeSelector::new_for_unit_testing(
vec![KeyframePercentage::new(0.)]),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(PropertyDeclaration::Width(
LengthOrPercentageOrAuto::Percentage(Percentage(0.))),
Importance::Normal),
]))),
source_location: SourceLocation {
line: 17,
column: 13,
},
})),
Arc::new(stylesheet.shared_lock.wrap(Keyframe {
selector: KeyframeSelector::new_for_unit_testing(
vec![KeyframePercentage::new(1.)]),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(PropertyDeclaration::Width(
LengthOrPercentageOrAuto::Percentage(Percentage(1.))),
Importance::Normal),
(PropertyDeclaration::AnimationTimingFunction(
animation_timing_function::SpecifiedValue(
vec![TimingFunction::ease()])),
Importance::Normal),
]))),
source_location: SourceLocation {
line: 18,
column: 13,
},
})),
],
vendor_prefix: None,
source_location: SourceLocation {
line: 16,
column: 19,
},
})))
], &stylesheet.shared_lock),
Component::AttributeInNoNamespace {
local_name: local_name!("type"),
operator: AttrSelectorOperator::Equal,
value: "hidden".to_owned(),
case_sensitivity: ParsedCaseSensitivity::AsciiCaseInsensitive,
never_matches: false,
},
],
(0 << 20) + (1 << 10) + (1 << 0),
)]),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(
PropertyDeclaration::Display(
longhands::display::SpecifiedValue::None,
),
Importance::Important,
),
(
PropertyDeclaration::Custom(CustomDeclaration {
name: Atom::from("a"),
value: CustomDeclarationValue::CSSWideKeyword(
CSSWideKeyword::Inherit,
),
}),
Importance::Important,
),
]))),
source_location: SourceLocation { line: 3, column: 9 },
}))),
CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
selectors: SelectorList::from_vec(vec![
Selector::from_vec(
vec![
Component::DefaultNamespace(NsAtom::from(
"http://www.w3.org/1999/xhtml",
)),
Component::LocalName(LocalName {
name: local_name!("html"),
lower_name: local_name!("html"),
}),
],
(0 << 20) + (0 << 10) + (1 << 0),
),
Selector::from_vec(
vec![
Component::DefaultNamespace(NsAtom::from(
"http://www.w3.org/1999/xhtml",
)),
Component::LocalName(LocalName {
name: local_name!("body"),
lower_name: local_name!("body"),
}),
],
(0 << 20) + (0 << 10) + (1 << 0),
),
]),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![(
PropertyDeclaration::Display(longhands::display::SpecifiedValue::Block),
Importance::Normal,
)]))),
source_location: SourceLocation {
line: 11,
column: 9,
},
}))),
CssRule::Style(Arc::new(stylesheet.shared_lock.wrap(StyleRule {
selectors: SelectorList::from_vec(vec![Selector::from_vec(
vec![
Component::DefaultNamespace(NsAtom::from(
"http://www.w3.org/1999/xhtml",
)),
Component::ID(Atom::from("d1")),
Component::Combinator(Combinator::Child),
Component::DefaultNamespace(NsAtom::from(
"http://www.w3.org/1999/xhtml",
)),
Component::Class(Atom::from("ok")),
],
(1 << 20) + (1 << 10) + (0 << 0),
)]),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(
PropertyDeclaration::BackgroundColor(
longhands::background_color::SpecifiedValue::Numeric {
authored: Some("blue".to_owned().into_boxed_str()),
parsed: cssparser::RGBA::new(0, 0, 255, 255),
},
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundPositionX(
longhands::background_position_x::SpecifiedValue(vec![
PositionComponent::zero(),
]),
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundPositionY(
longhands::background_position_y::SpecifiedValue(vec![
PositionComponent::zero(),
]),
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundRepeat(
longhands::background_repeat::SpecifiedValue(
vec![longhands::background_repeat::single_value
::get_initial_specified_value()],
),
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundAttachment(
longhands::background_attachment::SpecifiedValue(
vec![longhands::background_attachment::single_value
::get_initial_specified_value()],
),
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundImage(
longhands::background_image::SpecifiedValue(
vec![longhands::background_image::single_value
::get_initial_specified_value()],
),
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundSize(
longhands::background_size::SpecifiedValue(
vec![longhands::background_size::single_value
::get_initial_specified_value()],
),
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundOrigin(
longhands::background_origin::SpecifiedValue(
vec![longhands::background_origin::single_value
::get_initial_specified_value()],
),
),
Importance::Normal,
),
(
PropertyDeclaration::BackgroundClip(
longhands::background_clip::SpecifiedValue(
vec![longhands::background_clip::single_value
::get_initial_specified_value()],
),
),
Importance::Normal,
),
]))),
source_location: SourceLocation {
line: 15,
column: 9,
},
}))),
CssRule::Keyframes(Arc::new(stylesheet.shared_lock.wrap(KeyframesRule {
name: KeyframesName::Ident(CustomIdent("foo".into())),
keyframes: vec![
Arc::new(stylesheet.shared_lock.wrap(Keyframe {
selector: KeyframeSelector::new_for_unit_testing(vec![
KeyframePercentage::new(0.),
]),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![(
PropertyDeclaration::Width(
LengthOrPercentageOrAuto::Percentage(Percentage(0.)),
),
Importance::Normal,
)]))),
source_location: SourceLocation {
line: 17,
column: 13,
},
})),
Arc::new(stylesheet.shared_lock.wrap(Keyframe {
selector: KeyframeSelector::new_for_unit_testing(vec![
KeyframePercentage::new(1.),
]),
block: Arc::new(stylesheet.shared_lock.wrap(block_from(vec![
(
PropertyDeclaration::Width(
LengthOrPercentageOrAuto::Percentage(Percentage(1.)),
),
Importance::Normal,
),
(
PropertyDeclaration::AnimationTimingFunction(
animation_timing_function::SpecifiedValue(vec![
TimingFunction::ease(),
]),
),
Importance::Normal,
),
]))),
source_location: SourceLocation {
line: 18,
column: 13,
},
})),
],
vendor_prefix: None,
source_location: SourceLocation {
line: 16,
column: 19,
},
}))),
],
&stylesheet.shared_lock,
),
source_map_url: RwLock::new(None),
source_url: RwLock::new(None),
},
@ -266,10 +342,10 @@ fn test_parse_stylesheet() {
#[derive(Debug)]
struct CSSError {
pub url : ServoUrl,
pub url: ServoUrl,
pub line: u32,
pub column: u32,
pub message: String
pub message: String,
}
struct TestingErrorReporter {
@ -285,11 +361,21 @@ impl TestingErrorReporter {
fn assert_messages_contain(&self, expected_errors: &[(u32, u32, &str)]) {
let errors = self.errors.borrow();
for (i, (error, &(line, column, message))) in errors.iter().zip(expected_errors).enumerate() {
assert_eq!((error.line, error.column), (line, column),
"line/column numbers of the {}th error: {:?}", i + 1, error.message);
assert!(error.message.contains(message),
"{:?} does not contain {:?}", error.message, message);
for (i, (error, &(line, column, message))) in errors.iter().zip(expected_errors).enumerate()
{
assert_eq!(
(error.line, error.column),
(line, column),
"line/column numbers of the {}th error: {:?}",
i + 1,
error.message
);
assert!(
error.message.contains(message),
"{:?} does not contain {:?}",
error.message,
message
);
}
if errors.len() < expected_errors.len() {
panic!("Missing errors: {:#?}", &expected_errors[errors.len()..]);
@ -301,22 +387,16 @@ impl TestingErrorReporter {
}
impl ParseErrorReporter for TestingErrorReporter {
fn report_error(&self,
url: &ServoUrl,
location: SourceLocation,
error: ContextualParseError) {
self.errors.borrow_mut().push(
CSSError{
url: url.clone(),
line: location.line,
column: location.column,
message: error.to_string(),
}
)
fn report_error(&self, url: &ServoUrl, location: SourceLocation, error: ContextualParseError) {
self.errors.borrow_mut().push(CSSError {
url: url.clone(),
line: location.line,
column: location.column,
message: error.to_string(),
})
}
}
#[test]
fn test_report_error_stylesheet() {
PREFS.set("layout.viewport.enabled", PrefValue::Boolean(true));
@ -342,29 +422,50 @@ fn test_report_error_stylesheet() {
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
Stylesheet::from_str(css, url.clone(), Origin::UserAgent, media, lock,
None, Some(&error_reporter), QuirksMode::NoQuirks, 5);
Stylesheet::from_str(
css,
url.clone(),
Origin::UserAgent,
media,
lock,
None,
Some(&error_reporter),
QuirksMode::NoQuirks,
5,
);
error_reporter.assert_messages_contain(&[
(8, 18, "Unsupported property declaration: 'display: invalid;'"),
(9, 27, "Unsupported property declaration: 'background-image:"), // FIXME: column should be around 56
(
8,
18,
"Unsupported property declaration: 'display: invalid;'",
),
(
9,
27,
"Unsupported property declaration: 'background-image:",
), // FIXME: column should be around 56
(10, 17, "Unsupported property declaration: 'invalid: true;'"),
(12, 28, "Invalid media rule"),
(13, 30, "Unsupported @font-face descriptor declaration"),
// When @counter-style is supported, this should be replaced with two errors
(14, 19, "Invalid rule: '@counter-style "),
// When @font-feature-values is supported, this should be replaced with two errors
(15, 25, "Invalid rule: '@font-feature-values "),
(16, 13, "Invalid rule: '@invalid'"),
(17, 29, "Invalid rule: '@invalid'"),
(18, 34, "Invalid rule: '@supports "),
(19, 26, "Invalid keyframe rule: 'from invalid '"),
(19, 52, "Unsupported keyframe property declaration: 'margin: 0 invalid 0;'"),
(20, 29, "Unsupported @viewport descriptor declaration: 'width: 320px invalid auto;'"),
(
19,
52,
"Unsupported keyframe property declaration: 'margin: 0 invalid 0;'",
),
(
20,
29,
"Unsupported @viewport descriptor declaration: 'width: 320px invalid auto;'",
),
]);
assert_eq!(error_reporter.errors.borrow()[0].url, url);
@ -384,28 +485,50 @@ fn test_no_report_unrecognized_vendor_properties() {
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
Stylesheet::from_str(css, url, Origin::UserAgent, media, lock,
None, Some(&error_reporter), QuirksMode::NoQuirks, 0);
Stylesheet::from_str(
css,
url,
Origin::UserAgent,
media,
lock,
None,
Some(&error_reporter),
QuirksMode::NoQuirks,
0,
);
error_reporter.assert_messages_contain(&[
(4, 31, "Unsupported property declaration: '-moz-background-color: red;'"),
]);
error_reporter.assert_messages_contain(&[(
4,
31,
"Unsupported property declaration: '-moz-background-color: red;'",
)]);
}
#[test]
fn test_source_map_url() {
let tests = vec![
("", None),
("/*# sourceMappingURL=something */", Some("something".to_string())),
(
"/*# sourceMappingURL=something */",
Some("something".to_string()),
),
];
for test in tests {
let url = ServoUrl::parse("about::test").unwrap();
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
let stylesheet = Stylesheet::from_str(test.0, url.clone(), Origin::UserAgent, media, lock,
None, None, QuirksMode::NoQuirks,
0);
let stylesheet = Stylesheet::from_str(
test.0,
url.clone(),
Origin::UserAgent,
media,
lock,
None,
None,
QuirksMode::NoQuirks,
0,
);
let url_opt = stylesheet.contents.source_map_url.read();
assert_eq!(*url_opt, test.1);
}
@ -422,9 +545,17 @@ fn test_source_url() {
let url = ServoUrl::parse("about::test").unwrap();
let lock = SharedRwLock::new();
let media = Arc::new(lock.wrap(MediaList::empty()));
let stylesheet = Stylesheet::from_str(test.0, url.clone(), Origin::UserAgent, media, lock,
None, None, QuirksMode::NoQuirks,
0);
let stylesheet = Stylesheet::from_str(
test.0,
url.clone(),
Origin::UserAgent,
media,
lock,
None,
None,
QuirksMode::NoQuirks,
0,
);
let url_opt = stylesheet.contents.source_url.read();
assert_eq!(*url_opt, test.1);
}

141
tests/unit/style/stylist.rs
View file

@ -24,37 +24,55 @@ use style::thread_state::{self, ThreadState};
/// Each sublist of the result contains the Rules for one StyleRule.
fn get_mock_rules(css_selectors: &[&str]) -> (Vec<Vec<Rule>>, SharedRwLock) {
let shared_lock = SharedRwLock::new();
(css_selectors.iter().enumerate().map(|(i, selectors)| {
let selectors = SelectorParser::parse_author_origin_no_namespace(selectors).unwrap();
(
css_selectors
.iter()
.enumerate()
.map(|(i, selectors)| {
let selectors =
SelectorParser::parse_author_origin_no_namespace(selectors).unwrap();
let locked = Arc::new(shared_lock.wrap(StyleRule {
selectors: selectors,
block: Arc::new(shared_lock.wrap(PropertyDeclarationBlock::with_one(
PropertyDeclaration::Display(
longhands::display::SpecifiedValue::Block),
Importance::Normal
))),
source_location: SourceLocation {
line: 0,
column: 0,
},
}));
let locked = Arc::new(shared_lock.wrap(StyleRule {
selectors: selectors,
block: Arc::new(shared_lock.wrap(PropertyDeclarationBlock::with_one(
PropertyDeclaration::Display(longhands::display::SpecifiedValue::Block),
Importance::Normal,
))),
source_location: SourceLocation { line: 0, column: 0 },
}));
let guard = shared_lock.read();
let rule = locked.read_with(&guard);
rule.selectors.0.iter().map(|s| {
Rule::new(s.clone(), AncestorHashes::new(s, QuirksMode::NoQuirks), locked.clone(), i as u32)
}).collect()
}).collect(), shared_lock)
let guard = shared_lock.read();
let rule = locked.read_with(&guard);
rule.selectors
.0
.iter()
.map(|s| {
Rule::new(
s.clone(),
AncestorHashes::new(s, QuirksMode::NoQuirks),
locked.clone(),
i as u32,
)
})
.collect()
})
.collect(),
shared_lock,
)
}
fn parse_selectors(selectors: &[&str]) -> Vec<Selector<SelectorImpl>> {
selectors.iter()
.map(|x| SelectorParser::parse_author_origin_no_namespace(x).unwrap().0
.into_iter()
.nth(0)
.unwrap())
.collect()
selectors
.iter()
.map(|x| {
SelectorParser::parse_author_origin_no_namespace(x)
.unwrap()
.0
.into_iter()
.nth(0)
.unwrap()
})
.collect()
}
#[test]
@ -65,14 +83,13 @@ fn test_revalidation_selectors() {
"div:not(.foo)",
"div span",
"div > span",
// ID selectors.
"#foo1",
"#foo2::before",
"#foo3 > span",
"#foo1 > span", // FIXME(bz): This one should not be a
// revalidation selector, since #foo1 should be in the
// rule hash.
// revalidation selector, since #foo1 should be in the
// rule hash.
// Attribute selectors.
"div[foo]",
@ -84,7 +101,6 @@ fn test_revalidation_selectors() {
"div[foo $= \"bar\"]",
"div[foo *= \"bar\"]",
"*|div[foo][bar = \"baz\"]",
// Non-state-based pseudo-classes.
"div:empty",
"div:first-child",
@ -97,7 +113,6 @@ fn test_revalidation_selectors() {
"div:first-of-type",
"div:last-of-type",
"div:only-of-type",
// Note: it would be nice to test :moz-any and the various other non-TS
// pseudo classes supported by gecko, but we don't have access to those
// in these unit tests. :-(
@ -105,18 +120,17 @@ fn test_revalidation_selectors() {
// Sibling combinators.
"span + div",
"span ~ div",
// Selectors in the ancestor chain (needed for cousin sharing).
"p:first-child span",
]).into_iter()
.filter(|s| needs_revalidation_for_testing(&s))
.collect::<Vec<_>>();
])
.into_iter()
.filter(|s| needs_revalidation_for_testing(&s))
.collect::<Vec<_>>();
let reference = parse_selectors(&[
// ID selectors.
"#foo3 > span",
"#foo1 > span",
// Attribute selectors.
"div[foo]",
"div:not([foo])",
@ -127,7 +141,6 @@ fn test_revalidation_selectors() {
"div[foo $= \"bar\"]",
"div[foo *= \"bar\"]",
"*|div[foo][bar = \"baz\"]",
// Non-state-based pseudo-classes.
"div:empty",
"div:first-child",
@ -140,15 +153,14 @@ fn test_revalidation_selectors() {
"div:first-of-type",
"div:last-of-type",
"div:only-of-type",
// Sibling combinators.
"span + div",
"span ~ div",
// Selectors in the ancestor chain (needed for cousin sharing).
"p:first-child span",
]).into_iter()
.collect::<Vec<_>>();
])
.into_iter()
.collect::<Vec<_>>();
assert_eq!(test.len(), reference.len());
for (t, r) in test.into_iter().zip(reference.into_iter()) {
@ -161,25 +173,52 @@ fn test_rule_ordering_same_specificity() {
let (rules_list, _) = get_mock_rules(&["a.intro", "img.sidebar"]);
let a = &rules_list[0][0];
let b = &rules_list[1][0];
assert!((a.specificity(), a.source_order) < ((b.specificity(), b.source_order)),
"The rule that comes later should win.");
assert!(
(a.specificity(), a.source_order) < ((b.specificity(), b.source_order)),
"The rule that comes later should win."
);
}
#[test]
fn test_insert() {
let (rules_list, _) = get_mock_rules(&[".intro.foo", "#top"]);
let mut selector_map = SelectorMap::new();
selector_map.insert(rules_list[1][0].clone(), QuirksMode::NoQuirks)
.expect("OOM");
assert_eq!(1, selector_map.id_hash.get(&Atom::from("top"), QuirksMode::NoQuirks).unwrap()[0].source_order);
selector_map.insert(rules_list[0][0].clone(), QuirksMode::NoQuirks)
.expect("OOM");
assert_eq!(0, selector_map.class_hash.get(&Atom::from("foo"), QuirksMode::NoQuirks).unwrap()[0].source_order);
assert!(selector_map.class_hash.get(&Atom::from("intro"), QuirksMode::NoQuirks).is_none());
selector_map
.insert(rules_list[1][0].clone(), QuirksMode::NoQuirks)
.expect("OOM");
assert_eq!(
1,
selector_map
.id_hash
.get(&Atom::from("top"), QuirksMode::NoQuirks)
.unwrap()[0]
.source_order
);
selector_map
.insert(rules_list[0][0].clone(), QuirksMode::NoQuirks)
.expect("OOM");
assert_eq!(
0,
selector_map
.class_hash
.get(&Atom::from("foo"), QuirksMode::NoQuirks)
.unwrap()[0]
.source_order
);
assert!(
selector_map
.class_hash
.get(&Atom::from("intro"), QuirksMode::NoQuirks)
.is_none()
);
}
fn mock_stylist() -> Stylist {
let device = Device::new(MediaType::screen(), TypedSize2D::new(0f32, 0f32), TypedScale::new(1.0));
let device = Device::new(
MediaType::screen(),
TypedSize2D::new(0f32, 0f32),
TypedScale::new(1.0),
);
Stylist::new(device, QuirksMode::NoQuirks)
}

576
tests/unit/style/viewport.rs
View file

@ -34,15 +34,14 @@ macro_rules! stylesheet {
None,
None,
QuirksMode::NoQuirks,
0
0,
))
}
};
}
fn test_viewport_rule<F>(css: &str,
device: &Device,
callback: F)
where F: Fn(&Vec<ViewportDescriptorDeclaration>, &str)
fn test_viewport_rule<F>(css: &str, device: &Device, callback: F)
where
F: Fn(&Vec<ViewportDescriptorDeclaration>, &str),
{
PREFS.set("layout.viewport.enabled", PrefValue::Boolean(true));
let stylesheet = stylesheet!(css, Author);
@ -55,7 +54,8 @@ fn test_viewport_rule<F>(css: &str,
}
fn test_meta_viewport<F>(meta: &str, callback: F)
where F: Fn(&Vec<ViewportDescriptorDeclaration>, &str)
where
F: Fn(&Vec<ViewportDescriptorDeclaration>, &str),
{
if let Some(mut rule) = ViewportRule::from_meta(meta) {
// from_meta uses a hash-map to collect the declarations, so we need to
@ -74,29 +74,46 @@ fn test_meta_viewport<F>(meta: &str, callback: F)
macro_rules! assert_decl_len {
($declarations:ident == 1) => {
assert_eq!($declarations.len(), 1,
"expected 1 declaration; have {}: {:?})",
$declarations.len(), $declarations)
assert_eq!(
$declarations.len(),
1,
"expected 1 declaration; have {}: {:?})",
$declarations.len(),
$declarations
)
};
($declarations:ident == $len:expr) => {
assert_eq!($declarations.len(), $len,
"expected {} declarations; have {}: {:?})",
$len, $declarations.len(), $declarations)
}
assert_eq!(
$declarations.len(),
$len,
"expected {} declarations; have {}: {:?})",
$len,
$declarations.len(),
$declarations
)
};
}
macro_rules! viewport_length {
($value:expr, px) => {
ViewportLength::Specified(LengthOrPercentageOrAuto::Length(NoCalcLength::from_px($value)))
ViewportLength::Specified(LengthOrPercentageOrAuto::Length(NoCalcLength::from_px(
$value,
)))
};
($value:expr, vw) => {
ViewportLength::Specified(LengthOrPercentageOrAuto::Length(ViewportPercentage(Vw($value))))
}
ViewportLength::Specified(LengthOrPercentageOrAuto::Length(ViewportPercentage(Vw(
$value,
))))
};
}
#[test]
fn empty_viewport_rule() {
let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), TypedScale::new(1.0));
let device = Device::new(
MediaType::screen(),
TypedSize2D::new(800., 600.),
TypedScale::new(1.0),
);
test_viewport_rule("@viewport {}", &device, |declarations, css| {
println!("{}", css);
@ -119,35 +136,77 @@ macro_rules! assert_decl_eq {
#[test]
fn simple_viewport_rules() {
let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), TypedScale::new(1.0));
let device = Device::new(
MediaType::screen(),
TypedSize2D::new(800., 600.),
TypedScale::new(1.0),
);
test_viewport_rule("@viewport { width: auto; height: auto;\
zoom: auto; min-zoom: 0; max-zoom: 200%;\
user-zoom: zoom; orientation: auto; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 9);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[2], Author, MinHeight: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[3], Author, MaxHeight: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[4], Author, Zoom: Zoom::Auto);
assert_decl_eq!(&declarations[5], Author, MinZoom: Zoom::Number(0.));
assert_decl_eq!(&declarations[6], Author, MaxZoom: Zoom::Percentage(2.));
assert_decl_eq!(&declarations[7], Author, UserZoom: UserZoom::Zoom);
assert_decl_eq!(&declarations[8], Author, Orientation: Orientation::Auto);
});
test_viewport_rule(
"@viewport { width: auto; height: auto;\
zoom: auto; min-zoom: 0; max-zoom: 200%;\
user-zoom: zoom; orientation: auto; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 9);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[2],
Author,
MinHeight: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[3],
Author,
MaxHeight: ViewportLength::Specified(Auto)
);
assert_decl_eq!(&declarations[4], Author, Zoom: Zoom::Auto);
assert_decl_eq!(&declarations[5], Author, MinZoom: Zoom::Number(0.));
assert_decl_eq!(&declarations[6], Author, MaxZoom: Zoom::Percentage(2.));
assert_decl_eq!(&declarations[7], Author, UserZoom: UserZoom::Zoom);
assert_decl_eq!(&declarations[8], Author, Orientation: Orientation::Auto);
},
);
test_viewport_rule("@viewport { min-width: 200px; max-width: auto;\
min-height: 200px; max-height: auto; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 4);
assert_decl_eq!(&declarations[0], Author, MinWidth: viewport_length!(200., px));
assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[2], Author, MinHeight: viewport_length!(200., px));
assert_decl_eq!(&declarations[3], Author, MaxHeight: ViewportLength::Specified(Auto));
});
test_viewport_rule(
"@viewport { min-width: 200px; max-width: auto;\
min-height: 200px; max-height: auto; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 4);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: viewport_length!(200., px)
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[2],
Author,
MinHeight: viewport_length!(200., px)
);
assert_decl_eq!(
&declarations[3],
Author,
MaxHeight: ViewportLength::Specified(Auto)
);
},
);
}
#[test]
@ -155,129 +214,278 @@ fn simple_meta_viewport_contents() {
test_meta_viewport("width=500, height=600", |declarations, meta| {
println!("{}", meta);
assert_decl_len!(declarations == 4);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::ExtendToZoom);
assert_decl_eq!(&declarations[1], Author, MaxWidth: viewport_length!(500., px));
assert_decl_eq!(&declarations[2], Author, MinHeight: ViewportLength::ExtendToZoom);
assert_decl_eq!(&declarations[3], Author, MaxHeight: viewport_length!(600., px));
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::ExtendToZoom
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: viewport_length!(500., px)
);
assert_decl_eq!(
&declarations[2],
Author,
MinHeight: ViewportLength::ExtendToZoom
);
assert_decl_eq!(
&declarations[3],
Author,
MaxHeight: viewport_length!(600., px)
);
});
test_meta_viewport("initial-scale=1.0", |declarations, meta| {
println!("{}", meta);
assert_decl_len!(declarations == 3);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::ExtendToZoom);
assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::ExtendToZoom);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::ExtendToZoom
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: ViewportLength::ExtendToZoom
);
assert_decl_eq!(&declarations[2], Author, Zoom: Zoom::Number(1.));
});
test_meta_viewport("initial-scale=2.0, height=device-width", |declarations, meta| {
println!("{}", meta);
assert_decl_len!(declarations == 5);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[2], Author, MinHeight: ViewportLength::ExtendToZoom);
assert_decl_eq!(&declarations[3], Author, MaxHeight: viewport_length!(100., vw));
assert_decl_eq!(&declarations[4], Author, Zoom: Zoom::Number(2.));
});
test_meta_viewport(
"initial-scale=2.0, height=device-width",
|declarations, meta| {
println!("{}", meta);
assert_decl_len!(declarations == 5);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[2],
Author,
MinHeight: ViewportLength::ExtendToZoom
);
assert_decl_eq!(
&declarations[3],
Author,
MaxHeight: viewport_length!(100., vw)
);
assert_decl_eq!(&declarations[4], Author, Zoom: Zoom::Number(2.));
},
);
test_meta_viewport("width=480, initial-scale=2.0, user-scalable=1", |declarations, meta| {
println!("{}", meta);
assert_decl_len!(declarations == 4);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::ExtendToZoom);
assert_decl_eq!(&declarations[1], Author, MaxWidth: viewport_length!(480., px));
assert_decl_eq!(&declarations[2], Author, Zoom: Zoom::Number(2.));
assert_decl_eq!(&declarations[3], Author, UserZoom: UserZoom::Zoom);
});
test_meta_viewport(
"width=480, initial-scale=2.0, user-scalable=1",
|declarations, meta| {
println!("{}", meta);
assert_decl_len!(declarations == 4);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::ExtendToZoom
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: viewport_length!(480., px)
);
assert_decl_eq!(&declarations[2], Author, Zoom: Zoom::Number(2.));
assert_decl_eq!(&declarations[3], Author, UserZoom: UserZoom::Zoom);
},
);
}
#[test]
fn cascading_within_viewport_rule() {
let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), TypedScale::new(1.0));
let device = Device::new(
MediaType::screen(),
TypedSize2D::new(800., 600.),
TypedScale::new(1.0),
);
// normal order of appearance
test_viewport_rule("@viewport { min-width: 200px; min-width: auto; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 1);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto));
});
test_viewport_rule(
"@viewport { min-width: 200px; min-width: auto; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 1);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto)
);
},
);
// !important order of appearance
test_viewport_rule("@viewport { min-width: 200px !important; min-width: auto !important; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 1);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto), !important);
});
test_viewport_rule(
"@viewport { min-width: 200px !important; min-width: auto !important; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 1);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto),
!important
);
},
);
// !important vs normal
test_viewport_rule("@viewport { min-width: auto !important; min-width: 200px; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 1);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto), !important);
});
test_viewport_rule(
"@viewport { min-width: auto !important; min-width: 200px; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 1);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto),
!important
);
},
);
// normal longhands vs normal shorthand
test_viewport_rule("@viewport { min-width: 200px; max-width: 200px; width: auto; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::Specified(Auto));
});
test_viewport_rule(
"@viewport { min-width: 200px; max-width: 200px; width: auto; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: ViewportLength::Specified(Auto)
);
},
);
// normal shorthand vs normal longhands
test_viewport_rule("@viewport { width: 200px; min-width: auto; max-width: auto; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto));
assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::Specified(Auto));
});
test_viewport_rule(
"@viewport { width: 200px; min-width: auto; max-width: auto; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto)
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: ViewportLength::Specified(Auto)
);
},
);
// one !important longhand vs normal shorthand
test_viewport_rule("@viewport { min-width: auto !important; width: 200px; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto), !important);
assert_decl_eq!(&declarations[1], Author, MaxWidth: viewport_length!(200., px));
});
test_viewport_rule(
"@viewport { min-width: auto !important; width: 200px; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto),
!important
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: viewport_length!(200., px)
);
},
);
// both !important longhands vs normal shorthand
test_viewport_rule("@viewport { min-width: auto !important; max-width: auto !important; width: 200px; }",
&device, |declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(&declarations[0], Author, MinWidth: ViewportLength::Specified(Auto), !important);
assert_decl_eq!(&declarations[1], Author, MaxWidth: ViewportLength::Specified(Auto), !important);
});
test_viewport_rule(
"@viewport { min-width: auto !important; max-width: auto !important; width: 200px; }",
&device,
|declarations, css| {
println!("{}", css);
assert_decl_len!(declarations == 2);
assert_decl_eq!(
&declarations[0],
Author,
MinWidth: ViewportLength::Specified(Auto),
!important
);
assert_decl_eq!(
&declarations[1],
Author,
MaxWidth: ViewportLength::Specified(Auto),
!important
);
},
);
}
#[test]
fn multiple_stylesheets_cascading() {
PREFS.set("layout.viewport.enabled", PrefValue::Boolean(true));
let device = Device::new(MediaType::screen(), TypedSize2D::new(800., 600.), TypedScale::new(1.0));
let device = Device::new(
MediaType::screen(),
TypedSize2D::new(800., 600.),
TypedScale::new(1.0),
);
let shared_lock = SharedRwLock::new();
let stylesheets = vec![
stylesheet!("@viewport { min-width: 100px; min-height: 100px; zoom: 1; }",
UserAgent,
shared_lock.clone()),
stylesheet!("@viewport { min-width: 200px; min-height: 200px; }",
User, shared_lock.clone()),
stylesheet!("@viewport { min-width: 300px; }",
Author, shared_lock.clone())
stylesheet!(
"@viewport { min-width: 100px; min-height: 100px; zoom: 1; }",
UserAgent,
shared_lock.clone()
),
stylesheet!(
"@viewport { min-width: 200px; min-height: 200px; }",
User,
shared_lock.clone()
),
stylesheet!(
"@viewport { min-width: 300px; }",
Author,
shared_lock.clone()
),
];
let declarations = Cascade::from_stylesheets(
stylesheets.iter().map(|s| (&**s, Origin::Author)),
&StylesheetGuards::same(&shared_lock.read()),
&device,
).finish();
)
.finish();
assert_decl_len!(declarations == 3);
assert_decl_eq!(&declarations[0], UserAgent, Zoom: Zoom::Number(1.));
assert_decl_eq!(&declarations[1], User, MinHeight: viewport_length!(200., px));
assert_decl_eq!(&declarations[2], Author, MinWidth: viewport_length!(300., px));
assert_decl_eq!(
&declarations[1],
User,
MinHeight: viewport_length!(200., px)
);
assert_decl_eq!(
&declarations[2],
Author,
MinWidth: viewport_length!(300., px)
);
let stylesheets = vec![
stylesheet!("@viewport { min-width: 100px !important; }",
@ -291,10 +499,21 @@ fn multiple_stylesheets_cascading() {
stylesheets.iter().map(|s| (&**s, Origin::Author)),
&StylesheetGuards::same(&shared_lock.read()),
&device,
).finish();
)
.finish();
assert_decl_len!(declarations == 3);
assert_decl_eq!(&declarations[0], UserAgent, MinWidth: viewport_length!(100., px), !important);
assert_decl_eq!(&declarations[1], User, MinHeight: viewport_length!(200., px), !important);
assert_decl_eq!(
&declarations[0],
UserAgent,
MinWidth: viewport_length!(100., px),
!important
);
assert_decl_eq!(
&declarations[1],
User,
MinHeight: viewport_length!(200., px),
!important
);
assert_decl_eq!(&declarations[2], Author, Zoom: Zoom::Number(3.), !important);
}
@ -314,70 +533,81 @@ fn constrain_viewport() {
macro_rules! from_css {
($css:expr) => {
&ViewportRule::parse(&context, &mut Parser::new(&mut $css)).unwrap()
}
};
}
let initial_viewport = TypedSize2D::new(800., 600.);
let device = Device::new(MediaType::screen(), initial_viewport, TypedScale::new(1.0));
let mut input = ParserInput::new("");
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks), None);
assert_eq!(
ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
None
);
let mut input = ParserInput::new("width: 320px auto");
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
assert_eq!(
ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
}));
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
})
);
let mut input = ParserInput::new("width: 320px auto");
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
assert_eq!(
ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
}));
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
})
);
let mut input = ParserInput::new("width: 800px; height: 600px;\
zoom: 1;\
user-zoom: zoom;\
orientation: auto;");
assert_eq!(ViewportConstraints::maybe_new(&device,
from_css!(input),
QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
let mut input = ParserInput::new(
"width: 800px; height: 600px;\
zoom: 1;\
user-zoom: zoom;\
orientation: auto;",
);
assert_eq!(
ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: initial_viewport,
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
}));
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
})
);
let initial_viewport = TypedSize2D::new(200., 150.);
let device = Device::new(MediaType::screen(), initial_viewport, TypedScale::new(1.0));
let mut input = ParserInput::new("width: 320px auto");
assert_eq!(ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: TypedSize2D::new(320., 240.),
assert_eq!(
ViewportConstraints::maybe_new(&device, from_css!(input), QuirksMode::NoQuirks),
Some(ViewportConstraints {
size: TypedSize2D::new(320., 240.),
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
initial_zoom: PinchZoomFactor::new(1.),
min_zoom: None,
max_zoom: None,
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
}));
user_zoom: UserZoom::Zoom,
orientation: Orientation::Auto
})
);
}