diff options
Diffstat (limited to 'servo/tests/unit')
35 files changed, 4154 insertions, 0 deletions
diff --git a/servo/tests/unit/malloc_size_of/Cargo.toml b/servo/tests/unit/malloc_size_of/Cargo.toml new file mode 100644 index 0000000000..80668d5ba6 --- /dev/null +++ b/servo/tests/unit/malloc_size_of/Cargo.toml @@ -0,0 +1,13 @@ +[package] +name = "malloc_size_of_tests" +version = "0.0.1" +authors = ["The Servo Project Developers"] +license = "MPL-2.0" + +[lib] +path = "lib.rs" +test = false + +[dependencies] +malloc_size_of = {path = "../../../components/malloc_size_of"} +servo_arc = {path = "../../../components/servo_arc"} diff --git a/servo/tests/unit/malloc_size_of/lib.rs b/servo/tests/unit/malloc_size_of/lib.rs new file mode 100644 index 0000000000..75ad4d9413 --- /dev/null +++ b/servo/tests/unit/malloc_size_of/lib.rs @@ -0,0 +1,109 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +/** +``` +extern crate malloc_size_of; +extern crate servo_arc; + +fn sizeable<T: malloc_size_of::MallocSizeOf>() {} +fn shallow_sizeable<T: malloc_size_of::MallocShallowSizeOf>() {} +fn cloneable<T: Clone>() {} + +fn main() { + cloneable::<servo_arc::Arc<i32>>(); + cloneable::<std::sync::Arc<i32>>(); + cloneable::<std::rc::Rc<i32>>(); +} +``` +*/ +pub fn imports_ok() {} + +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>>(); + } + ``` + */ + 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>>(); + } + ``` + */ + 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>>(); + } + ``` + */ + pub fn rc() {} +} + +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>>(); + } + ``` + */ + 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>>(); + } + ``` + */ + 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>>(); + } + ``` + */ + pub fn rc() {} +} diff --git a/servo/tests/unit/style/Cargo.toml b/servo/tests/unit/style/Cargo.toml new file mode 100644 index 0000000000..55289f3659 --- /dev/null +++ b/servo/tests/unit/style/Cargo.toml @@ -0,0 +1,30 @@ +[package] +name = "style_tests" +version = "0.0.1" +authors = ["The Servo Project Developers"] +license = "MPL-2.0" + +[lib] +name = "style_tests" +path = "lib.rs" +doctest = false + +[dependencies] +byteorder = "1.0" +app_units = "0.7" +cssparser = "0.31" +euclid = "0.22" +html5ever = "0.22" +parking_lot = "0.10" +rayon = "1" +serde_json = "1.0" +selectors = {path = "../../../components/selectors"} +servo_arc = {path = "../../../components/servo_arc"} +servo_atoms = {path = "../../../components/atoms"} +servo_config = {path = "../../../components/config"} +servo_url = {path = "../../../components/url"} +size_of_test = {path = "../../../components/size_of_test"} +style = {path = "../../../components/style"} +style_traits = {path = "../../../components/style_traits"} +std_test_override = { path = "../../../components/std_test_override" } +to_shmem = { path = "../../../components/to_shmem" } diff --git a/servo/tests/unit/style/animated_properties.rs b/servo/tests/unit/style/animated_properties.rs new file mode 100644 index 0000000000..fe0b03af87 --- /dev/null +++ b/servo/tests/unit/style/animated_properties.rs @@ -0,0 +1,169 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::RGBA; +use style::values::animated::{Animate, Procedure, ToAnimatedValue}; +use style::values::computed::Percentage; +use style::values::generics::transform::{Transform, TransformOperation}; + +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(), + ) +} + +// Color +#[test] +fn test_rgba_color_interepolation_preserves_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)); +} + +#[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)); +} + +#[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)); +} + +#[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)); +} + +#[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)); +} + +// Transform +#[test] +fn test_transform_interpolation_on_translate() { + use style::values::computed::{CalcLengthPercentage, Length, LengthPercentage}; + + let from = Transform(vec![ + TransformOperation::Translate3D(LengthPercentage::Length(Length::new(0.)), + LengthPercentage::Length(Length::new(100.)), + Length::new(25.))]); + let to = Transform(vec![ + TransformOperation::Translate3D(LengthPercentage::Length(Length::new(100.)), + LengthPercentage::Length(Length::new(0.)), + Length::new(75.))]); + assert_eq!( + from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(), + Transform(vec![TransformOperation::Translate3D( + LengthPercentage::Length(Length::new(50.)), + LengthPercentage::Length(Length::new(50.)), + Length::new(50.), + )]) + ); + + let from = Transform(vec![TransformOperation::Translate3D( + LengthPercentage::Percentage(Percentage(0.5)), + LengthPercentage::Percentage(Percentage(1.0)), + Length::new(25.), + )]); + let to = Transform(vec![ + TransformOperation::Translate3D(LengthPercentage::Length(Length::new(100.)), + LengthPercentage::Length(Length::new(50.)), + Length::new(75.))]); + assert_eq!( + from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(), + Transform(vec![TransformOperation::Translate3D( + // calc(50px + 25%) + LengthPercentage::Calc(CalcLengthPercentage::new(Length::new(50.), + Some(Percentage(0.25)))), + // calc(25px + 50%) + LengthPercentage::Calc(CalcLengthPercentage::new(Length::new(25.), + Some(Percentage(0.5)))), + Length::new(50.), + )]) + ); +} + +#[test] +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(), + Transform(vec![TransformOperation::Scale3D(1.5, 3.0, 1.5)]) + ); +} + +#[test] +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))]); + 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)), + ]) + ); +} + +#[test] +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)))]); + assert_eq!( + from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(), + Transform(vec![TransformOperation::Skew( + Angle::from_radians(50.0), + Some(Angle::from_radians(50.0)), + )]) + ); +} + +#[test] +fn test_transform_interpolation_on_mismatched_lists() { + use style::values::computed::{Angle, Length, LengthPercentage}; + + let from = Transform(vec![TransformOperation::Rotate3D(0.0, 0.0, 1.0, + Angle::from_radians(100.0))]); + let to = Transform(vec![ + TransformOperation::Translate3D(LengthPercentage::Length(Length::new(100.)), + LengthPercentage::Length(Length::new(0.)), + Length::new(0.))]); + assert_eq!( + from.animate(&to, Procedure::Interpolate { progress: 0.5 }).unwrap(), + Transform(vec![TransformOperation::InterpolateMatrix { + from_list: from.clone(), + to_list: to.clone(), + progress: Percentage(0.5), + }]) + ); +} diff --git a/servo/tests/unit/style/attr.rs b/servo/tests/unit/style/attr.rs new file mode 100644 index 0000000000..b3164c4911 --- /dev/null +++ b/servo/tests/unit/style/attr.rs @@ -0,0 +1,88 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use app_units::Au; +use style::attr::{AttrValue, LengthPercentageOrAuto, parse_length}; +use style::values::computed::{CalcLengthPercentage, Percentage}; + +#[test] +fn test_length_calc() { + let calc = CalcLengthPercentage::new(Au(10).into(), Some(Percentage(0.2))); + assert_eq!(calc.to_used_value(Some(Au(10))), Some(Au(12))); + assert_eq!(calc.to_used_value(Some(Au(0))), Some(Au(10))); + assert_eq!(calc.to_used_value(None), None); + + let calc = CalcLengthPercentage::new(Au(10).into(), None); + assert_eq!(calc.to_used_value(Some(Au(0))), Some(Au(10))); + assert_eq!(calc.to_used_value(None), Some(Au(10))); +} + +#[test] +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") + } +} + +#[test] +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") + } +} + +#[test] +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") + } +} + +#[test] +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") + } +} + +#[test] +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") + } +} + +#[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") + } +} + +#[test] +pub fn test_parse_length() { + fn check(input: &str, expected: LengthPercentageOrAuto) { + let parsed = parse_length(input); + assert_eq!(parsed, expected); + } + + check("0", LengthPercentageOrAuto::Length(Au::from_px(0))); + check("0.000%", LengthPercentageOrAuto::Percentage(0.0)); + check("+5.82%", LengthPercentageOrAuto::Percentage(0.0582)); + check("5.82", LengthPercentageOrAuto::Length(Au::from_f64_px(5.82))); + check("invalid", LengthPercentageOrAuto::Auto); + check("12 followed by invalid", LengthPercentageOrAuto::Length(Au::from_px(12))); +} diff --git a/servo/tests/unit/style/custom_properties.rs b/servo/tests/unit/style/custom_properties.rs new file mode 100644 index 0000000000..f04d4ff6b7 --- /dev/null +++ b/servo/tests/unit/style/custom_properties.rs @@ -0,0 +1,44 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::{Parser, ParserInput}; +use servo_arc::Arc; +use style::custom_properties::{Name, SpecifiedValue, CustomPropertiesMap, CustomPropertiesBuilder, CssEnvironment}; +use style::properties::CustomDeclarationValue; +use test::{self, Bencher}; + +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 env = CssEnvironment; + let mut builder = CustomPropertiesBuilder::new(inherited, &env); + + for &(ref name, ref val) in &values { + builder.cascade(name, &CustomDeclarationValue::Value(val.clone())); + } + + builder.build() +} + +#[bench] +fn cascade_custom_simple(b: &mut Bencher) { + b.iter(|| { + let parent = cascade(&[ + ("foo", "10px"), + ("bar", "100px"), + ], None); + + test::black_box(cascade(&[ + ("baz", "calc(40em + 4px)"), + ("bazz", "calc(30em + 4px)"), + ], parent.as_ref())) + }) +} diff --git a/servo/tests/unit/style/lib.rs b/servo/tests/unit/style/lib.rs new file mode 100644 index 0000000000..aa5a562d12 --- /dev/null +++ b/servo/tests/unit/style/lib.rs @@ -0,0 +1,36 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +#![cfg(test)] +#![feature(test)] + +extern crate app_units; +extern crate cssparser; +extern crate euclid; +#[macro_use] extern crate html5ever; +extern crate parking_lot; +extern crate rayon; +extern crate selectors; +extern crate serde_json; +extern crate servo_arc; +extern crate servo_atoms; +extern crate servo_config; +extern crate servo_url; +#[macro_use] extern crate style; +extern crate style_traits; +extern crate test; + +mod animated_properties; +mod attr; +mod custom_properties; +mod logical_geometry; +mod parsing; +mod properties; +mod rule_tree; +mod size_of; +mod specified_values; +mod str; +mod stylesheets; +mod stylist; +mod viewport; diff --git a/servo/tests/unit/style/logical_geometry.rs b/servo/tests/unit/style/logical_geometry.rs new file mode 100644 index 0000000000..8d6c06ec9a --- /dev/null +++ b/servo/tests/unit/style/logical_geometry.rs @@ -0,0 +1,75 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use euclid::{Size2D, Point2D, SideOffsets2D, Rect}; +use style::logical_geometry::{WritingMode, LogicalSize, LogicalPoint, LogicalMargin, LogicalRect}; + +#[cfg(test)] +fn modes() -> Vec<WritingMode> { + vec![ + WritingMode::empty(), + WritingMode::VERTICAL, + WritingMode::VERTICAL | WritingMode::VERTICAL_LR, + WritingMode::VERTICAL | WritingMode::VERTICAL_LR | WritingMode::VERTICAL_SIDEWAYS, + WritingMode::VERTICAL | WritingMode::VERTICAL_LR | WritingMode::TEXT_SIDEWAYS, + WritingMode::VERTICAL | WritingMode::VERTICAL_SIDEWAYS, + WritingMode::VERTICAL | WritingMode::TEXT_SIDEWAYS, + WritingMode::VERTICAL | WritingMode::UPRIGHT, + WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::VERTICAL_LR | WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::VERTICAL_LR | WritingMode::VERTICAL_SIDEWAYS | WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::VERTICAL_LR | WritingMode::TEXT_SIDEWAYS | WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::VERTICAL_LR | WritingMode::UPRIGHT | WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::VERTICAL_SIDEWAYS | WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::TEXT_SIDEWAYS | WritingMode::RTL, + WritingMode::VERTICAL | WritingMode::UPRIGHT | WritingMode::RTL, + ] +} + +#[test] +fn test_size_round_trip() { + let physical = Size2D::new(1u32, 2u32); + for &mode in modes().iter() { + let logical = LogicalSize::from_physical(mode, physical); + assert_eq!(logical.to_physical(mode), physical); + assert_eq!(logical.width(mode), 1); + assert_eq!(logical.height(mode), 2); + } +} + +#[test] +fn test_point_round_trip() { + let physical = Point2D::new(1u32, 2u32); + let container = Size2D::new(100, 200); + for &mode in modes().iter() { + let logical = LogicalPoint::from_physical(mode, physical, container); + assert_eq!(logical.to_physical(mode, container), physical); + assert_eq!(logical.x(mode, container), 1); + assert_eq!(logical.y(mode, container), 2); + } +} + +#[test] +fn test_margin_round_trip() { + let physical = SideOffsets2D::new(1u32, 2u32, 3u32, 4u32); + for &mode in modes().iter() { + let logical = LogicalMargin::from_physical(mode, physical); + assert_eq!(logical.to_physical(mode), physical); + assert_eq!(logical.top(mode), 1); + assert_eq!(logical.right(mode), 2); + assert_eq!(logical.bottom(mode), 3); + assert_eq!(logical.left(mode), 4); + } +} + +#[test] +fn test_rect_round_trip() { + let physical = Rect::new(Point2D::new(1u32, 2u32), Size2D::new(3u32, 4u32)); + let container = Size2D::new(100, 200); + for &mode in modes().iter() { + let logical = LogicalRect::from_physical(mode, physical, container); + assert_eq!(logical.to_physical(mode, container), physical); + } +} diff --git a/servo/tests/unit/style/media_queries.rs b/servo/tests/unit/style/media_queries.rs new file mode 100644 index 0000000000..eaa91e6ec4 --- /dev/null +++ b/servo/tests/unit/style/media_queries.rs @@ -0,0 +1,398 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use euclid::Scale; +use euclid::Size2D; +use servo_arc::Arc; +use servo_url::ServoUrl; +use std::borrow::ToOwned; +use style::Atom; +use style::context::QuirksMode; +use style::media_queries::*; +use style::servo::media_queries::*; +use style::shared_lock::SharedRwLock; +use style::stylesheets::{AllRules, Stylesheet, StylesheetInDocument, Origin, CssRule}; +use style::values::{CustomIdent, specified}; +use style_traits::ToCss; + +fn test_media_rule<F>(css: &str, callback: F) +where + F: Fn(&MediaList, &str), +{ + let url = ServoUrl::parse("http://localhost").unwrap(); + let css_str = css.to_owned(); + let lock = SharedRwLock::new(); + let media_list = Arc::new(lock.wrap(MediaList::empty())); + let stylesheet = Stylesheet::from_str( + css, url, Origin::Author, media_list, lock, + None, None, QuirksMode::NoQuirks, 0); + let dummy = Device::new(MediaType::screen(), Size2D::new(200.0, 100.0), Scale::new(1.0)); + let mut rule_count = 0; + let guard = stylesheet.shared_lock.read(); + for rule in stylesheet.iter_rules::<AllRules>(&dummy, &guard) { + if let CssRule::Media(ref lock) = *rule { + rule_count += 1; + callback(&lock.read_with(&guard).media_queries.read_with(&guard), css); + } + } + assert!(rule_count > 0, css_str); +} + +fn media_query_test(device: &Device, css: &str, expected_rule_count: usize) { + let url = ServoUrl::parse("http://localhost").unwrap(); + let lock = SharedRwLock::new(); + let media_list = Arc::new(lock.wrap(MediaList::empty())); + let ss = Stylesheet::from_str( + css, url, Origin::Author, media_list, lock, + None, None, QuirksMode::NoQuirks, 0); + let mut rule_count = 0; + ss.effective_style_rules(device, &ss.shared_lock.read(), |_| rule_count += 1); + assert!(rule_count == expected_rule_count, css.to_owned()); +} + +#[test] +fn test_mq_empty() { + test_media_rule("@media { }", |list, css| { + assert!(list.media_queries.len() == 0, css.to_owned()); + }); +} + +#[test] +fn test_mq_screen() { + test_media_rule("@media screen { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media only screen { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Only), css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media not screen { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Not), css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); +} + +#[test] +fn test_mq_print() { + test_media_rule("@media print { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media only print { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Only), css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media not print { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Not), css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); +} + +#[test] +fn test_mq_unknown() { + test_media_rule("@media fridge { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete( + MediaType(CustomIdent(Atom::from("fridge")))), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media only glass { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Only), css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete( + MediaType(CustomIdent(Atom::from("glass")))), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media not wood { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Not), css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete( + MediaType(CustomIdent(Atom::from("wood")))), css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); +} + +#[test] +fn test_mq_all() { + test_media_rule("@media all { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::All, css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media only all { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Only), css.to_owned()); + assert!(q.media_type == MediaQueryType::All, css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); + + test_media_rule("@media not all { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Not), css.to_owned()); + assert!(q.media_type == MediaQueryType::All, css.to_owned()); + assert!(q.expressions.len() == 0, css.to_owned()); + }); +} + +#[test] +fn test_mq_or() { + test_media_rule("@media screen, print { }", |list, css| { + assert!(list.media_queries.len() == 2, css.to_owned()); + let q0 = &list.media_queries[0]; + assert!(q0.qualifier == None, css.to_owned()); + assert!(q0.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned()); + assert!(q0.expressions.len() == 0, css.to_owned()); + + let q1 = &list.media_queries[1]; + assert!(q1.qualifier == None, css.to_owned()); + assert!(q1.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned()); + assert!(q1.expressions.len() == 0, css.to_owned()); + }); +} + +#[test] +fn test_mq_default_expressions() { + test_media_rule("@media (min-width: 100px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::All, css.to_owned()); + assert!(q.expressions.len() == 1, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::from_px(100.)), + _ => panic!("wrong expression type"), + } + }); + + test_media_rule("@media (max-width: 43px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::All, css.to_owned()); + assert!(q.expressions.len() == 1, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(43.)), + _ => panic!("wrong expression type"), + } + }); +} + +#[test] +fn test_mq_expressions() { + test_media_rule("@media screen and (min-width: 100px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned()); + assert!(q.expressions.len() == 1, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::from_px(100.)), + _ => panic!("wrong expression type"), + } + }); + + test_media_rule("@media print and (max-width: 43px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned()); + assert!(q.expressions.len() == 1, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(43.)), + _ => panic!("wrong expression type"), + } + }); + + test_media_rule("@media print and (width: 43px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::print()), css.to_owned()); + assert!(q.expressions.len() == 1, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Eq(ref w)) => assert!(*w == specified::Length::from_px(43.)), + _ => panic!("wrong expression type"), + } + }); + + test_media_rule("@media fridge and (max-width: 52px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete( + MediaType(CustomIdent(Atom::from("fridge")))), css.to_owned()); + assert!(q.expressions.len() == 1, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(52.)), + _ => panic!("wrong expression type"), + } + }); +} + +#[test] +fn test_to_css() { + test_media_rule("@media print and (width: 43px) { }", |list, _| { + let q = &list.media_queries[0]; + let dest = q.to_css_string(); + assert_eq!(dest, "print and (width: 43px)"); + }); +} + +#[test] +fn test_mq_multiple_expressions() { + test_media_rule("@media (min-width: 100px) and (max-width: 200px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == None, css.to_owned()); + assert!(q.media_type == MediaQueryType::All, css.to_owned()); + assert!(q.expressions.len() == 2, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::from_px(100.)), + _ => panic!("wrong expression type"), + } + match *q.expressions[1].kind_for_testing() { + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(200.)), + _ => panic!("wrong expression type"), + } + }); + + test_media_rule("@media not screen and (min-width: 100px) and (max-width: 200px) { }", |list, css| { + assert!(list.media_queries.len() == 1, css.to_owned()); + let q = &list.media_queries[0]; + assert!(q.qualifier == Some(Qualifier::Not), css.to_owned()); + assert!(q.media_type == MediaQueryType::Concrete(MediaType::screen()), css.to_owned()); + assert!(q.expressions.len() == 2, css.to_owned()); + match *q.expressions[0].kind_for_testing() { + ExpressionKind::Width(Range::Min(ref w)) => assert!(*w == specified::Length::from_px(100.)), + _ => panic!("wrong expression type"), + } + match *q.expressions[1].kind_for_testing() { + ExpressionKind::Width(Range::Max(ref w)) => assert!(*w == specified::Length::from_px(200.)), + _ => panic!("wrong expression type"), + } + }); +} + +#[test] +fn test_mq_malformed_expressions() { + fn check_malformed_expr(list: &MediaList, css: &str) { + assert!(!list.media_queries.is_empty(), css.to_owned()); + for mq in &list.media_queries { + assert!(mq.qualifier == Some(Qualifier::Not), css.to_owned()); + assert!(mq.media_type == MediaQueryType::All, css.to_owned()); + assert!(mq.expressions.is_empty(), css.to_owned()); + } + } + + for rule in &[ + "@media (min-width: 100blah) and (max-width: 200px) { }", + "@media screen and (height: 200px) { }", + "@media (min-width: 30em foo bar) {}", + "@media not {}", + "@media not (min-width: 300px) {}", + "@media , {}", + ] { + test_media_rule(rule, check_malformed_expr); + } +} + +#[test] +fn test_matching_simple() { + let device = Device::new(MediaType::screen(), Size2D::new(200.0, 100.0), Scale::new(1.0)); + + media_query_test(&device, "@media not all { a { color: red; } }", 0); + media_query_test(&device, "@media not screen { a { color: red; } }", 0); + media_query_test(&device, "@media not print { a { color: red; } }", 1); + + media_query_test(&device, "@media unknown { a { color: red; } }", 0); + media_query_test(&device, "@media not unknown { a { color: red; } }", 1); + + media_query_test(&device, "@media { a { color: red; } }", 1); + media_query_test(&device, "@media screen { a { color: red; } }", 1); + media_query_test(&device, "@media print { a { color: red; } }", 0); +} + +#[test] +fn test_matching_width() { + let device = Device::new(MediaType::screen(), Size2D::new(200.0, 100.0), Scale::new(1.0)); + + media_query_test(&device, "@media { a { color: red; } }", 1); + + media_query_test(&device, "@media (min-width: 50px) { a { color: red; } }", 1); + media_query_test(&device, "@media (min-width: 150px) { a { color: red; } }", 1); + media_query_test(&device, "@media (min-width: 300px) { a { color: red; } }", 0); + + media_query_test(&device, "@media screen and (min-width: 50px) { a { color: red; } }", 1); + media_query_test(&device, "@media screen and (min-width: 150px) { a { color: red; } }", 1); + media_query_test(&device, "@media screen and (min-width: 300px) { a { color: red; } }", 0); + + media_query_test(&device, "@media not screen and (min-width: 50px) { a { color: red; } }", 0); + media_query_test(&device, "@media not screen and (min-width: 150px) { a { color: red; } }", 0); + media_query_test(&device, "@media not screen and (min-width: 300px) { a { color: red; } }", 1); + + media_query_test(&device, "@media (max-width: 50px) { a { color: red; } }", 0); + media_query_test(&device, "@media (max-width: 150px) { a { color: red; } }", 0); + media_query_test(&device, "@media (max-width: 300px) { a { color: red; } }", 1); + + media_query_test(&device, "@media screen and (min-width: 50px) and (max-width: 100px) { a { color: red; } }", 0); + media_query_test(&device, "@media screen and (min-width: 250px) and (max-width: 300px) { a { color: red; } }", 0); + media_query_test(&device, "@media screen and (min-width: 50px) and (max-width: 250px) { a { color: red; } }", 1); + + media_query_test( + &device, "@media not screen and (min-width: 50px) and (max-width: 100px) { a { color: red; } }", 1); + media_query_test( + &device, "@media not screen and (min-width: 250px) and (max-width: 300px) { a { color: red; } }", 1); + media_query_test( + &device, "@media not screen and (min-width: 50px) and (max-width: 250px) { a { color: red; } }", 0); + + media_query_test( + &device, "@media not screen and (min-width: 3.1em) and (max-width: 6em) { a { color: red; } }", 1); + media_query_test( + &device, "@media not screen and (min-width: 16em) and (max-width: 19.75em) { a { color: red; } }", 1); + media_query_test( + &device, "@media not screen and (min-width: 3em) and (max-width: 250px) { a { color: red; } }", 0); +} + +#[test] +fn test_matching_invalid() { + let device = Device::new(MediaType::screen(), Size2D::new(200.0, 100.0), Scale::new(1.0)); + + media_query_test(&device, "@media fridge { a { color: red; } }", 0); + media_query_test(&device, "@media screen and (height: 100px) { a { color: red; } }", 0); + media_query_test(&device, "@media not print and (width: 100) { a { color: red; } }", 0); +} diff --git a/servo/tests/unit/style/parsing/animation.rs b/servo/tests/unit/style/parsing/animation.rs new file mode 100644 index 0000000000..a4b2d78597 --- /dev/null +++ b/servo/tests/unit/style/parsing/animation.rs @@ -0,0 +1,21 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use servo_atoms::Atom; +use style::parser::Parse; +use style::properties::longhands::animation_name; +use style::values::{KeyframesName, CustomIdent}; +use style::values::specified::AnimationIterationCount; +use style_traits::ToCss; + +#[test] +fn test_animation_iteration() { + assert_roundtrip_with_context!(AnimationIterationCount::parse, "0", "0"); + assert_roundtrip_with_context!(AnimationIterationCount::parse, "0.1", "0.1"); + assert_roundtrip_with_context!(AnimationIterationCount::parse, "infinite", "infinite"); + + // Negative numbers are invalid + assert!(parse(AnimationIterationCount::parse, "-1").is_err()); +} diff --git a/servo/tests/unit/style/parsing/background.rs b/servo/tests/unit/style/parsing/background.rs new file mode 100644 index 0000000000..7f091a5b05 --- /dev/null +++ b/servo/tests/unit/style/parsing/background.rs @@ -0,0 +1,104 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style::properties::longhands::{background_attachment, background_clip, background_color, background_image}; +use style::properties::longhands::{background_origin, background_position_x, background_position_y, background_repeat}; +use style::properties::longhands::background_size; +use style::properties::shorthands::background; + +#[test] +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")); +} + +#[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")); + + 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")); + + 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")); + + 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\")")); +} + +#[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 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")); +} + +#[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")); + + 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!(parse(background::parse_value, "/ 30px 20px").is_err()); + + assert!(parse(background::parse_value, "repeat-x / 30px 20px").is_err()); +} + +#[test] +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")); + + 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")); + + 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")); +} diff --git a/servo/tests/unit/style/parsing/border.rs b/servo/tests/unit/style/parsing/border.rs new file mode 100644 index 0000000000..3565d6ad53 --- /dev/null +++ b/servo/tests/unit/style/parsing/border.rs @@ -0,0 +1,190 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style::parser::Parse; +use style::properties::MaybeBoxed; +use style::properties::longhands::{border_image_outset, border_image_repeat, border_image_slice}; +use style::properties::longhands::{border_image_source, border_image_width}; +use style::properties::shorthands::border_image; +use style::values::specified::BorderRadius; +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()) + } +} + +macro_rules! assert_initial { + ($parsed_shorthand: expr, $prop: ident) => { + 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); + } +} + +#[test] +fn test_border_radius() { + assert_border_radius_values!("10px"; + "10px", "10px", "10px", "10px" ; + "10px", "10px", "10px", "10px"); + assert_border_radius_values!("10px 20px"; + "10px", "20px", "10px", "20px" ; + "10px", "20px", "10px", "20px"); + assert_border_radius_values!("10px 20px 30px"; + "10px", "20px", "30px", "20px" ; + "10px", "20px", "30px", "20px"); + assert_border_radius_values!("10px 20px 30px 40px"; + "10px", "20px", "30px", "40px" ; + "10px", "20px", "30px", "40px"); + assert_border_radius_values!("10% / 20px"; + "10%", "10%", "10%", "10%" ; + "20px", "20px", "20px", "20px"); + assert_border_radius_values!("10px / 20px 30px"; + "10px", "10px", "10px", "10px" ; + "20px", "30px", "20px", "30px"); + assert_border_radius_values!("10px 20px 30px 40px / 1px 2px 3px 4px"; + "10px", "20px", "30px", "40px" ; + "1px", "2px", "3px", "4px"); + assert_border_radius_values!("10px 20px 30px 40px / 1px 2px 3px 4px"; + "10px", "20px", "30px", "40px" ; + "1px", "2px", "3px", "4px"); + assert_border_radius_values!("10px 20px 30px 40px / 1px 2px 3px 4px"; + "10px", "20px", "30px", "40px" ; + "1px", "2px", "3px", "4px"); + assert_border_radius_values!("10px -20px 30px 40px"; + "10px", "10px", "10px", "10px"; + "10px", "10px", "10px", "10px"); + assert_border_radius_values!("10px 20px -30px 40px"; + "10px", "20px", "10px", "20px"; + "10px", "20px", "10px", "20px"); + assert_border_radius_values!("10px 20px 30px -40px"; + "10px", "20px", "30px", "20px"; + "10px", "20px", "30px", "20px"); + assert!(parse(BorderRadius::parse, "-10px 20px 30px 40px").is_err()); +} + +#[test] +fn border_image_shorthand_should_parse_when_all_properties_specified() { + let input = "linear-gradient(red, blue) 30 30% 45 fill / 20px 40px / 10px round stretch"; + let result = parse(border_image::parse_value, input).unwrap(); + + assert_longhand!(result, border_image_source, "linear-gradient(red, blue)"); + assert_longhand!(result, border_image_slice, "30 30% 45 fill"); + assert_longhand!(result, border_image_width, "20px 40px"); + assert_longhand!(result, border_image_outset, "10px"); + assert_longhand!(result, border_image_repeat, "round stretch"); +} + +#[test] +fn border_image_shorthand_should_parse_without_width() { + let input = "linear-gradient(red, blue) 30 30% 45 fill / / 10px round stretch"; + let result = parse(border_image::parse_value, input).unwrap(); + + assert_longhand!(result, border_image_source, "linear-gradient(red, blue)"); + assert_longhand!(result, border_image_slice, "30 30% 45 fill"); + assert_longhand!(result, border_image_outset, "10px"); + assert_longhand!(result, border_image_repeat, "round stretch"); + assert_initial!(result, border_image_width); +} + +#[test] +fn border_image_shorthand_should_parse_without_outset() { + let input = "linear-gradient(red, blue) 30 30% 45 fill / 20px 40px round"; + let result = parse(border_image::parse_value, input).unwrap(); + + assert_longhand!(result, border_image_source, "linear-gradient(red, blue)"); + assert_longhand!(result, border_image_slice, "30 30% 45 fill"); + assert_longhand!(result, border_image_width, "20px 40px"); + assert_longhand!(result, border_image_repeat, "round"); + assert_initial!(result, border_image_outset); +} + +#[test] +fn border_image_shorthand_should_parse_without_width_or_outset() { + let input = "linear-gradient(red, blue) 30 30% 45 fill round"; + let result = parse(border_image::parse_value, input).unwrap(); + + assert_longhand!(result, border_image_source, "linear-gradient(red, blue)"); + assert_longhand!(result, border_image_slice, "30 30% 45 fill"); + assert_longhand!(result, border_image_repeat, "round"); + assert_initial!(result, border_image_width); + assert_initial!(result, border_image_outset); +} + +#[test] +fn border_image_shorthand_should_parse_with_just_source() { + let result = parse(border_image::parse_value, "linear-gradient(red, blue)").unwrap(); + + assert_longhand!(result, border_image_source, "linear-gradient(red, blue)"); + assert_initial!(result, border_image_slice); + assert_initial!(result, border_image_width); + assert_initial!(result, border_image_outset); + assert_initial!(result, border_image_repeat); +} + +#[test] +fn border_image_outset_should_error_on_negative_length() { + let result = parse(border_image_outset::parse, "-1em"); + assert!(result.is_err()); +} + +#[test] +fn border_image_outset_should_error_on_negative_number() { + let result = parse(border_image_outset::parse, "-15"); + assert!(result.is_err()); +} + +#[test] +fn border_image_outset_should_return_number_on_plain_zero() { + let result = parse(border_image_outset::parse, "0"); + assert_eq!(result.unwrap(), parse_longhand!(border_image_outset, "0")); +} + +#[test] +fn border_image_outset_should_return_length_on_length_zero() { + let result = parse(border_image_outset::parse, "0em"); + assert_eq!(result.unwrap(), parse_longhand!(border_image_outset, "0em")); +} + +#[test] +fn test_border_style() { + use style::values::specified::BorderStyle; + + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"none"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"hidden"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"solid"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"double"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"dotted"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"dashed"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"groove"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"ridge"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"inset"#); + assert_roundtrip_with_context!(<BorderStyle as Parse>::parse, r#"outset"#); +} + +#[test] +fn test_border_spacing() { + use style::properties::longhands::border_spacing; + + assert_parser_exhausted!(border_spacing::parse, "1px rubbish", false); + assert_parser_exhausted!(border_spacing::parse, "1px", true); + assert_parser_exhausted!(border_spacing::parse, "1px 2px", true); +} diff --git a/servo/tests/unit/style/parsing/box_.rs b/servo/tests/unit/style/parsing/box_.rs new file mode 100644 index 0000000000..cec950c3cd --- /dev/null +++ b/servo/tests/unit/style/parsing/box_.rs @@ -0,0 +1,22 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style_traits::ToCss; + +#[test] +fn test_transform_translate() { + use style::properties::longhands::transform; + assert_roundtrip_with_context!(transform::parse, "translate(2px)"); + assert_roundtrip_with_context!(transform::parse, "translate(2px, 5px)"); + assert!(parse(transform::parse, "translate(2px foo)").is_err()); + assert!(parse(transform::parse, "perspective(-10px)").is_err()); +} + +#[test] +fn test_unexhausted_transform() { + use style::properties::longhands::transform; + assert_parser_exhausted!(transform::parse, "rotate(70deg)foo", false); + assert_parser_exhausted!(transform::parse, "rotate(70deg) foo", false); +} diff --git a/servo/tests/unit/style/parsing/column.rs b/servo/tests/unit/style/parsing/column.rs new file mode 100644 index 0000000000..6e0e86182a --- /dev/null +++ b/servo/tests/unit/style/parsing/column.rs @@ -0,0 +1,30 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style_traits::ToCss; + +#[test] +fn test_column_width() { + use style::properties::longhands::column_width; + + assert_roundtrip_with_context!(column_width::parse, "auto"); + assert_roundtrip_with_context!(column_width::parse, "6px"); + assert_roundtrip_with_context!(column_width::parse, "2.5em"); + assert_roundtrip_with_context!(column_width::parse, "0.3vw"); + + assert!(parse(column_width::parse, "-6px").is_err()); +} + +#[test] +fn test_column_gap() { + use style::properties::longhands::column_gap; + + assert_roundtrip_with_context!(column_gap::parse, "normal"); + assert_roundtrip_with_context!(column_gap::parse, "6px"); + assert_roundtrip_with_context!(column_gap::parse, "2.5em"); + assert_roundtrip_with_context!(column_gap::parse, "0.3vw"); + + assert!(parse(column_gap::parse, "-6px").is_err()); +} diff --git a/servo/tests/unit/style/parsing/effects.rs b/servo/tests/unit/style/parsing/effects.rs new file mode 100644 index 0000000000..faf1126efa --- /dev/null +++ b/servo/tests/unit/style/parsing/effects.rs @@ -0,0 +1,91 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style::properties::longhands::{perspective_origin, transform_origin}; +use style_traits::ToCss; + +#[test] +fn test_clip() { + use style::properties::longhands::clip; + + assert_roundtrip_with_context!(clip::parse, "auto"); + assert_roundtrip_with_context!(clip::parse, "rect(1px, 2px, 3px, 4px)"); + assert_roundtrip_with_context!(clip::parse, "rect(1px, auto, auto, 4px)"); + 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)"); +} + +#[test] +fn test_effects_parser_exhaustion() { + assert_parser_exhausted!(perspective_origin::parse, "1px 1px", true); + assert_parser_exhausted!(transform_origin::parse, "1px 1px", true); + + assert_parser_exhausted!(perspective_origin::parse, "1px some-rubbish", false); + assert_parser_exhausted!(transform_origin::parse, "1px some-rubbish", false); +} + +#[test] +fn test_parse_factor() { + use parsing::parse; + use style::properties::longhands::filter; + + assert!(parse(filter::parse, "brightness(0)").is_ok()); + assert!(parse(filter::parse, "brightness(55)").is_ok()); + assert!(parse(filter::parse, "brightness(100)").is_ok()); + + assert!(parse(filter::parse, "contrast(0)").is_ok()); + assert!(parse(filter::parse, "contrast(55)").is_ok()); + assert!(parse(filter::parse, "contrast(100)").is_ok()); + + assert!(parse(filter::parse, "grayscale(0)").is_ok()); + assert!(parse(filter::parse, "grayscale(55)").is_ok()); + assert!(parse(filter::parse, "grayscale(100)").is_ok()); + + assert!(parse(filter::parse, "invert(0)").is_ok()); + assert!(parse(filter::parse, "invert(55)").is_ok()); + assert!(parse(filter::parse, "invert(100)").is_ok()); + + assert!(parse(filter::parse, "opacity(0)").is_ok()); + assert!(parse(filter::parse, "opacity(55)").is_ok()); + assert!(parse(filter::parse, "opacity(100)").is_ok()); + + assert!(parse(filter::parse, "sepia(0)").is_ok()); + assert!(parse(filter::parse, "sepia(55)").is_ok()); + assert!(parse(filter::parse, "sepia(100)").is_ok()); + + assert!(parse(filter::parse, "saturate(0)").is_ok()); + assert!(parse(filter::parse, "saturate(55)").is_ok()); + assert!(parse(filter::parse, "saturate(100)").is_ok()); + + // Negative numbers are invalid for certain filters + assert!(parse(filter::parse, "brightness(-1)").is_err()); + assert!(parse(filter::parse, "contrast(-1)").is_err()); + assert!(parse(filter::parse, "grayscale(-1)").is_err()); + assert!(parse(filter::parse, "invert(-1)").is_err()); + assert!(parse(filter::parse, "opacity(-1)").is_err()); + assert!(parse(filter::parse, "sepia(-1)").is_err()); + assert!(parse(filter::parse, "saturate(-1)").is_err()); +} + +#[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 +} diff --git a/servo/tests/unit/style/parsing/image.rs b/servo/tests/unit/style/parsing/image.rs new file mode 100644 index 0000000000..8833eaf391 --- /dev/null +++ b/servo/tests/unit/style/parsing/image.rs @@ -0,0 +1,104 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use style::parser::Parse; +use style::values::specified::image::*; +use style_traits::ToCss; + +#[test] +fn test_linear_gradient() { + // Parsing from the right + assert_roundtrip_with_context!(Image::parse, "linear-gradient(to left, red, green)"); + + // Parsing from the left + assert_roundtrip_with_context!(Image::parse, "linear-gradient(to right, red, green)"); + + // Parsing with two values for <side-or-corner> + assert_roundtrip_with_context!(Image::parse, "linear-gradient(to right top, red, green)"); + + // Parsing with <angle> + assert_roundtrip_with_context!(Image::parse, "linear-gradient(45deg, red, green)"); + + // Parsing with more than two entries in <color-stop-list> + assert_roundtrip_with_context!(Image::parse, "linear-gradient(red, yellow, green)"); + + // Parsing with percentage in the <color-stop-list> + assert_roundtrip_with_context!(Image::parse, "linear-gradient(red, green, yellow 50%)"); + + // Parsing without <angle> and <side-or-corner> + assert_roundtrip_with_context!(Image::parse, "linear-gradient(red, green)"); +} + +#[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)"); + + // 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)"); + + // 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)"); + + + // 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)"); + + // 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)"); + + // Parsing with just color stops + 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)"); +} diff --git a/servo/tests/unit/style/parsing/inherited_text.rs b/servo/tests/unit/style/parsing/inherited_text.rs new file mode 100644 index 0000000000..abcbe5d091 --- /dev/null +++ b/servo/tests/unit/style/parsing/inherited_text.rs @@ -0,0 +1,44 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style::values::generics::text::Spacing; + +#[test] +fn negative_letter_spacing_should_parse_properly() { + use style::properties::longhands::letter_spacing; + 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)))); + assert_eq!(negative_value, expected); +} + +#[test] +fn negative_word_spacing_should_parse_properly() { + use style::properties::longhands::word_spacing; + use style::values::specified::length::{NoCalcLength, LengthPercentage, FontRelativeLength}; + + let negative_value = parse_longhand!(word_spacing, "-0.5em"); + let expected = Spacing::Value(LengthPercentage::Length( + NoCalcLength::FontRelative(FontRelativeLength::Em(-0.5)) + )); + assert_eq!(negative_value, expected); +} + +#[test] +fn line_height_should_return_number_on_plain_zero() { + use style::properties::longhands::line_height; + + let result = parse(line_height::parse, "0").unwrap(); + assert_eq!(result, parse_longhand!(line_height, "0")); +} + +#[test] +fn line_height_should_return_length_on_length_zero() { + use style::properties::longhands::line_height; + + let result = parse(line_height::parse, "0px").unwrap(); + assert_eq!(result, parse_longhand!(line_height, "0px")); +} diff --git a/servo/tests/unit/style/parsing/mod.rs b/servo/tests/unit/style/parsing/mod.rs new file mode 100644 index 0000000000..dc931633e7 --- /dev/null +++ b/servo/tests/unit/style/parsing/mod.rs @@ -0,0 +1,126 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +//! Tests for parsing and serialization of values/properties + +use cssparser::{Parser, ParserInput}; +use style::context::QuirksMode; +use style::parser::ParserContext; +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>> { + 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>> { + let url = ::servo_url::ServoUrl::parse("http://localhost").unwrap(); + let context = ParserContext::new( + Origin::Author, + &url, + Some(CssRuleType::Style), + ParsingMode::DEFAULT, + QuirksMode::NoQuirks, + None, + None, + ); + let mut parser = Parser::new(input); + f(&context, &mut parser) +} + +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>> { + 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) +} + +// This is a macro so that the file/line information +// is preserved in the panic +macro_rules! assert_roundtrip_with_context { + ($fun:expr, $string:expr) => { + assert_roundtrip_with_context!($fun, $string, $string); + }; + ($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 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(); + unwrapped + }} +} + +macro_rules! assert_roundtrip { + ($fun:expr, $string:expr) => { + assert_roundtrip!($fun, $string, $string); + }; + ($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 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_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() + }} +} + +macro_rules! parse_longhand { + ($name:ident, $s:expr) => { + parse($name::parse, $s).unwrap() + }; +} + +mod animation; +mod background; +mod border; +mod box_; +mod column; +mod effects; +mod image; +mod inherited_text; +mod outline; +mod position; +mod selectors; +mod supports; +mod text_overflow; +mod transition_duration; +mod transition_timing_function; diff --git a/servo/tests/unit/style/parsing/outline.rs b/servo/tests/unit/style/parsing/outline.rs new file mode 100644 index 0000000000..6d909d9bc5 --- /dev/null +++ b/servo/tests/unit/style/parsing/outline.rs @@ -0,0 +1,26 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style_traits::ToCss; + +#[test] +fn test_outline_style() { + use style::properties::longhands::outline_style; + + assert_roundtrip_with_context!(outline_style::parse, r#"auto"#); + assert_roundtrip_with_context!(outline_style::parse, r#"none"#); + assert_roundtrip_with_context!(outline_style::parse, r#"solid"#); + assert_roundtrip_with_context!(outline_style::parse, r#"double"#); + assert_roundtrip_with_context!(outline_style::parse, r#"dotted"#); + assert_roundtrip_with_context!(outline_style::parse, r#"dashed"#); + assert_roundtrip_with_context!(outline_style::parse, r#"groove"#); + assert_roundtrip_with_context!(outline_style::parse, r#"ridge"#); + assert_roundtrip_with_context!(outline_style::parse, r#"inset"#); + assert_roundtrip_with_context!(outline_style::parse, r#"outset"#); + + // The outline-style property accepts the same values as border-style, + // except that 'hidden' is not a legal outline style. + assert!(parse(outline_style::parse, r#"hidden"#).is_err()); +} diff --git a/servo/tests/unit/style/parsing/position.rs b/servo/tests/unit/style/parsing/position.rs new file mode 100644 index 0000000000..ce73c7a0d2 --- /dev/null +++ b/servo/tests/unit/style/parsing/position.rs @@ -0,0 +1,145 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::{parse, parse_entirely}; +use style::parser::Parse; +use style::values::specified::position::*; +use style_traits::ToCss; + +#[test] +fn test_position() { + // Serialization is not actually specced + // though these are the values expected by basic-shape + // https://github.com/w3c/csswg-drafts/issues/368 + assert_roundtrip_with_context!(Position::parse, "center", "center center"); + assert_roundtrip_with_context!(Position::parse, "top left", "left top"); + assert_roundtrip_with_context!(Position::parse, "left top", "left top"); + assert_roundtrip_with_context!(Position::parse, "top right", "right top"); + assert_roundtrip_with_context!(Position::parse, "right top", "right top"); + assert_roundtrip_with_context!(Position::parse, "bottom left", "left bottom"); + assert_roundtrip_with_context!(Position::parse, "left bottom", "left bottom"); + assert_roundtrip_with_context!(Position::parse, "left center", "left center"); + assert_roundtrip_with_context!(Position::parse, "right center", "right center"); + assert_roundtrip_with_context!(Position::parse, "center top", "center top"); + assert_roundtrip_with_context!(Position::parse, "center bottom", "center bottom"); + assert_roundtrip_with_context!(Position::parse, "center 10px", "center 10px"); + assert_roundtrip_with_context!(Position::parse, "center 10%", "center 10%"); + assert_roundtrip_with_context!(Position::parse, "right 10%", "right 10%"); + + // Only keywords can be reordered + assert!(parse_entirely(Position::parse, "top 40%").is_err()); + assert!(parse_entirely(Position::parse, "40% left").is_err()); + + // 3 and 4 value serialization + assert_roundtrip_with_context!(Position::parse, "left 10px top 15px", "left 10px top 15px"); + assert_roundtrip_with_context!(Position::parse, "top 15px left 10px", "left 10px top 15px"); + assert_roundtrip_with_context!(Position::parse, "left 10% top 15px", "left 10% top 15px"); + assert_roundtrip_with_context!(Position::parse, "top 15px left 10%", "left 10% top 15px"); + assert_roundtrip_with_context!(Position::parse, "left top 15px", "left top 15px"); + assert_roundtrip_with_context!(Position::parse, "top 15px left", "left top 15px"); + assert_roundtrip_with_context!(Position::parse, "left 10px top", "left 10px top"); + assert_roundtrip_with_context!(Position::parse, "top left 10px", "left 10px top"); + assert_roundtrip_with_context!(Position::parse, "right 10px bottom", "right 10px bottom"); + assert_roundtrip_with_context!(Position::parse, "bottom right 10px", "right 10px bottom"); + assert_roundtrip_with_context!(Position::parse, "center right 10px", "right 10px center"); + assert_roundtrip_with_context!(Position::parse, "center bottom 10px", "center bottom 10px"); + + // Invalid 3 value positions + assert!(parse_entirely(Position::parse, "20px 30px 20px").is_err()); + assert!(parse_entirely(Position::parse, "top 30px 20px").is_err()); + assert!(parse_entirely(Position::parse, "50% bottom 20%").is_err()); + + // Only horizontal and vertical keywords can have positions + assert!(parse_entirely(Position::parse, "center 10px left 15px").is_err()); + assert!(parse_entirely(Position::parse, "center 10px 15px").is_err()); + assert!(parse_entirely(Position::parse, "center 10px bottom").is_err()); + + // "Horizontal Horizontal" or "Vertical Vertical" positions cause error + assert!(parse_entirely(Position::parse, "left right").is_err()); + assert!(parse_entirely(Position::parse, "left 10px right").is_err()); + assert!(parse_entirely(Position::parse, "left 10px right 15%").is_err()); + assert!(parse_entirely(Position::parse, "top bottom").is_err()); + assert!(parse_entirely(Position::parse, "top 10px bottom").is_err()); + assert!(parse_entirely(Position::parse, "top 10px bottom 15%").is_err()); + + // Logical keywords are not supported in Position yet. + assert!(parse(Position::parse, "x-start").is_err()); + assert!(parse(Position::parse, "y-end").is_err()); + assert!(parse(Position::parse, "x-start y-end").is_err()); + assert!(parse(Position::parse, "x-end 10px").is_err()); + assert!(parse(Position::parse, "y-start 20px").is_err()); + assert!(parse(Position::parse, "x-start bottom 10%").is_err()); + assert!(parse_entirely(Position::parse, "left y-start 10%").is_err()); + assert!(parse(Position::parse, "x-start 20px y-end 10%").is_err()); +} + +#[test] +fn test_horizontal_position() { + // One value serializations. + assert_roundtrip_with_context!(HorizontalPosition::parse, "20px", "20px"); + assert_roundtrip_with_context!(HorizontalPosition::parse, "25%", "25%"); + assert_roundtrip_with_context!(HorizontalPosition::parse, "center", "center"); + assert_roundtrip_with_context!(HorizontalPosition::parse, "left", "left"); + assert_roundtrip_with_context!(HorizontalPosition::parse, "right", "right"); + + // Two value serializations. + assert_roundtrip_with_context!(HorizontalPosition::parse, "right 10px", "right 10px"); + + // Invalid horizontal positions. + assert!(parse(HorizontalPosition::parse, "top").is_err()); + assert!(parse(HorizontalPosition::parse, "bottom").is_err()); + assert!(parse(HorizontalPosition::parse, "y-start").is_err()); + assert!(parse(HorizontalPosition::parse, "y-end").is_err()); + assert!(parse(HorizontalPosition::parse, "y-end 20px ").is_err()); + assert!(parse(HorizontalPosition::parse, "bottom 20px").is_err()); + assert!(parse(HorizontalPosition::parse, "bottom top").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "20px y-end").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "20px top").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "left center").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "left top").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "left right").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "20px 30px").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "10px left").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "x-end 20%").is_err()); + assert!(parse_entirely(HorizontalPosition::parse, "20px x-start").is_err()); + + // Logical keywords are not supported in Position yet. + assert!(parse(HorizontalPosition::parse, "x-start").is_err()); + assert!(parse(HorizontalPosition::parse, "x-end").is_err()); +} + +#[test] +fn test_vertical_position() { + // One value serializations. + assert_roundtrip_with_context!(VerticalPosition::parse, "20px", "20px"); + assert_roundtrip_with_context!(VerticalPosition::parse, "25%", "25%"); + assert_roundtrip_with_context!(VerticalPosition::parse, "center", "center"); + assert_roundtrip_with_context!(VerticalPosition::parse, "top", "top"); + assert_roundtrip_with_context!(VerticalPosition::parse, "bottom", "bottom"); + + // Two value serializations. + assert_roundtrip_with_context!(VerticalPosition::parse, "bottom 10px", "bottom 10px"); + + // Invalid vertical positions. + assert!(parse(VerticalPosition::parse, "left").is_err()); + assert!(parse(VerticalPosition::parse, "right").is_err()); + assert!(parse(VerticalPosition::parse, "x-start").is_err()); + assert!(parse(VerticalPosition::parse, "x-end").is_err()); + assert!(parse(VerticalPosition::parse, "x-end 20px").is_err()); + assert!(parse(VerticalPosition::parse, "left 20px").is_err()); + assert!(parse(VerticalPosition::parse, "left center").is_err()); + assert!(parse(VerticalPosition::parse, "left top").is_err()); + assert!(parse(VerticalPosition::parse, "left right").is_err()); + assert!(parse_entirely(VerticalPosition::parse, "20px x-end").is_err()); + assert!(parse_entirely(VerticalPosition::parse, "20px right").is_err()); + assert!(parse_entirely(VerticalPosition::parse, "bottom top").is_err()); + assert!(parse_entirely(VerticalPosition::parse, "20px 30px").is_err()); + assert!(parse_entirely(VerticalPosition::parse, "10px top").is_err()); + assert!(parse_entirely(VerticalPosition::parse, "y-end 20%").is_err()); + assert!(parse_entirely(VerticalPosition::parse, "20px y-start").is_err()); + + // Logical keywords are not supported in Position yet. + assert!(parse(VerticalPosition::parse, "y-start").is_err()); + assert!(parse(VerticalPosition::parse, "y-end").is_err()); +} diff --git a/servo/tests/unit/style/parsing/selectors.rs b/servo/tests/unit/style/parsing/selectors.rs new file mode 100644 index 0000000000..a1e85bd20d --- /dev/null +++ b/servo/tests/unit/style/parsing/selectors.rs @@ -0,0 +1,30 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::{Parser, ParserInput, ToCss}; +use selectors::parser::SelectorList; +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>> { + let mut ns = Namespaces::default(); + ns.prefixes.insert("svg".into(), ns!(svg)); + let parser = SelectorParser { + stylesheet_origin: Origin::UserAgent, + namespaces: &ns, + url_data: None, + }; + SelectorList::parse(&parser, input) +} + +#[test] +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, "* > *"); + assert_roundtrip!(parse_selector, "*|* + *", "* + *"); +} diff --git a/servo/tests/unit/style/parsing/supports.rs b/servo/tests/unit/style/parsing/supports.rs new file mode 100644 index 0000000000..15e948b73e --- /dev/null +++ b/servo/tests/unit/style/parsing/supports.rs @@ -0,0 +1,16 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::{Parser, ParserInput}; +use style::stylesheets::supports_rule::SupportsCondition; +use style_traits::ToCss; + +#[test] +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, "future-\\1 extension(4)"); + assert_roundtrip!(SupportsCondition::parse, "((test))"); +} diff --git a/servo/tests/unit/style/parsing/text_overflow.rs b/servo/tests/unit/style/parsing/text_overflow.rs new file mode 100644 index 0000000000..505e6ffb8c --- /dev/null +++ b/servo/tests/unit/style/parsing/text_overflow.rs @@ -0,0 +1,30 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style_traits::ToCss; + +#[test] +fn test_text_overflow() { + use style::properties::longhands::text_overflow; + + assert_roundtrip_with_context!(text_overflow::parse, r#"clip"#); + assert_roundtrip_with_context!(text_overflow::parse, r#"ellipsis"#); + assert_roundtrip_with_context!(text_overflow::parse, r#"clip ellipsis"#); + assert_roundtrip_with_context!(text_overflow::parse, r#""x""#); + assert_roundtrip_with_context!(text_overflow::parse, r#"'x'"#, r#""x""#); + assert_roundtrip_with_context!(text_overflow::parse, r#"clip "x""#); + assert_roundtrip_with_context!(text_overflow::parse, r#""x" clip"#); + assert_roundtrip_with_context!(text_overflow::parse, r#""x" "y""#); +} + +#[test] +fn test_text_overflow_parser_exhaustion() { + use style::properties::longhands::text_overflow; + + assert_parser_exhausted!(text_overflow::parse, r#"clip rubbish"#, false); + assert_parser_exhausted!(text_overflow::parse, r#"clip"#, true); + assert_parser_exhausted!(text_overflow::parse, r#"ellipsis"#, true); + assert_parser_exhausted!(text_overflow::parse, r#"clip ellipsis"#, true); +} diff --git a/servo/tests/unit/style/parsing/transition_duration.rs b/servo/tests/unit/style/parsing/transition_duration.rs new file mode 100644 index 0000000000..c771a58944 --- /dev/null +++ b/servo/tests/unit/style/parsing/transition_duration.rs @@ -0,0 +1,17 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style::properties::longhands::transition_duration; + +#[test] +fn test_positive_transition_duration() { + assert!(parse(transition_duration::parse, "5s").is_ok()); + assert!(parse(transition_duration::parse, "0s").is_ok()); +} + +#[test] +fn test_negative_transition_duration() { + assert!(parse(transition_duration::parse, "-5s").is_err()); +} diff --git a/servo/tests/unit/style/parsing/transition_timing_function.rs b/servo/tests/unit/style/parsing/transition_timing_function.rs new file mode 100644 index 0000000000..2d22f24459 --- /dev/null +++ b/servo/tests/unit/style/parsing/transition_timing_function.rs @@ -0,0 +1,37 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use parsing::parse; +use style::properties::longhands::transition_timing_function; +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)"); + + // 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(2, 0, 0, 0").is_err()); + assert!(parse(transition_timing_function::parse, "cubic-bezier(0, 0, 2, 0").is_err()); + assert!(parse(transition_timing_function::parse, "cubic-bezier(2, 0, 2, 0").is_err()); +} + +#[test] +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)"); + + // Step interval value must be an integer greater than 0 + assert!(parse(transition_timing_function::parse, "steps(0)").is_err()); + assert!(parse(transition_timing_function::parse, "steps(0.5)").is_err()); + assert!(parse(transition_timing_function::parse, "steps(-1)").is_err()); + assert!(parse(transition_timing_function::parse, "steps(1, middle)").is_err()); +} diff --git a/servo/tests/unit/style/properties/mod.rs b/servo/tests/unit/style/properties/mod.rs new file mode 100644 index 0000000000..bfb6402692 --- /dev/null +++ b/servo/tests/unit/style/properties/mod.rs @@ -0,0 +1,66 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::{Parser, ParserInput}; +use style::context::QuirksMode; +use style::parser::ParserContext; +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>> +{ + 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>>, +{ + let url = ::servo_url::ServoUrl::parse("http://localhost").unwrap(); + let context = ParserContext::new( + Origin::Author, + &url, + Some(CssRuleType::Style), + ParsingMode::DEFAULT, + QuirksMode::NoQuirks, + None, + None, + ); + let mut parser = Parser::new(input); + f(&context, &mut parser) +} + +macro_rules! assert_roundtrip_with_context { + ($fun:expr, $string:expr) => { + 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 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(); + unwrapped + }} +} + +mod scaffolding; +mod serialization; diff --git a/servo/tests/unit/style/properties/scaffolding.rs b/servo/tests/unit/style/properties/scaffolding.rs new file mode 100644 index 0000000000..7c09f51176 --- /dev/null +++ b/servo/tests/unit/style/properties/scaffolding.rs @@ -0,0 +1,59 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use serde_json::{self, Value}; +use std::env; +use std::fs::{File, remove_file}; +use std::path::Path; +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"); + 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 status = Command::new(python) + .arg(&script) + .arg("servo") + .arg("html") + .arg("regular") + .status() + .unwrap(); + assert!(status.success(), "{:?}", status); + + let properties: Value = serde_json::from_reader(File::open(json).unwrap()).unwrap(); + assert!(properties.as_object().unwrap().len() > 100); + assert!(properties.as_object().unwrap().contains_key("margin")); + assert!(properties.as_object().unwrap().contains_key("margin-top")); +} + +#[cfg(windows)] +fn find_python() -> String { + 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() { + return "python27.exe".to_owned(); + } + + if Command::new("python.exe").arg("--version").output().is_ok() { + return "python.exe".to_owned(); + } + + panic!("Can't find python (tried python27.exe and python.exe)! Try fixing PATH or setting the PYTHON env var"); +} + +#[cfg(not(windows))] +fn find_python() -> String { + if Command::new("python2.7").arg("--version").output().unwrap().status.success() { + "python2.7" + } else { + "python" + }.to_owned() +} diff --git a/servo/tests/unit/style/properties/serialization.rs b/servo/tests/unit/style/properties/serialization.rs new file mode 100644 index 0000000000..fe1d158153 --- /dev/null +++ b/servo/tests/unit/style/properties/serialization.rs @@ -0,0 +1,731 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use properties::{parse, parse_input}; +use style::computed_values::display::T as Display; +use style::properties::{PropertyDeclaration, Importance}; +use style::properties::declaration_block::PropertyDeclarationBlock; +use style::properties::parse_property_declaration_list; +use style::values::RGBA; +use style::values::specified::{BorderStyle, BorderSideWidth, Color}; +use style::values::specified::{Length, LengthPercentage, LengthPercentageOrAuto}; +use style::values::specified::NoCalcLength; +use style::values::specified::url::SpecifiedUrl; +use style_traits::ToCss; +use stylesheets::block_from; + +trait ToCssString { + fn to_css_string(&self) -> String; +} + +impl ToCssString for PropertyDeclarationBlock { + fn to_css_string(&self) -> String { + let mut css = String::new(); + self.to_css(&mut css).unwrap(); + css + } +} + +#[test] +fn property_declaration_block_should_serialize_correctly() { + use style::properties::longhands::overflow_x::SpecifiedValue as OverflowValue; + + let declarations = vec![ + (PropertyDeclaration::Width( + LengthPercentageOrAuto::Length(NoCalcLength::from_px(70f32))), + Importance::Normal), + + (PropertyDeclaration::MinHeight( + LengthPercentage::Length(NoCalcLength::from_px(20f32))), + Importance::Normal), + + (PropertyDeclaration::Height( + LengthPercentageOrAuto::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); + + let css_string = block.to_css_string(); + + assert_eq!( + css_string, + "width: 70px; min-height: 20px; height: 20px !important; display: inline-block; overflow: auto;" + ); +} + +mod shorthand_serialization { + pub use super::*; + + pub fn shorthand_properties_to_string(properties: Vec<PropertyDeclaration>) -> String { + let block = block_from(properties.into_iter().map(|d| (d, Importance::Normal))); + + block.to_css_string() + } + + mod four_sides_shorthands { + pub use super::*; + + // we can use margin as a base to test out the different combinations + // but afterwards, we only need to to one test per "four sides shorthand" + #[test] + fn all_equal_properties_should_serialize_to_one_value() { + let mut properties = Vec::new(); + + let px_70 = LengthPercentageOrAuto::Length(NoCalcLength::from_px(70f32)); + properties.push(PropertyDeclaration::MarginTop(px_70.clone())); + properties.push(PropertyDeclaration::MarginRight(px_70.clone())); + properties.push(PropertyDeclaration::MarginBottom(px_70.clone())); + properties.push(PropertyDeclaration::MarginLeft(px_70)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "margin: 70px;"); + } + + #[test] + fn equal_vertical_and_equal_horizontal_properties_should_serialize_to_two_value() { + let mut properties = Vec::new(); + + let vertical_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(10f32)); + let horizontal_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(5f32)); + + properties.push(PropertyDeclaration::MarginTop(vertical_px.clone())); + properties.push(PropertyDeclaration::MarginRight(horizontal_px.clone())); + properties.push(PropertyDeclaration::MarginBottom(vertical_px)); + properties.push(PropertyDeclaration::MarginLeft(horizontal_px)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "margin: 10px 5px;"); + } + + #[test] + fn different_vertical_and_equal_horizontal_properties_should_serialize_to_three_values() { + let mut properties = Vec::new(); + + let top_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(8f32)); + let bottom_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(10f32)); + let horizontal_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(5f32)); + + properties.push(PropertyDeclaration::MarginTop(top_px)); + properties.push(PropertyDeclaration::MarginRight(horizontal_px.clone())); + properties.push(PropertyDeclaration::MarginBottom(bottom_px)); + properties.push(PropertyDeclaration::MarginLeft(horizontal_px)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "margin: 8px 5px 10px;"); + } + + #[test] + fn different_properties_should_serialize_to_four_values() { + let mut properties = Vec::new(); + + let top_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(8f32)); + let right_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(12f32)); + let bottom_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(10f32)); + let left_px = LengthPercentageOrAuto::Length(NoCalcLength::from_px(14f32)); + + properties.push(PropertyDeclaration::MarginTop(top_px)); + properties.push(PropertyDeclaration::MarginRight(right_px)); + properties.push(PropertyDeclaration::MarginBottom(bottom_px)); + properties.push(PropertyDeclaration::MarginLeft(left_px)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "margin: 8px 12px 10px 14px;"); + } + + #[test] + fn different_longhands_should_serialize_to_long_form() { + let mut properties = Vec::new(); + + 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())); + + 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())); + + 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())); + + 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 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())); + + 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())); + + 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())); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-style: solid; border-width: 30px; border-color: rgb(0, 0, 255);"); + } + + #[test] + fn padding_should_serialize_correctly() { + use style::values::specified::NonNegativeLengthPercentage; + + let mut properties = Vec::new(); + + let px_10: NonNegativeLengthPercentage = NoCalcLength::from_px(10f32).into(); + let px_15: NonNegativeLengthPercentage = NoCalcLength::from_px(15f32).into(); + properties.push(PropertyDeclaration::PaddingTop(px_10.clone())); + properties.push(PropertyDeclaration::PaddingRight(px_15.clone())); + properties.push(PropertyDeclaration::PaddingBottom(px_10)); + properties.push(PropertyDeclaration::PaddingLeft(px_15)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "padding: 10px 15px;"); + } + + #[test] + fn border_width_should_serialize_correctly() { + let mut properties = Vec::new(); + + let top_px = BorderSideWidth::Length(Length::from_px(10f32)); + let bottom_px = BorderSideWidth::Length(Length::from_px(10f32)); + + let right_px = BorderSideWidth::Length(Length::from_px(15f32)); + let left_px = BorderSideWidth::Length(Length::from_px(15f32)); + + properties.push(PropertyDeclaration::BorderTopWidth(top_px)); + properties.push(PropertyDeclaration::BorderRightWidth(right_px)); + properties.push(PropertyDeclaration::BorderBottomWidth(bottom_px)); + properties.push(PropertyDeclaration::BorderLeftWidth(left_px)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-width: 10px 15px;"); + } + + #[test] + fn border_width_with_keywords_should_serialize_correctly() { + let mut properties = Vec::new(); + + let top_px = BorderSideWidth::Thin; + let right_px = BorderSideWidth::Medium; + let bottom_px = BorderSideWidth::Thick; + let left_px = BorderSideWidth::Length(Length::from_px(15f32)); + + properties.push(PropertyDeclaration::BorderTopWidth(top_px)); + properties.push(PropertyDeclaration::BorderRightWidth(right_px)); + properties.push(PropertyDeclaration::BorderBottomWidth(bottom_px)); + properties.push(PropertyDeclaration::BorderLeftWidth(left_px)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-width: thin medium thick 15px;"); + } + + #[test] + fn border_color_should_serialize_correctly() { + let mut properties = Vec::new(); + + let red = Color::rgba(RGBA::new(255, 0, 0, 255)); + let blue = Color::rgba(RGBA::new(0, 0, 255, 255)); + + properties.push(PropertyDeclaration::BorderTopColor(blue.clone())); + properties.push(PropertyDeclaration::BorderRightColor(red.clone())); + properties.push(PropertyDeclaration::BorderBottomColor(blue)); + properties.push(PropertyDeclaration::BorderLeftColor(red)); + + 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);"); + } + + #[test] + fn border_style_should_serialize_correctly() { + let mut properties = Vec::new(); + + let solid = BorderStyle::Solid; + let dotted = BorderStyle::Dotted; + properties.push(PropertyDeclaration::BorderTopStyle(solid.clone())); + properties.push(PropertyDeclaration::BorderRightStyle(dotted.clone())); + properties.push(PropertyDeclaration::BorderBottomStyle(solid)); + properties.push(PropertyDeclaration::BorderLeftStyle(dotted)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-style: solid dotted;"); + } + + use style::values::specified::{BorderCornerRadius, Percentage}; + + #[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() + )))); + + 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::BorderTopStyle(BorderStyle::Solid)); + let c = Color::Numeric { + parsed: RGBA::new(255, 0, 0, 255), + 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()) + }; + properties.push(PropertyDeclaration::BorderTopColor(c.clone())); + properties.push(PropertyDeclaration::BorderBottomColor(c.clone())); + properties.push(PropertyDeclaration::BorderLeftColor(c.clone())); + properties.push(PropertyDeclaration::BorderRightColor(c.clone())); + + let serialization = shorthand_properties_to_string(properties); + 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 { + parsed: RGBA::new(0, 255, 0, 255), + 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::BorderTopStyle(BorderStyle::Solid)); + let c = Color::Numeric { + parsed: RGBA::new(255, 0, 0, 255), + 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;"); + } + + // we can use border-top as a base to test out the different combinations + // but afterwards, we only need to to one test per "directional border shorthand" + + #[test] + fn directional_border_should_show_all_properties_when_values_are_set() { + let mut properties = Vec::new(); + + let width = BorderSideWidth::Length(Length::from_px(4f32)); + let style = BorderStyle::Solid; + let color = RGBA::new(255, 0, 0, 255).into(); + + properties.push(PropertyDeclaration::BorderTopWidth(width)); + properties.push(PropertyDeclaration::BorderTopStyle(style)); + properties.push(PropertyDeclaration::BorderTopColor(color)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-top: 4px solid rgb(255, 0, 0);"); + } + + fn get_border_property_values() -> (BorderSideWidth, BorderStyle, Color) { + (BorderSideWidth::Length(Length::from_px(4f32)), + BorderStyle::Solid, + Color::currentcolor()) + } + + #[test] + fn border_top_should_serialize_correctly() { + let mut properties = Vec::new(); + let (width, style, color) = get_border_property_values(); + properties.push(PropertyDeclaration::BorderTopWidth(width)); + properties.push(PropertyDeclaration::BorderTopStyle(style)); + properties.push(PropertyDeclaration::BorderTopColor(color)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-top: 4px solid;"); + } + + #[test] + fn border_right_should_serialize_correctly() { + let mut properties = Vec::new(); + let (width, style, color) = get_border_property_values(); + properties.push(PropertyDeclaration::BorderRightWidth(width)); + properties.push(PropertyDeclaration::BorderRightStyle(style)); + properties.push(PropertyDeclaration::BorderRightColor(color)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-right: 4px solid;"); + } + + #[test] + fn border_bottom_should_serialize_correctly() { + let mut properties = Vec::new(); + let (width, style, color) = get_border_property_values(); + properties.push(PropertyDeclaration::BorderBottomWidth(width)); + properties.push(PropertyDeclaration::BorderBottomStyle(style)); + properties.push(PropertyDeclaration::BorderBottomColor(color)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-bottom: 4px solid;"); + } + + #[test] + fn border_left_should_serialize_correctly() { + let mut properties = Vec::new(); + let (width, style, color) = get_border_property_values(); + properties.push(PropertyDeclaration::BorderLeftWidth(width)); + properties.push(PropertyDeclaration::BorderLeftStyle(style)); + properties.push(PropertyDeclaration::BorderLeftColor(color)); + + let serialization = shorthand_properties_to_string(properties); + assert_eq!(serialization, "border-left: 4px solid;"); + } + + #[test] + fn border_should_serialize_correctly() { + // According to https://drafts.csswg.org/css-backgrounds-3/#the-border-shorthands, + // 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;"; + + let block = parse(|c, i| Ok(parse_property_declaration_list(c, i)), block_text).unwrap(); + + let serialization = block.to_css_string(); + + assert_eq!(serialization, "border: 4px solid;"); + } + } + + mod background { + use super::*; + + #[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;"; + + 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;" + ); + } + + #[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;"; + + 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;" + ); + } + + #[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;"; + + 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: \ + url(\"http://servo/test.png\") repeat-x scroll 7px 4px / 70px 50px border-box padding-box, \ + rgb(0, 0, 255) none repeat-y scroll 70px 40px / 20px 30px padding-box;" + ); + } + + #[test] + fn serialize_multiple_backgrounds_unequal_property_lists() { + // When the lengths of property values are different, the shorthand serialization + // should not be used. Previously the implementation cycled values if the lists were + // uneven. This is incorrect, in that we should serialize to a shorthand only when the + // lists have the same length (this affects background, transition and animation). + // https://github.com/servo/servo/issues/15398 ) + // With background, the color is one exception as it should only appear once for + // 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;"; + + 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); + } + + #[test] + fn background_position_should_be_a_valid_form_its_longhands() { + // 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(); + 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(); + let serialization = block.to_css_string(); + assert_eq!(serialization, "background-position: center 20px;"); + } + } + + mod quotes { + pub use super::*; + + #[test] + fn should_serialize_none_correctly() { + use style::properties::longhands::quotes; + + assert_roundtrip_with_context!(quotes::parse, "none"); + } + } + + mod animation { + pub use super::*; + + #[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;"; + + 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;") + } + + #[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;"; + + 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;"); + } + + #[test] + fn serialize_multiple_animations_unequal_property_lists() { + // When the lengths of property values are different, the shorthand serialization + // should not be used. Previously the implementation cycled values if the lists were + // uneven. This is incorrect, in that we should serialize to a shorthand only when the + // 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;"; + + 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); + } + + #[test] + fn serialize_multiple_without_all_properties_returns_longhand() { + // timing function and direction are missing, so no shorthand is returned. + let block_text = "animation-name: bounce, roll; \ + animation-duration: 1s, 0.2s; \ + animation-delay: 0s, 1s; \ + 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 serialization = block.to_css_string(); + + assert_eq!(serialization, block_text); + } + } + + mod keywords { + pub use super::*; + #[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 serialization = block.to_css_string(); + assert_eq!(serialization, "--a: inherit;"); + } + + #[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 serialization = block.to_css_string(); + assert_eq!(serialization, block_text); + } + } + + mod effects { + pub use super::*; + pub use style::properties::longhands::box_shadow::SpecifiedValue as BoxShadowList; + pub use style::values::specified::effects::{BoxShadow, SimpleShadow}; + + #[test] + fn box_shadow_should_serialize_correctly() { + use style::values::specified::length::NonNegativeLength; + + let mut properties = Vec::new(); + let shadow_val = BoxShadow { + base: SimpleShadow { + color: None, + horizontal: Length::from_px(1f32), + vertical: Length::from_px(2f32), + blur: Some(NonNegativeLength::from_px(3f32)), + }, + spread: Some(Length::from_px(4f32)), + inset: false, + }; + 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(); + + assert_eq!(shadow.to_css_string(), shadow_css); + } + } +} diff --git a/servo/tests/unit/style/rule_tree/bench.rs b/servo/tests/unit/style/rule_tree/bench.rs new file mode 100644 index 0000000000..d7b024a1b4 --- /dev/null +++ b/servo/tests/unit/style/rule_tree/bench.rs @@ -0,0 +1,214 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::SourceLocation; +use rayon; +use servo_arc::Arc; +use servo_url::ServoUrl; +use style::context::QuirksMode; +use style::error_reporting::{ParseErrorReporter, ContextualParseError}; +use style::media_queries::MediaList; +use style::properties::{longhands, Importance, PropertyDeclaration, PropertyDeclarationBlock}; +use style::rule_tree::{CascadeLevel, RuleTree, StrongRuleNode, StyleSource}; +use style::shared_lock::SharedRwLock; +use style::stylesheets::{Origin, Stylesheet, CssRule}; +use style::thread_state::{self, ThreadState}; +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); + } +} + +struct AutoGCRuleTree<'a>(&'a RuleTree); + +impl<'a> AutoGCRuleTree<'a> { + fn new(r: &'a RuleTree) -> Self { + AutoGCRuleTree(r) + } +} + +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!"); + } + } +} + +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 guard = s.shared_lock.read(); + let rules = s.contents.rules.read_with(&guard); + rules.0.iter().filter_map(|rule| { + match *rule { + CssRule::Style(ref style_rule) => Some(( + StyleSource::from_rule(style_rule.clone()), + CascadeLevel::UserNormal, + )), + _ => None, + } + }).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 { + 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)); + test_insertion(rule_tree, rules) +} + +#[bench] +fn bench_insertion_basic(b: &mut Bencher) { + let r = RuleTree::new(); + thread_state::initialize(ThreadState::SCRIPT); + + let rules_matched = parse_rules( + ".foo { width: 200px; } \ + .bar { height: 500px; } \ + .baz { display: block; }"); + + b.iter(|| { + let _gc = AutoGCRuleTree::new(&r); + + for _ in 0..(4000 + 400) { + test::black_box(test_insertion(&r, rules_matched.clone())); + } + }) +} + +#[bench] +fn bench_insertion_basic_per_element(b: &mut Bencher) { + let r = RuleTree::new(); + thread_state::initialize(ThreadState::SCRIPT); + + let rules_matched = parse_rules( + ".foo { width: 200px; } \ + .bar { height: 500px; } \ + .baz { display: block; }"); + + b.iter(|| { + let _gc = AutoGCRuleTree::new(&r); + + test::black_box(test_insertion(&r, rules_matched.clone())); + }); +} + +#[bench] +fn bench_expensive_insertion(b: &mut Bencher) { + let r = RuleTree::new(); + thread_state::initialize(ThreadState::SCRIPT); + + // This test case tests a case where you style a bunch of siblings + // matching the same rules, with a different style attribute each + // one. + let rules_matched = parse_rules( + ".foo { width: 200px; } \ + .bar { height: 500px; } \ + .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)); + } + }); +} + +#[bench] +fn bench_insertion_basic_parallel(b: &mut Bencher) { + let r = RuleTree::new(); + thread_state::initialize(ThreadState::SCRIPT); + + let rules_matched = parse_rules( + ".foo { width: 200px; } \ + .bar { height: 500px; } \ + .baz { display: block; }"); + + b.iter(|| { + let _gc = AutoGCRuleTree::new(&r); + + rayon::scope(|s| { + for _ in 0..4 { + s.spawn(|s| { + for _ in 0..1000 { + test::black_box(test_insertion(&r, + rules_matched.clone())); + } + s.spawn(|_| { + for _ in 0..100 { + test::black_box(test_insertion(&r, + rules_matched.clone())); + } + }) + }) + } + }); + }); +} + +#[bench] +fn bench_expensive_insertion_parallel(b: &mut Bencher) { + let r = RuleTree::new(); + thread_state::initialize(ThreadState::SCRIPT); + + let rules_matched = parse_rules( + ".foo { width: 200px; } \ + .bar { height: 500px; } \ + .baz { display: block; }"); + + let shared_lock = SharedRwLock::new(); + b.iter(|| { + let _gc = AutoGCRuleTree::new(&r); + + rayon::scope(|s| { + for _ in 0..4 { + s.spawn(|s| { + for _ in 0..1000 { + 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)); + } + }) + }) + } + }); + }); +} diff --git a/servo/tests/unit/style/rule_tree/mod.rs b/servo/tests/unit/style/rule_tree/mod.rs new file mode 100644 index 0000000000..6370d2640c --- /dev/null +++ b/servo/tests/unit/style/rule_tree/mod.rs @@ -0,0 +1,5 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +mod bench; diff --git a/servo/tests/unit/style/size_of.rs b/servo/tests/unit/style/size_of.rs new file mode 100644 index 0000000000..744d3596ac --- /dev/null +++ b/servo/tests/unit/style/size_of.rs @@ -0,0 +1,23 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use selectors::parser::{SelectorParseError, SelectorParseErrorKind}; +use style::invalidation::element::invalidation_map::Dependency; +use style::properties; + +size_of_test!(test_size_of_dependency, Dependency, 16); + +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_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); diff --git a/servo/tests/unit/style/str.rs b/servo/tests/unit/style/str.rs new file mode 100644 index 0000000000..149b3f231f --- /dev/null +++ b/servo/tests/unit/style/str.rs @@ -0,0 +1,46 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +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()); +} + +#[test] +pub fn test_str_join_empty() { + let slice: [&str; 0] = []; + let actual = str_join(&slice, "-"); + let expected = ""; + assert_eq!(actual, expected); +} + +#[test] +pub fn test_str_join_one() { + let slice = ["alpha"]; + let actual = str_join(&slice, "-"); + let expected = "alpha"; + assert_eq!(actual, expected); +} + +#[test] +pub fn test_str_join_many() { + let slice = ["", "alpha", "", "beta", "gamma", ""]; + let actual = str_join(&slice, "-"); + let expected = "-alpha--beta-gamma-"; + assert_eq!(actual, expected); +} + +#[test] +pub fn test_starts_with_ignore_ascii_case_basic() { + assert!(starts_with_ignore_ascii_case("-webkit-", "-webkit-")); + assert!(starts_with_ignore_ascii_case("-webkit-foo", "-webkit-")); +} + +#[test] +pub fn test_starts_with_ignore_ascii_case_char_boundary() { + assert!(!starts_with_ignore_ascii_case("aaaaa💩", "-webkit-")); +} diff --git a/servo/tests/unit/style/stylesheets.rs b/servo/tests/unit/style/stylesheets.rs new file mode 100644 index 0000000000..e612a39d11 --- /dev/null +++ b/servo/tests/unit/style/stylesheets.rs @@ -0,0 +1,431 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::{self, SourceLocation}; +use html5ever::{Namespace as NsAtom}; +use parking_lot::RwLock; +use selectors::attr::*; +use selectors::parser::*; +use servo_arc::Arc; +use servo_atoms::Atom; +use servo_config::prefs::{PREFS, PrefValue}; +use servo_url::ServoUrl; +use std::borrow::ToOwned; +use std::cell::RefCell; +use std::sync::atomic::AtomicBool; +use style::context::QuirksMode; +use style::error_reporting::{ParseErrorReporter, ContextualParseError}; +use style::media_queries::MediaList; +use style::properties::{CSSWideKeyword, CustomDeclaration}; +use style::properties::{CustomDeclarationValue, Importance}; +use style::properties::{PropertyDeclaration, PropertyDeclarationBlock}; +use style::properties::longhands::{self, animation_timing_function}; +use style::shared_lock::SharedRwLock; +use style::stylesheets::{Origin, Namespaces}; +use style::stylesheets::{Stylesheet, StylesheetContents, NamespaceRule, CssRule, CssRules, StyleRule, KeyframesRule}; +use style::stylesheets::keyframes_rule::{Keyframe, KeyframeSelector, KeyframePercentage}; +use style::values::{KeyframesName, CustomIdent}; +use style::values::computed::Percentage; +use style::values::specified::{LengthPercentageOrAuto, PositionComponent}; +use style::values::specified::TimingFunction; + +pub fn block_from<I>(iterable: I) -> PropertyDeclarationBlock +where I: IntoIterator<Item=(PropertyDeclaration, Importance)> { + let mut block = PropertyDeclarationBlock::new(); + for (d, i) in iterable { + block.push(d, i); + } + block +} + +#[test] +fn test_parse_stylesheet() { + let css = r" + @namespace url(http://www.w3.org/1999/xhtml); + /* FIXME: only if scripting is enabled */ + input[type=hidden i] { + display: block !important; + display: none !important; + display: inline; + --a: b !important; + --a: inherit !important; + --a: c; + } + html , body /**/ { + display: none; + display: block; + } + #d1 > .ok { background: blue; } + @keyframes foo { + from { width: 0% } + to { + width: 100%; + width: 50% !important; /* !important not allowed here */ + animation-name: 'foo'; /* animation properties not allowed here */ + animation-timing-function: ease; /* … except animation-timing-function */ + } + }"; + 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 mut namespaces = Namespaces::default(); + namespaces.default = Some(ns!(html)); + let expected = Stylesheet { + contents: StylesheetContents { + origin: Origin::UserAgent, + 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")), + 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( + LengthPercentageOrAuto::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( + LengthPercentageOrAuto::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), + }, + media: Arc::new(stylesheet.shared_lock.wrap(MediaList::empty())), + shared_lock: stylesheet.shared_lock.clone(), + disabled: AtomicBool::new(false), + }; + + assert_eq!(format!("{:#?}", stylesheet), format!("{:#?}", expected)); +} + +#[derive(Debug)] +struct CSSError { + pub url : ServoUrl, + pub line: u32, + pub column: u32, + pub message: String +} + +struct TestingErrorReporter { + errors: RefCell<Vec<CSSError>>, +} + +impl TestingErrorReporter { + pub fn new() -> Self { + TestingErrorReporter { + errors: RefCell::new(Vec::new()), + } + } + + 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); + } + if errors.len() < expected_errors.len() { + panic!("Missing errors: {:#?}", &expected_errors[errors.len()..]); + } + if errors.len() > expected_errors.len() { + panic!("Extra errors: {:#?}", &errors[expected_errors.len()..]); + } + } +} + +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(), + } + ) + } +} + + +#[test] +fn test_report_error_stylesheet() { + PREFS.set("layout.viewport.enabled", PrefValue::Boolean(true)); + let css = r" + div { + background-color: red; + display: invalid; + background-image: linear-gradient(0deg, black, invalid, transparent); + invalid: true; + } + @media (min-width: 10px invalid 1000px) {} + @font-face { src: url(), invalid, url(); } + @counter-style foo { symbols: a 0invalid b } + @font-feature-values Sans Sans { @foo {} @swash { foo: 1 invalid 2 } } + @invalid; + @media screen { @invalid; } + @supports (color: green) and invalid and (margin: 0) {} + @keyframes foo { from invalid {} to { margin: 0 invalid 0; } } + @viewport { width: 320px invalid auto; } + "; + let url = ServoUrl::parse("about::test").unwrap(); + let error_reporter = TestingErrorReporter::new(); + + 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); + + 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 + (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;'"), + ]); + + assert_eq!(error_reporter.errors.borrow()[0].url, url); +} + +#[test] +fn test_no_report_unrecognized_vendor_properties() { + let css = r" + div { + -o-background-color: red; + _background-color: red; + -moz-background-color: red; + } + "; + let url = ServoUrl::parse("about::test").unwrap(); + let error_reporter = TestingErrorReporter::new(); + + 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); + + 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())), + ]; + + 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 url_opt = stylesheet.contents.source_map_url.read(); + assert_eq!(*url_opt, test.1); + } +} + +#[test] +fn test_source_url() { + let tests = vec![ + ("", None), + ("/*# sourceURL=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 url_opt = stylesheet.contents.source_url.read(); + assert_eq!(*url_opt, test.1); + } +} diff --git a/servo/tests/unit/style/stylist.rs b/servo/tests/unit/style/stylist.rs new file mode 100644 index 0000000000..5a4d3be244 --- /dev/null +++ b/servo/tests/unit/style/stylist.rs @@ -0,0 +1,201 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::SourceLocation; +use euclid::Scale; +use euclid::Size2D; +use selectors::parser::{AncestorHashes, Selector}; +use servo_arc::Arc; +use servo_atoms::Atom; +use style::context::QuirksMode; +use style::media_queries::{Device, MediaType}; +use style::properties::{PropertyDeclarationBlock, PropertyDeclaration}; +use style::properties::{longhands, Importance}; +use style::selector_map::SelectorMap; +use style::selector_parser::{SelectorImpl, SelectorParser}; +use style::shared_lock::SharedRwLock; +use style::stylesheets::StyleRule; +use style::stylist::{Stylist, Rule}; +use style::stylist::needs_revalidation_for_testing; +use style::thread_state::{self, ThreadState}; + +/// Helper method to get some Rules from selector strings. +/// 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(); + + 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) +} + +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() +} + +#[test] +fn test_revalidation_selectors() { + let test = parse_selectors(&[ + // Not revalidation selectors. + "div", + "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. + + // Attribute selectors. + "div[foo]", + "div:not([foo])", + "div[foo = \"bar\"]", + "div[foo ~= \"bar\"]", + "div[foo |= \"bar\"]", + "div[foo ^= \"bar\"]", + "div[foo $= \"bar\"]", + "div[foo *= \"bar\"]", + "*|div[foo][bar = \"baz\"]", + + // Non-state-based pseudo-classes. + "div:empty", + "div:first-child", + "div:last-child", + "div:only-child", + "div:nth-child(2)", + "div:nth-last-child(2)", + "div:nth-of-type(2)", + "div:nth-last-of-type(2)", + "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. :-( + + // 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<_>>(); + + let reference = parse_selectors(&[ + // ID selectors. + "#foo3 > span", + "#foo1 > span", + + // Attribute selectors. + "div[foo]", + "div:not([foo])", + "div[foo = \"bar\"]", + "div[foo ~= \"bar\"]", + "div[foo |= \"bar\"]", + "div[foo ^= \"bar\"]", + "div[foo $= \"bar\"]", + "div[foo *= \"bar\"]", + "*|div[foo][bar = \"baz\"]", + + // Non-state-based pseudo-classes. + "div:empty", + "div:first-child", + "div:last-child", + "div:only-child", + "div:nth-child(2)", + "div:nth-last-child(2)", + "div:nth-of-type(2)", + "div:nth-last-of-type(2)", + "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<_>>(); + + assert_eq!(test.len(), reference.len()); + for (t, r) in test.into_iter().zip(reference.into_iter()) { + assert_eq!(t, r) + } +} + +#[test] +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."); +} + +#[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()); +} + +fn mock_stylist() -> Stylist { + let device = Device::new(MediaType::screen(), Size2D::new(0f32, 0f32), Scale::new(1.0)); + Stylist::new(device, QuirksMode::NoQuirks) +} + +#[test] +fn test_stylist_device_accessors() { + thread_state::initialize(ThreadState::LAYOUT); + let stylist = mock_stylist(); + assert_eq!(stylist.device().media_type(), MediaType::screen()); + let mut stylist_mut = mock_stylist(); + assert_eq!(stylist_mut.device_mut().media_type(), MediaType::screen()); +} + +#[test] +fn test_stylist_rule_tree_accessors() { + thread_state::initialize(ThreadState::LAYOUT); + let stylist = mock_stylist(); + stylist.rule_tree(); + stylist.rule_tree().root(); +} diff --git a/servo/tests/unit/style/viewport.rs b/servo/tests/unit/style/viewport.rs new file mode 100644 index 0000000000..432f931329 --- /dev/null +++ b/servo/tests/unit/style/viewport.rs @@ -0,0 +1,383 @@ +/* This Source Code Form is subject to the terms of the Mozilla Public + * License, v. 2.0. If a copy of the MPL was not distributed with this + * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ + +use cssparser::{Parser, ParserInput}; +use euclid::Scale; +use euclid::Size2D; +use servo_arc::Arc; +use servo_config::prefs::{PREFS, PrefValue}; +use servo_url::ServoUrl; +use style::context::QuirksMode; +use style::media_queries::{Device, MediaList, MediaType}; +use style::parser::ParserContext; +use style::shared_lock::{SharedRwLock, StylesheetGuards}; +use style::stylesheets::{CssRuleType, Stylesheet, StylesheetInDocument, Origin}; +use style::stylesheets::viewport_rule::*; +use style::values::specified::LengthPercentageOrAuto::{self, Auto}; +use style::values::specified::NoCalcLength::{self, ViewportPercentage}; +use style::values::specified::ViewportPercentageLength::Vw; +use style_traits::{ParsingMode, PinchZoomFactor}; +use style_traits::viewport::*; + +macro_rules! stylesheet { + ($css:expr, $origin:ident) => { + stylesheet!($css, $origin, SharedRwLock::new()) + }; + ($css:expr, $origin:ident, $shared_lock:expr) => { + Arc::new(Stylesheet::from_str( + $css, + ServoUrl::parse("http://localhost").unwrap(), + Origin::$origin, + Arc::new($shared_lock.wrap(MediaList::empty())), + $shared_lock, + None, + None, + QuirksMode::NoQuirks, + 0 + )) + } +} + +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); + let mut rule_count = 0; + stylesheet.effective_viewport_rules(&device, &stylesheet.shared_lock.read(), |rule| { + rule_count += 1; + callback(&rule.declarations, css); + }); + assert!(rule_count > 0); +} + +fn test_meta_viewport<F>(meta: &str, callback: F) + 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 + // sort them in a stable order for the tests + rule.declarations.sort_by(|a, b| { + let a = a.descriptor.discriminant_value(); + let b = b.descriptor.discriminant_value(); + a.cmp(&b) + }); + + callback(&rule.declarations, meta); + } else { + panic!("no @viewport rule for {}", meta); + } +} + +macro_rules! assert_decl_len { + ($declarations:ident == 1) => { + 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) + } +} + +macro_rules! viewport_length { + ($value:expr, px) => { + ViewportLength::Specified(LengthPercentageOrAuto::Length(NoCalcLength::from_px($value))) + }; + ($value:expr, vw) => { + ViewportLength::Specified(LengthPercentageOrAuto::Length(ViewportPercentage(Vw($value)))) + } +} + +#[test] +fn empty_viewport_rule() { + let device = Device::new(MediaType::screen(), Size2D::new(800., 600.), Scale::new(1.0)); + + test_viewport_rule("@viewport {}", &device, |declarations, css| { + println!("{}", css); + assert_decl_len!(declarations == 0); + }); +} + +macro_rules! assert_decl_eq { + ($d:expr, $origin:ident, $expected:ident: $value:expr) => {{ + assert_eq!($d.origin, Origin::$origin); + assert_eq!($d.descriptor, ViewportDescriptor::$expected($value)); + assert_eq!($d.important, false, "descriptor should not be !important"); + }}; + ($d:expr, $origin:ident, $expected:ident: $value:expr, !important) => {{ + assert_eq!($d.origin, Origin::$origin); + assert_eq!($d.descriptor, ViewportDescriptor::$expected($value)); + assert_eq!($d.important, true, "descriptor should be !important"); + }}; +} + +#[test] +fn simple_viewport_rules() { + let device = Device::new(MediaType::screen(), Size2D::new(800., 600.), Scale::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 { 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] +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)); + }); + + 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[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("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(), Size2D::new(800., 600.), Scale::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)); + }); + + // !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); + }); + + // !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); + }); + + // 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)); + }); + + // 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)); + }); + + // 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)); + }); + + // 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] +fn multiple_stylesheets_cascading() { + PREFS.set("layout.viewport.enabled", PrefValue::Boolean(true)); + let device = Device::new(MediaType::screen(), Size2D::new(800., 600.), Scale::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()) + ]; + + let declarations = Cascade::from_stylesheets( + stylesheets.iter().map(|s| (&**s, Origin::Author)), + &StylesheetGuards::same(&shared_lock.read()), + &device, + ).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)); + + let stylesheets = vec![ + stylesheet!("@viewport { min-width: 100px !important; }", + UserAgent, shared_lock.clone()), + stylesheet!("@viewport { min-width: 200px !important; min-height: 200px !important; }", + User, shared_lock.clone()), + stylesheet!("@viewport { min-width: 300px !important; min-height: 300px !important; zoom: 3 !important; }", + Author, shared_lock.clone()) + ]; + let declarations = Cascade::from_stylesheets( + stylesheets.iter().map(|s| (&**s, Origin::Author)), + &StylesheetGuards::same(&shared_lock.read()), + &device, + ).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[2], Author, Zoom: Zoom::Number(3.), !important); +} + +#[test] +fn constrain_viewport() { + let url = ServoUrl::parse("http://localhost").unwrap(); + let context = ParserContext::new( + Origin::Author, + &url, + Some(CssRuleType::Viewport), + ParsingMode::DEFAULT, + QuirksMode::NoQuirks, + None, + None, + ); + + macro_rules! from_css { + ($css:expr) => { + &ViewportRule::parse(&context, &mut Parser::new(&mut $css)).unwrap() + } + } + + let initial_viewport = Size2D::new(800., 600.); + let device = Device::new(MediaType::screen(), initial_viewport, Scale::new(1.0)); + let mut input = ParserInput::new(""); + 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, + + initial_zoom: PinchZoomFactor::new(1.), + min_zoom: None, + max_zoom: None, + + 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, + + initial_zoom: PinchZoomFactor::new(1.), + min_zoom: None, + max_zoom: None, + + 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, + + initial_zoom: PinchZoomFactor::new(1.), + min_zoom: None, + max_zoom: None, + + user_zoom: UserZoom::Zoom, + orientation: Orientation::Auto + })); + + let initial_viewport = Size2D::new(200., 150.); + let device = Device::new(MediaType::screen(), initial_viewport, Scale::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: Size2D::new(320., 240.), + + initial_zoom: PinchZoomFactor::new(1.), + min_zoom: None, + max_zoom: None, + + user_zoom: UserZoom::Zoom, + orientation: Orientation::Auto + })); +} |