mirror of
https://github.com/servo/servo.git
synced 2025-06-24 00:54:32 +01:00
5b36d211b4
2020, not yet wired to the rest of layout. This commit implements an object that handles the 10 rules in CSS 2.1: https://www.w3.org/TR/CSS2/visuren.html#float-position The implementation strategy is that of a persistent balanced binary search tree of float bands. Binary search trees are commonly used for implementing float positioning; e.g. by WebKit. Persistence enables each object that interacts with floats to efficiently contain a snapshot of the float list at the time that object was laid out. That way, incremental layout can invalidate and start reflow at any point in a containing block. This commit features extensive use of [QuickCheck](https://github.com/BurntSushi/quickcheck) to ensure that the rules of the CSS specification are followed. Because this is not yet connected to layout, floats will not actually be laid out in Web pages yet. Note that unit tests as set up in Servo currently require types that they access to be public. Therefore, some internal layout 2020 types that were previously private have been made public. This is somewhat unfortunate. Part of #25167.
133 lines
4.1 KiB
Rust
133 lines
4.1 KiB
Rust
/* 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::{ParseError, ParsingMode};
|
|
|
|
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)
|
|
}
|
|
|
|
// 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 box_;
|
|
mod effects;
|
|
mod image;
|
|
mod inherited_text;
|
|
mod outline;
|
|
mod selectors;
|
|
mod supports;
|
|
mod transition_duration;
|
|
mod transition_timing_function;
|
|
|
|
// These tests test features that are only available in 2013 layout.
|
|
#[cfg(feature = "layout_2013")]
|
|
mod background;
|
|
#[cfg(feature = "layout_2013")]
|
|
mod border;
|
|
#[cfg(feature = "layout_2013")]
|
|
mod column;
|
|
#[cfg(feature = "layout_2013")]
|
|
mod text_overflow;
|