diff options
247 files changed, 7490 insertions, 6243 deletions
diff --git a/Cargo.lock b/Cargo.lock index f4a32a14a0f..2f8ab0361fa 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2022,7 +2022,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "976dd42dc7e85965fe702eb8164f21f450704bdde31faefd6471dba214cb594e" dependencies = [ "libc", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -2548,7 +2548,7 @@ dependencies = [ "gobject-sys", "libc", "system-deps", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -3094,9 +3094,9 @@ dependencies = [ [[package]] name = "hashbrown" -version = "0.15.2" +version = "0.15.3" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" +checksum = "84b26c544d002229e640969970a2e74021aadf6e2f96372b9c58eff97de08eb3" dependencies = [ "foldhash", "serde", @@ -3990,7 +3990,7 @@ checksum = "e04d7f318608d35d4b61ddd75cbdaee86b023ebe2bd5a66ee0915f0bf93095a9" dependencies = [ "hermit-abi 0.5.0", "libc", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -4243,7 +4243,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "fc2f4eb4bc735547cfed7c0a4922cbd04a4655978c09b54f1f7b228750664c34" dependencies = [ "cfg-if", - "windows-targets 0.48.5", + "windows-targets 0.52.6", ] [[package]] @@ -5467,7 +5467,7 @@ dependencies = [ [[package]] name = "peek-poke" version = "0.3.0" -source = "git+https://github.com/servo/webrender?branch=0.66#88462530746749163bcf1dc89be20a19f2394e71" +source = "git+https://github.com/servo/webrender?branch=0.67#ae2477d9a6da403e5b5dce8a17415a2cd1563074" dependencies = [ "euclid", "peek-poke-derive", @@ -5476,13 +5476,12 @@ dependencies = [ [[package]] name = "peek-poke-derive" version = "0.3.0" -source = "git+https://github.com/servo/webrender?branch=0.66#88462530746749163bcf1dc89be20a19f2394e71" +source = "git+https://github.com/servo/webrender?branch=0.67#ae2477d9a6da403e5b5dce8a17415a2cd1563074" dependencies = [ "proc-macro2", "quote", "syn", "synstructure", - "unicode-xid", ] [[package]] @@ -6082,14 +6081,15 @@ dependencies = [ [[package]] name = "ron" -version = "0.8.1" +version = "0.10.1" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "b91f7eff05f748767f183df4320a63d6936e9c6107d97c9e6bdd9784f4289c94" +checksum = "beceb6f7bf81c73e73aeef6dd1356d9a1b2b4909e1f0fc3e59b034f9572d7b7f" dependencies = [ - "base64 0.21.7", + "base64 0.22.1", "bitflags 2.9.0", "serde", "serde_derive", + "unicode-ident", ] [[package]] @@ -6129,7 +6129,7 @@ dependencies = [ "errno", "libc", "linux-raw-sys", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -7492,7 +7492,7 @@ dependencies = [ "getrandom", "once_cell", "rustix", - "windows-sys 0.52.0", + "windows-sys 0.59.0", ] [[package]] @@ -8044,12 +8044,6 @@ source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" [[package]] -name = "unicode-xid" -version = "0.2.6" -source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "ebc1c04c71510c7f702b52b7c350734c9ff1295c464a03335b00bb84fc54f853" - -[[package]] name = "universal-hash" version = "0.5.1" source = "registry+https://github.com/rust-lang/crates.io-index" @@ -8316,9 +8310,9 @@ dependencies = [ [[package]] name = "wayland-cursor" -version = "0.31.8" +version = "0.31.10" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a93029cbb6650748881a00e4922b076092a6a08c11e7fbdb923f064b23968c5d" +checksum = "a65317158dec28d00416cb16705934070aef4f8393353d41126c54264ae0f182" dependencies = [ "rustix", "wayland-client", @@ -8352,9 +8346,9 @@ dependencies = [ [[package]] name = "wayland-protocols-wlr" -version = "0.3.6" +version = "0.3.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "248a02e6f595aad796561fa82d25601bd2c8c3b145b1c7453fc8f94c1a58f8b2" +checksum = "1cb6cdc73399c0e06504c437fe3cf886f25568dd5454473d565085b36d6a8bbf" dependencies = [ "bitflags 2.9.0", "wayland-backend", @@ -8553,7 +8547,7 @@ dependencies = [ [[package]] name = "webrender" version = "0.66.0" -source = "git+https://github.com/servo/webrender?branch=0.66#88462530746749163bcf1dc89be20a19f2394e71" +source = "git+https://github.com/servo/webrender?branch=0.67#ae2477d9a6da403e5b5dce8a17415a2cd1563074" dependencies = [ "allocator-api2", "bincode", @@ -8588,7 +8582,7 @@ dependencies = [ [[package]] name = "webrender_api" version = "0.66.0" -source = "git+https://github.com/servo/webrender?branch=0.66#88462530746749163bcf1dc89be20a19f2394e71" +source = "git+https://github.com/servo/webrender?branch=0.67#ae2477d9a6da403e5b5dce8a17415a2cd1563074" dependencies = [ "app_units", "bitflags 2.9.0", @@ -8609,7 +8603,7 @@ dependencies = [ [[package]] name = "webrender_build" version = "0.0.2" -source = "git+https://github.com/servo/webrender?branch=0.66#88462530746749163bcf1dc89be20a19f2394e71" +source = "git+https://github.com/servo/webrender?branch=0.67#ae2477d9a6da403e5b5dce8a17415a2cd1563074" dependencies = [ "bitflags 2.9.0", "lazy_static", @@ -9201,9 +9195,9 @@ dependencies = [ [[package]] name = "winnow" -version = "0.7.7" +version = "0.7.8" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "6cb8234a863ea0e8cd7284fcdd4f145233eb00fee02bbdd9861aec44e6477bc5" +checksum = "9e27d6ad3dac991091e4d35de9ba2d2d00647c5d0fc26c5496dee55984ae111b" dependencies = [ "memchr", ] @@ -9229,7 +9223,7 @@ dependencies = [ [[package]] name = "wr_glyph_rasterizer" version = "0.1.0" -source = "git+https://github.com/servo/webrender?branch=0.66#88462530746749163bcf1dc89be20a19f2394e71" +source = "git+https://github.com/servo/webrender?branch=0.67#ae2477d9a6da403e5b5dce8a17415a2cd1563074" dependencies = [ "core-foundation 0.9.4", "core-graphics", @@ -9253,8 +9247,8 @@ dependencies = [ [[package]] name = "wr_malloc_size_of" -version = "0.0.3" -source = "git+https://github.com/servo/webrender?branch=0.66#88462530746749163bcf1dc89be20a19f2394e71" +version = "0.2.0" +source = "git+https://github.com/servo/webrender?branch=0.67#ae2477d9a6da403e5b5dce8a17415a2cd1563074" dependencies = [ "app_units", "euclid", diff --git a/Cargo.toml b/Cargo.toml index 21bc94bcfda..b43c38b21b9 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -166,15 +166,15 @@ uuid = { version = "1.12.1", features = ["v4"] } webdriver = "0.51.0" webgpu_traits = { path = "components/shared/webgpu" } webpki-roots = "0.26" -webrender = { git = "https://github.com/servo/webrender", branch = "0.66", features = ["capture"] } -webrender_api = { git = "https://github.com/servo/webrender", branch = "0.66" } +webrender = { git = "https://github.com/servo/webrender", branch = "0.67", features = ["capture"] } +webrender_api = { git = "https://github.com/servo/webrender", branch = "0.67" } webxr-api = { path = "components/shared/webxr" } wgpu-core = "25" wgpu-types = "25" winapi = "0.3" windows-sys = "0.59" wio = "0.2" -wr_malloc_size_of = { git = "https://github.com/servo/webrender", branch = "0.66" } +wr_malloc_size_of = { git = "https://github.com/servo/webrender", branch = "0.67" } xi-unicode = "0.3.0" xml5ever = "0.22" diff --git a/components/canvas/backend.rs b/components/canvas/backend.rs new file mode 100644 index 00000000000..53acbea8b8d --- /dev/null +++ b/components/canvas/backend.rs @@ -0,0 +1,243 @@ +/* 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 canvas_traits::canvas::{ + CompositionOrBlending, FillOrStrokeStyle, LineCapStyle, LineJoinStyle, +}; +use euclid::Angle; +use euclid::default::{Point2D, Rect, Size2D, Transform2D, Vector2D}; +use lyon_geom::Arc; +use style::color::AbsoluteColor; + +use crate::canvas_data::{CanvasPaintState, Filter, TextRun}; + +pub(crate) trait Backend: Clone + Sized { + type Pattern<'a>: PatternHelpers + Clone; + type StrokeOptions: StrokeOptionsHelpers + Clone; + type Color: Clone; + type DrawOptions: DrawOptionsHelpers + Clone; + type CompositionOp; + type DrawTarget: GenericDrawTarget<Self>; + type PathBuilder: GenericPathBuilder<Self>; + type SourceSurface; + type Bytes<'a>: AsRef<[u8]>; + type Path: PathHelpers<Self> + Clone; + type GradientStop; + type GradientStops; + + fn get_composition_op(&self, opts: &Self::DrawOptions) -> Self::CompositionOp; + fn need_to_draw_shadow(&self, color: &Self::Color) -> bool; + fn set_shadow_color(&mut self, color: AbsoluteColor, state: &mut CanvasPaintState<'_, Self>); + fn set_fill_style( + &mut self, + style: FillOrStrokeStyle, + state: &mut CanvasPaintState<'_, Self>, + drawtarget: &Self::DrawTarget, + ); + fn set_stroke_style( + &mut self, + style: FillOrStrokeStyle, + state: &mut CanvasPaintState<'_, Self>, + drawtarget: &Self::DrawTarget, + ); + fn set_global_composition( + &mut self, + op: CompositionOrBlending, + state: &mut CanvasPaintState<'_, Self>, + ); + fn create_drawtarget(&self, size: Size2D<u64>) -> Self::DrawTarget; + fn new_paint_state<'a>(&self) -> CanvasPaintState<'a, Self>; +} + +// This defines required methods for a DrawTarget (currently only implemented for raqote). The +// prototypes are derived from the now-removed Azure backend's methods. +pub(crate) trait GenericDrawTarget<B: Backend> { + fn clear_rect(&mut self, rect: &Rect<f32>); + fn copy_surface( + &mut self, + surface: B::SourceSurface, + source: Rect<i32>, + destination: Point2D<i32>, + ); + fn create_path_builder(&self) -> B::PathBuilder; + fn create_similar_draw_target(&self, size: &Size2D<i32>) -> Self; + fn create_source_surface_from_data(&self, data: &[u8]) -> Option<B::SourceSurface>; + fn draw_surface( + &mut self, + surface: B::SourceSurface, + dest: Rect<f64>, + source: Rect<f64>, + filter: Filter, + draw_options: &B::DrawOptions, + ); + fn draw_surface_with_shadow( + &self, + surface: B::SourceSurface, + dest: &Point2D<f32>, + color: &B::Color, + offset: &Vector2D<f32>, + sigma: f32, + operator: B::CompositionOp, + ); + fn fill(&mut self, path: &B::Path, pattern: B::Pattern<'_>, draw_options: &B::DrawOptions); + fn fill_text( + &mut self, + text_runs: Vec<TextRun>, + start: Point2D<f32>, + pattern: &B::Pattern<'_>, + draw_options: &B::DrawOptions, + ); + fn fill_rect( + &mut self, + rect: &Rect<f32>, + pattern: B::Pattern<'_>, + draw_options: Option<&B::DrawOptions>, + ); + fn get_size(&self) -> Size2D<i32>; + fn get_transform(&self) -> Transform2D<f32>; + fn pop_clip(&mut self); + fn push_clip(&mut self, path: &B::Path); + fn set_transform(&mut self, matrix: &Transform2D<f32>); + fn stroke( + &mut self, + path: &B::Path, + pattern: B::Pattern<'_>, + stroke_options: &B::StrokeOptions, + draw_options: &B::DrawOptions, + ); + fn stroke_line( + &mut self, + start: Point2D<f32>, + end: Point2D<f32>, + pattern: B::Pattern<'_>, + stroke_options: &B::StrokeOptions, + draw_options: &B::DrawOptions, + ); + fn stroke_rect( + &mut self, + rect: &Rect<f32>, + pattern: B::Pattern<'_>, + stroke_options: &B::StrokeOptions, + draw_options: &B::DrawOptions, + ); + fn surface(&self) -> B::SourceSurface; + fn bytes(&'_ self) -> B::Bytes<'_>; +} + +/// A generic PathBuilder that abstracts the interface for azure's and raqote's PathBuilder. +pub(crate) trait GenericPathBuilder<B: Backend> { + fn arc( + &mut self, + origin: Point2D<f32>, + radius: f32, + start_angle: f32, + end_angle: f32, + anticlockwise: bool, + ); + fn bezier_curve_to( + &mut self, + control_point1: &Point2D<f32>, + control_point2: &Point2D<f32>, + control_point3: &Point2D<f32>, + ); + fn close(&mut self); + #[allow(clippy::too_many_arguments)] + fn ellipse( + &mut self, + origin: Point2D<f32>, + radius_x: f32, + radius_y: f32, + rotation_angle: f32, + start_angle: f32, + end_angle: f32, + anticlockwise: bool, + ) { + let mut start = Angle::radians(start_angle); + let mut end = Angle::radians(end_angle); + + // Wrap angles mod 2 * PI if necessary + if !anticlockwise && start > end + Angle::two_pi() || + anticlockwise && end > start + Angle::two_pi() + { + start = start.positive(); + end = end.positive(); + } + + // Calculate the total arc we're going to sweep. + let sweep = match anticlockwise { + true => { + if end - start == Angle::two_pi() { + -Angle::two_pi() + } else if end > start { + -(Angle::two_pi() - (end - start)) + } else { + -(start - end) + } + }, + false => { + if start - end == Angle::two_pi() { + Angle::two_pi() + } else if start > end { + Angle::two_pi() - (start - end) + } else { + end - start + } + }, + }; + + let arc: Arc<f32> = Arc { + center: origin, + radii: Vector2D::new(radius_x, radius_y), + start_angle: start, + sweep_angle: sweep, + x_rotation: Angle::radians(rotation_angle), + }; + + self.line_to(arc.from()); + + arc.for_each_quadratic_bezier(&mut |q| { + self.quadratic_curve_to(&q.ctrl, &q.to); + }); + } + fn get_current_point(&mut self) -> Option<Point2D<f32>>; + fn line_to(&mut self, point: Point2D<f32>); + fn move_to(&mut self, point: Point2D<f32>); + fn quadratic_curve_to(&mut self, control_point: &Point2D<f32>, end_point: &Point2D<f32>); + fn svg_arc( + &mut self, + radius_x: f32, + radius_y: f32, + rotation_angle: f32, + large_arc: bool, + sweep: bool, + end_point: Point2D<f32>, + ); + fn finish(&mut self) -> B::Path; +} + +pub(crate) trait PatternHelpers { + fn is_zero_size_gradient(&self) -> bool; + fn draw_rect(&self, rect: &Rect<f32>) -> Rect<f32>; +} + +pub(crate) trait StrokeOptionsHelpers { + fn set_line_width(&mut self, _val: f32); + fn set_miter_limit(&mut self, _val: f32); + fn set_line_join(&mut self, val: LineJoinStyle); + fn set_line_cap(&mut self, val: LineCapStyle); + fn set_line_dash(&mut self, items: Vec<f32>); + fn set_line_dash_offset(&mut self, offset: f32); +} + +pub(crate) trait DrawOptionsHelpers { + fn set_alpha(&mut self, val: f32); +} + +pub(crate) trait PathHelpers<B: Backend> { + fn transformed_copy_to_builder(&self, transform: &Transform2D<f32>) -> B::PathBuilder; + + fn contains_point(&self, x: f64, y: f64, path_transform: &Transform2D<f32>) -> bool; + + fn copy_to_builder(&self) -> B::PathBuilder; +} diff --git a/components/canvas/canvas_data.rs b/components/canvas/canvas_data.rs index 2667b7f6b44..ea30589d0af 100644 --- a/components/canvas/canvas_data.rs +++ b/components/canvas/canvas_data.rs @@ -2,6 +2,7 @@ * 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 std::marker::PhantomData; use std::mem; use std::sync::Arc; @@ -16,7 +17,6 @@ use fonts::{ }; use ipc_channel::ipc::{IpcSender, IpcSharedMemory}; use log::warn; -use num_traits::ToPrimitive; use range::Range; use servo_arc::Arc as ServoArc; use snapshot::Snapshot; @@ -26,14 +26,17 @@ use unicode_script::Script; use webrender_api::units::RectExt as RectExt_; use webrender_api::{ImageDescriptor, ImageDescriptorFlags, ImageFormat, ImageKey}; -use crate::raqote_backend::Repetition; +use crate::backend::{ + Backend, DrawOptionsHelpers as _, GenericDrawTarget as _, GenericPathBuilder, PathHelpers, + PatternHelpers, StrokeOptionsHelpers as _, +}; // Asserts on WR texture cache update for zero sized image with raw data. // https://github.com/servo/webrender/blob/main/webrender/src/texture_cache.rs#L1475 const MIN_WR_IMAGE_SIZE: Size2D<u64> = Size2D::new(1, 1); -fn to_path(path: &[PathSegment], mut builder: Box<dyn GenericPathBuilder>) -> Path { - let mut build_ref = PathBuilderRef { +fn to_path<B: Backend>(path: &[PathSegment], mut builder: B::PathBuilder) -> B::Path { + let mut build_ref = PathBuilderRef::<B> { builder: &mut builder, transform: Transform2D::identity(), }; @@ -112,20 +115,20 @@ fn to_path(path: &[PathSegment], mut builder: Box<dyn GenericPathBuilder>) -> Pa /// draw the path, we convert it back to userspace and draw it /// with the correct transform applied. /// TODO: De-abstract now that Azure is removed? -enum PathState { +enum PathState<B: Backend> { /// Path builder in user-space. If a transform has been applied /// but no further path operations have occurred, it is stored /// in the optional field. - UserSpacePathBuilder(Box<dyn GenericPathBuilder>, Option<Transform2D<f32>>), + UserSpacePathBuilder(B::PathBuilder, Option<Transform2D<f32>>), /// Path builder in device-space. - DeviceSpacePathBuilder(Box<dyn GenericPathBuilder>), + DeviceSpacePathBuilder(B::PathBuilder), /// Path in user-space. If a transform has been applied but /// but no further path operations have occurred, it is stored /// in the optional field. - UserSpacePath(Path, Option<Transform2D<f32>>), + UserSpacePath(B::Path, Option<Transform2D<f32>>), } -impl PathState { +impl<B: Backend> PathState<B> { fn is_path(&self) -> bool { match *self { PathState::UserSpacePath(..) => true, @@ -133,7 +136,7 @@ impl PathState { } } - fn path(&self) -> &Path { + fn path(&self) -> &B::Path { match *self { PathState::UserSpacePath(ref p, _) => p, PathState::UserSpacePathBuilder(..) | PathState::DeviceSpacePathBuilder(..) => { @@ -143,84 +146,14 @@ impl PathState { } } -pub trait Backend { - fn get_composition_op(&self, opts: &DrawOptions) -> CompositionOp; - fn need_to_draw_shadow(&self, color: &Color) -> bool; - fn set_shadow_color(&mut self, color: AbsoluteColor, state: &mut CanvasPaintState<'_>); - fn set_fill_style( - &mut self, - style: FillOrStrokeStyle, - state: &mut CanvasPaintState<'_>, - drawtarget: &dyn GenericDrawTarget, - ); - fn set_stroke_style( - &mut self, - style: FillOrStrokeStyle, - state: &mut CanvasPaintState<'_>, - drawtarget: &dyn GenericDrawTarget, - ); - fn set_global_composition( - &mut self, - op: CompositionOrBlending, - state: &mut CanvasPaintState<'_>, - ); - fn create_drawtarget(&self, size: Size2D<u64>) -> Box<dyn GenericDrawTarget>; - fn recreate_paint_state<'a>(&self, state: &CanvasPaintState<'a>) -> CanvasPaintState<'a>; -} - -/// A generic PathBuilder that abstracts the interface for azure's and raqote's PathBuilder. -/// TODO: De-abstract now that Azure is removed? -pub trait GenericPathBuilder { - fn arc( - &mut self, - origin: Point2D<f32>, - radius: f32, - start_angle: f32, - end_angle: f32, - anticlockwise: bool, - ); - fn bezier_curve_to( - &mut self, - control_point1: &Point2D<f32>, - control_point2: &Point2D<f32>, - control_point3: &Point2D<f32>, - ); - fn close(&mut self); - #[allow(clippy::too_many_arguments)] - fn ellipse( - &mut self, - origin: Point2D<f32>, - radius_x: f32, - radius_y: f32, - rotation_angle: f32, - start_angle: f32, - end_angle: f32, - anticlockwise: bool, - ); - fn get_current_point(&mut self) -> Option<Point2D<f32>>; - fn line_to(&mut self, point: Point2D<f32>); - fn move_to(&mut self, point: Point2D<f32>); - fn quadratic_curve_to(&mut self, control_point: &Point2D<f32>, end_point: &Point2D<f32>); - fn svg_arc( - &mut self, - radius_x: f32, - radius_y: f32, - rotation_angle: f32, - large_arc: bool, - sweep: bool, - end_point: Point2D<f32>, - ); - fn finish(&mut self) -> Path; -} - /// A wrapper around a stored PathBuilder and an optional transformation that should be /// applied to any points to ensure they are in the matching device space. -struct PathBuilderRef<'a> { - builder: &'a mut Box<dyn GenericPathBuilder>, +struct PathBuilderRef<'a, B: Backend> { + builder: &'a mut B::PathBuilder, transform: Transform2D<f32>, } -impl PathBuilderRef<'_> { +impl<B: Backend> PathBuilderRef<'_, B> { fn line_to(&mut self, pt: &Point2D<f32>) { let pt = self.transform.transform_point(*pt); self.builder.line_to(pt); @@ -341,7 +274,7 @@ impl PathBuilderRef<'_> { } #[allow(clippy::too_many_arguments)] - pub fn ellipse( + pub(crate) fn ellipse( &mut self, center: &Point2D<f32>, radius_x: f32, @@ -430,9 +363,9 @@ impl UnshapedTextRun<'_> { } } -pub struct TextRun { - pub font: FontRef, - pub glyphs: Arc<GlyphStore>, +pub(crate) struct TextRun { + pub(crate) font: FontRef, + pub(crate) glyphs: Arc<GlyphStore>, } impl TextRun { @@ -458,149 +391,31 @@ impl TextRun { } } -// This defines required methods for a DrawTarget (currently only implemented for raqote). The -// prototypes are derived from the now-removed Azure backend's methods. -pub trait GenericDrawTarget { - fn clear_rect(&mut self, rect: &Rect<f32>); - fn copy_surface( - &mut self, - surface: SourceSurface, - source: Rect<i32>, - destination: Point2D<i32>, - ); - fn create_gradient_stops(&self, gradient_stops: Vec<GradientStop>) -> GradientStops; - fn create_path_builder(&self) -> Box<dyn GenericPathBuilder>; - fn create_similar_draw_target(&self, size: &Size2D<i32>) -> Box<dyn GenericDrawTarget>; - fn create_source_surface_from_data(&self, data: &[u8]) -> Option<SourceSurface>; - fn draw_surface( - &mut self, - surface: SourceSurface, - dest: Rect<f64>, - source: Rect<f64>, - filter: Filter, - draw_options: &DrawOptions, - ); - fn draw_surface_with_shadow( - &self, - surface: SourceSurface, - dest: &Point2D<f32>, - color: &Color, - offset: &Vector2D<f32>, - sigma: f32, - operator: CompositionOp, - ); - fn fill(&mut self, path: &Path, pattern: Pattern, draw_options: &DrawOptions); - fn fill_text( - &mut self, - text_runs: Vec<TextRun>, - start: Point2D<f32>, - pattern: &Pattern, - draw_options: &DrawOptions, - ); - fn fill_rect(&mut self, rect: &Rect<f32>, pattern: Pattern, draw_options: Option<&DrawOptions>); - fn get_size(&self) -> Size2D<i32>; - fn get_transform(&self) -> Transform2D<f32>; - fn pop_clip(&mut self); - fn push_clip(&mut self, path: &Path); - fn set_transform(&mut self, matrix: &Transform2D<f32>); - fn snapshot(&self) -> SourceSurface; - fn stroke( - &mut self, - path: &Path, - pattern: Pattern, - stroke_options: &StrokeOptions, - draw_options: &DrawOptions, - ); - fn stroke_line( - &mut self, - start: Point2D<f32>, - end: Point2D<f32>, - pattern: Pattern, - stroke_options: &StrokeOptions, - draw_options: &DrawOptions, - ); - fn stroke_rect( - &mut self, - rect: &Rect<f32>, - pattern: Pattern, - stroke_options: &StrokeOptions, - draw_options: &DrawOptions, - ); - fn snapshot_data(&self) -> &[u8]; -} - -pub enum GradientStop { - Raqote(raqote::GradientStop), -} - -pub enum GradientStops { - Raqote(Vec<raqote::GradientStop>), -} - -#[derive(Clone)] -pub enum Color { - Raqote(raqote::SolidSource), -} - -#[derive(Clone)] -pub enum CompositionOp { - Raqote(raqote::BlendMode), -} - -#[derive(Clone)] -pub enum SourceSurface { - Raqote(Vec<u8>), // TODO: See if we can avoid the alloc (probably?) -} - -#[derive(Clone)] -pub enum Path { - Raqote(raqote::Path), -} - -#[derive(Clone)] -pub enum Pattern<'a> { - Raqote(crate::raqote_backend::Pattern<'a>), -} - -#[derive(Clone)] -pub enum DrawOptions { - Raqote(raqote::DrawOptions), -} - -#[derive(Clone)] -pub enum StrokeOptions { - Raqote(raqote::StrokeStyle), -} - #[derive(Clone, Copy)] -pub enum Filter { +pub(crate) enum Filter { Bilinear, Nearest, } -pub struct CanvasData<'a> { - backend: Box<dyn Backend>, - drawtarget: Box<dyn GenericDrawTarget>, - path_state: Option<PathState>, - state: CanvasPaintState<'a>, - saved_states: Vec<CanvasPaintState<'a>>, +pub(crate) struct CanvasData<'a, B: Backend> { + backend: B, + drawtarget: B::DrawTarget, + path_state: Option<PathState<B>>, + state: CanvasPaintState<'a, B>, + saved_states: Vec<CanvasPaintState<'a, B>>, compositor_api: CrossProcessCompositorApi, image_key: ImageKey, font_context: Arc<FontContext>, } -fn create_backend() -> Box<dyn Backend> { - Box::new(crate::raqote_backend::RaqoteBackend) -} - -impl<'a> CanvasData<'a> { - pub fn new( +impl<'a, B: Backend> CanvasData<'a, B> { + pub(crate) fn new( size: Size2D<u64>, compositor_api: CrossProcessCompositorApi, font_context: Arc<FontContext>, - ) -> CanvasData<'a> { + backend: B, + ) -> CanvasData<'a, B> { let size = size.max(MIN_WR_IMAGE_SIZE); - let backend = create_backend(); let draw_target = backend.create_drawtarget(size); let image_key = compositor_api.generate_image_key().unwrap(); let descriptor = ImageDescriptor { @@ -611,13 +426,13 @@ impl<'a> CanvasData<'a> { flags: ImageDescriptorFlags::empty(), }; let data = - SerializableImageData::Raw(IpcSharedMemory::from_bytes(draw_target.snapshot_data())); + SerializableImageData::Raw(IpcSharedMemory::from_bytes(draw_target.bytes().as_ref())); compositor_api.update_images(vec![ImageUpdate::AddImage(image_key, descriptor, data)]); CanvasData { + state: backend.new_paint_state(), backend, drawtarget: draw_target, path_state: None, - state: CanvasPaintState::default(), saved_states: vec![], compositor_api, image_key, @@ -625,11 +440,11 @@ impl<'a> CanvasData<'a> { } } - pub fn image_key(&self) -> ImageKey { + pub(crate) fn image_key(&self) -> ImageKey { self.image_key } - pub fn draw_image( + pub(crate) fn draw_image( &mut self, image_data: &[u8], image_size: Size2D<u64>, @@ -648,8 +463,8 @@ impl<'a> CanvasData<'a> { }; let draw_options = self.state.draw_options.clone(); - let writer = |draw_target: &mut dyn GenericDrawTarget| { - write_image( + let writer = |draw_target: &mut B::DrawTarget| { + write_image::<B>( draw_target, image_data, source_rect.size, @@ -669,15 +484,15 @@ impl<'a> CanvasData<'a> { // TODO(pylbrecht) pass another closure for raqote self.draw_with_shadow(&rect, writer); } else { - writer(&mut *self.drawtarget); + writer(&mut self.drawtarget); } } - pub fn save_context_state(&mut self) { + pub(crate) fn save_context_state(&mut self) { self.saved_states.push(self.state.clone()); } - pub fn restore_context_state(&mut self) { + pub(crate) fn restore_context_state(&mut self) { if let Some(state) = self.saved_states.pop() { let _ = mem::replace(&mut self.state, state); self.drawtarget.set_transform(&self.state.transform); @@ -685,7 +500,7 @@ impl<'a> CanvasData<'a> { } } - pub fn fill_text_with_size( + pub(crate) fn fill_text_with_size( &mut self, text: String, x: f64, @@ -764,7 +579,7 @@ impl<'a> CanvasData<'a> { } /// <https://html.spec.whatwg.org/multipage/#text-preparation-algorithm> - pub fn fill_text( + pub(crate) fn fill_text( &mut self, text: String, x: f64, @@ -782,7 +597,7 @@ impl<'a> CanvasData<'a> { /// <https://html.spec.whatwg.org/multipage/#text-preparation-algorithm> /// <https://html.spec.whatwg.org/multipage/#dom-context-2d-measuretext> - pub fn measure_text(&mut self, text: String) -> TextMetrics { + pub(crate) fn measure_text(&mut self, text: String) -> TextMetrics { // > Step 2: Replace all ASCII whitespace in text with U+0020 SPACE characters. let text = replace_ascii_whitespace(text); let Some(ref font_style) = self.state.font_style else { @@ -934,49 +749,15 @@ impl<'a> CanvasData<'a> { point2(x + anchor_x, y + anchor_y) } - pub fn fill_rect(&mut self, rect: &Rect<f32>) { + pub(crate) fn fill_rect(&mut self, rect: &Rect<f32>) { if self.state.fill_style.is_zero_size_gradient() { return; // Paint nothing if gradient size is zero. } - let draw_rect = match &self.state.fill_style { - Pattern::Raqote(pattern) => match pattern { - crate::raqote_backend::Pattern::Surface(pattern) => { - let pattern_rect = Rect::new(Point2D::origin(), pattern.size()); - let mut draw_rect = rect.intersection(&pattern_rect).unwrap_or(Rect::zero()); - - match pattern.repetition() { - Repetition::NoRepeat => { - draw_rect.size.width = - draw_rect.size.width.min(pattern_rect.size.width); - draw_rect.size.height = - draw_rect.size.height.min(pattern_rect.size.height); - }, - Repetition::RepeatX => { - draw_rect.size.width = rect.size.width; - draw_rect.size.height = - draw_rect.size.height.min(pattern_rect.size.height); - }, - Repetition::RepeatY => { - draw_rect.size.height = rect.size.height; - draw_rect.size.width = - draw_rect.size.width.min(pattern_rect.size.width); - }, - Repetition::Repeat => { - draw_rect = *rect; - }, - } - - draw_rect - }, - crate::raqote_backend::Pattern::Color(..) | - crate::raqote_backend::Pattern::LinearGradient(..) | - crate::raqote_backend::Pattern::RadialGradient(..) => *rect, - }, - }; + let draw_rect = self.state.fill_style.draw_rect(rect); if self.need_to_draw_shadow() { - self.draw_with_shadow(&draw_rect, |new_draw_target: &mut dyn GenericDrawTarget| { + self.draw_with_shadow(&draw_rect, |new_draw_target: &mut B::DrawTarget| { new_draw_target.fill_rect( &draw_rect, self.state.fill_style.clone(), @@ -992,17 +773,17 @@ impl<'a> CanvasData<'a> { } } - pub fn clear_rect(&mut self, rect: &Rect<f32>) { + pub(crate) fn clear_rect(&mut self, rect: &Rect<f32>) { self.drawtarget.clear_rect(rect); } - pub fn stroke_rect(&mut self, rect: &Rect<f32>) { + pub(crate) fn stroke_rect(&mut self, rect: &Rect<f32>) { if self.state.stroke_style.is_zero_size_gradient() { return; // Paint nothing if gradient size is zero. } if self.need_to_draw_shadow() { - self.draw_with_shadow(rect, |new_draw_target: &mut dyn GenericDrawTarget| { + self.draw_with_shadow(rect, |new_draw_target: &mut B::DrawTarget| { new_draw_target.stroke_rect( rect, self.state.stroke_style.clone(), @@ -1030,12 +811,12 @@ impl<'a> CanvasData<'a> { } } - pub fn begin_path(&mut self) { + pub(crate) fn begin_path(&mut self) { // Erase any traces of previous paths that existed before this. self.path_state = None; } - pub fn close_path(&mut self) { + pub(crate) fn close_path(&mut self) { self.path_builder().close(); } @@ -1097,14 +878,14 @@ impl<'a> CanvasData<'a> { assert!(self.path_state.as_ref().unwrap().is_path()) } - fn path(&self) -> &Path { + fn path(&self) -> &B::Path { self.path_state .as_ref() .expect("Should have called ensure_path()") .path() } - pub fn fill(&mut self) { + pub(crate) fn fill(&mut self) { if self.state.fill_style.is_zero_size_gradient() { return; // Paint nothing if gradient size is zero. } @@ -1113,16 +894,16 @@ impl<'a> CanvasData<'a> { self.drawtarget.fill( &self.path().clone(), self.state.fill_style.clone(), - &self.state.draw_options, + &self.state.draw_options.clone(), ); } - pub fn fill_path(&mut self, path: &[PathSegment]) { + pub(crate) fn fill_path(&mut self, path: &[PathSegment]) { if self.state.fill_style.is_zero_size_gradient() { return; // Paint nothing if gradient size is zero. } - let path = to_path(path, self.drawtarget.create_path_builder()); + let path = to_path::<B>(path, self.drawtarget.create_path_builder()); self.drawtarget.fill( &path, @@ -1131,7 +912,7 @@ impl<'a> CanvasData<'a> { ); } - pub fn stroke(&mut self) { + pub(crate) fn stroke(&mut self) { if self.state.stroke_style.is_zero_size_gradient() { return; // Paint nothing if gradient size is zero. } @@ -1145,12 +926,12 @@ impl<'a> CanvasData<'a> { ); } - pub fn stroke_path(&mut self, path: &[PathSegment]) { + pub(crate) fn stroke_path(&mut self, path: &[PathSegment]) { if self.state.stroke_style.is_zero_size_gradient() { return; // Paint nothing if gradient size is zero. } - let path = to_path(path, self.drawtarget.create_path_builder()); + let path = to_path::<B>(path, self.drawtarget.create_path_builder()); self.drawtarget.stroke( &path, @@ -1160,18 +941,18 @@ impl<'a> CanvasData<'a> { ); } - pub fn clip(&mut self) { + pub(crate) fn clip(&mut self) { self.ensure_path(); let path = self.path().clone(); self.drawtarget.push_clip(&path); } - pub fn clip_path(&mut self, path: &[PathSegment]) { - let path = to_path(path, self.drawtarget.create_path_builder()); + pub(crate) fn clip_path(&mut self, path: &[PathSegment]) { + let path = to_path::<B>(path, self.drawtarget.create_path_builder()); self.drawtarget.push_clip(&path); } - pub fn is_point_in_path( + pub(crate) fn is_point_in_path( &mut self, x: f64, y: f64, @@ -1190,7 +971,7 @@ impl<'a> CanvasData<'a> { chan.send(result).unwrap(); } - pub fn is_point_in_path_( + pub(crate) fn is_point_in_path_( &mut self, path: &[PathSegment], x: f64, @@ -1202,7 +983,7 @@ impl<'a> CanvasData<'a> { Some(PathState::UserSpacePath(_, Some(transform))) => transform, Some(_) | None => &self.drawtarget.get_transform(), }; - let result = to_path(path, self.drawtarget.create_path_builder()).contains_point( + let result = to_path::<B>(path, self.drawtarget.create_path_builder()).contains_point( x, y, path_transform, @@ -1210,15 +991,15 @@ impl<'a> CanvasData<'a> { chan.send(result).unwrap(); } - pub fn move_to(&mut self, point: &Point2D<f32>) { + pub(crate) fn move_to(&mut self, point: &Point2D<f32>) { self.path_builder().move_to(point); } - pub fn line_to(&mut self, point: &Point2D<f32>) { + pub(crate) fn line_to(&mut self, point: &Point2D<f32>) { self.path_builder().line_to(point); } - fn path_builder(&mut self) -> PathBuilderRef { + fn path_builder(&mut self) -> PathBuilderRef<B> { if self.path_state.is_none() { self.path_state = Some(PathState::UserSpacePathBuilder( self.drawtarget.create_path_builder(), @@ -1283,18 +1064,18 @@ impl<'a> CanvasData<'a> { } } - pub fn rect(&mut self, rect: &Rect<f32>) { + pub(crate) fn rect(&mut self, rect: &Rect<f32>) { self.path_builder().rect(rect); } - pub fn quadratic_curve_to(&mut self, cp: &Point2D<f32>, endpoint: &Point2D<f32>) { + pub(crate) fn quadratic_curve_to(&mut self, cp: &Point2D<f32>, endpoint: &Point2D<f32>) { if self.path_state.is_none() { self.move_to(cp); } self.path_builder().quadratic_curve_to(cp, endpoint); } - pub fn bezier_curve_to( + pub(crate) fn bezier_curve_to( &mut self, cp1: &Point2D<f32>, cp2: &Point2D<f32>, @@ -1306,7 +1087,7 @@ impl<'a> CanvasData<'a> { self.path_builder().bezier_curve_to(cp1, cp2, endpoint); } - pub fn arc( + pub(crate) fn arc( &mut self, center: &Point2D<f32>, radius: f32, @@ -1318,12 +1099,12 @@ impl<'a> CanvasData<'a> { .arc(center, radius, start_angle, end_angle, ccw); } - pub fn arc_to(&mut self, cp1: &Point2D<f32>, cp2: &Point2D<f32>, radius: f32) { + pub(crate) fn arc_to(&mut self, cp1: &Point2D<f32>, cp2: &Point2D<f32>, radius: f32) { self.path_builder().arc_to(cp1, cp2, radius); } #[allow(clippy::too_many_arguments)] - pub fn ellipse( + pub(crate) fn ellipse( &mut self, center: &Point2D<f32>, radius_x: f32, @@ -1344,45 +1125,45 @@ impl<'a> CanvasData<'a> { ); } - pub fn set_fill_style(&mut self, style: FillOrStrokeStyle) { + pub(crate) fn set_fill_style(&mut self, style: FillOrStrokeStyle) { self.backend - .set_fill_style(style, &mut self.state, &*self.drawtarget); + .set_fill_style(style, &mut self.state, &self.drawtarget); } - pub fn set_stroke_style(&mut self, style: FillOrStrokeStyle) { + pub(crate) fn set_stroke_style(&mut self, style: FillOrStrokeStyle) { self.backend - .set_stroke_style(style, &mut self.state, &*self.drawtarget); + .set_stroke_style(style, &mut self.state, &self.drawtarget); } - pub fn set_line_width(&mut self, width: f32) { + pub(crate) fn set_line_width(&mut self, width: f32) { self.state.stroke_opts.set_line_width(width); } - pub fn set_line_cap(&mut self, cap: LineCapStyle) { + pub(crate) fn set_line_cap(&mut self, cap: LineCapStyle) { self.state.stroke_opts.set_line_cap(cap); } - pub fn set_line_join(&mut self, join: LineJoinStyle) { + pub(crate) fn set_line_join(&mut self, join: LineJoinStyle) { self.state.stroke_opts.set_line_join(join); } - pub fn set_miter_limit(&mut self, limit: f32) { + pub(crate) fn set_miter_limit(&mut self, limit: f32) { self.state.stroke_opts.set_miter_limit(limit); } - pub fn set_line_dash(&mut self, items: Vec<f32>) { + pub(crate) fn set_line_dash(&mut self, items: Vec<f32>) { self.state.stroke_opts.set_line_dash(items); } - pub fn set_line_dash_offset(&mut self, offset: f32) { + pub(crate) fn set_line_dash_offset(&mut self, offset: f32) { self.state.stroke_opts.set_line_dash_offset(offset); } - pub fn get_transform(&self) -> Transform2D<f32> { + pub(crate) fn get_transform(&self) -> Transform2D<f32> { self.drawtarget.get_transform() } - pub fn set_transform(&mut self, transform: &Transform2D<f32>) { + pub(crate) fn set_transform(&mut self, transform: &Transform2D<f32>) { // If there is an in-progress path, store the existing transformation required // to move between device and user space. match self.path_state.as_mut() { @@ -1398,32 +1179,28 @@ impl<'a> CanvasData<'a> { self.drawtarget.set_transform(transform) } - pub fn set_global_alpha(&mut self, alpha: f32) { + pub(crate) fn set_global_alpha(&mut self, alpha: f32) { self.state.draw_options.set_alpha(alpha); } - pub fn set_global_composition(&mut self, op: CompositionOrBlending) { + pub(crate) fn set_global_composition(&mut self, op: CompositionOrBlending) { self.backend.set_global_composition(op, &mut self.state); } - pub fn recreate(&mut self, size: Option<Size2D<u64>>) { + pub(crate) fn recreate(&mut self, size: Option<Size2D<u64>>) { let size = size .unwrap_or_else(|| self.drawtarget.get_size().to_u64()) .max(MIN_WR_IMAGE_SIZE); self.drawtarget = self .backend .create_drawtarget(Size2D::new(size.width, size.height)); - self.state = self.backend.recreate_paint_state(&self.state); + self.state = self.backend.new_paint_state(); self.saved_states.clear(); self.update_image_rendering(); } - pub fn snapshot(&self) { - self.drawtarget.snapshot_data(); - } - /// Update image in WebRender - pub fn update_image_rendering(&mut self) { + pub(crate) fn update_image_rendering(&mut self) { let descriptor = ImageDescriptor { size: self.drawtarget.get_size().cast_unit(), stride: None, @@ -1432,7 +1209,7 @@ impl<'a> CanvasData<'a> { flags: ImageDescriptorFlags::empty(), }; let data = SerializableImageData::Raw(IpcSharedMemory::from_bytes( - self.drawtarget.snapshot_data(), + self.drawtarget.bytes().as_ref(), )); self.compositor_api @@ -1444,7 +1221,7 @@ impl<'a> CanvasData<'a> { } // https://html.spec.whatwg.org/multipage/#dom-context-2d-putimagedata - pub fn put_image_data(&mut self, mut imagedata: Vec<u8>, rect: Rect<u64>) { + pub(crate) fn put_image_data(&mut self, mut imagedata: Vec<u8>, rect: Rect<u64>) { assert_eq!(imagedata.len() % 4, 0); assert_eq!(rect.size.area() as usize, imagedata.len() / 4); pixels::rgba8_byte_swap_and_premultiply_inplace(&mut imagedata); @@ -1459,31 +1236,31 @@ impl<'a> CanvasData<'a> { ); } - pub fn set_shadow_offset_x(&mut self, value: f64) { + pub(crate) fn set_shadow_offset_x(&mut self, value: f64) { self.state.shadow_offset_x = value; } - pub fn set_shadow_offset_y(&mut self, value: f64) { + pub(crate) fn set_shadow_offset_y(&mut self, value: f64) { self.state.shadow_offset_y = value; } - pub fn set_shadow_blur(&mut self, value: f64) { + pub(crate) fn set_shadow_blur(&mut self, value: f64) { self.state.shadow_blur = value; } - pub fn set_shadow_color(&mut self, value: AbsoluteColor) { + pub(crate) fn set_shadow_color(&mut self, value: AbsoluteColor) { self.backend.set_shadow_color(value, &mut self.state); } - pub fn set_font(&mut self, font_style: FontStyleStruct) { + pub(crate) fn set_font(&mut self, font_style: FontStyleStruct) { self.state.font_style = Some(ServoArc::new(font_style)) } - pub fn set_text_align(&mut self, text_align: TextAlign) { + pub(crate) fn set_text_align(&mut self, text_align: TextAlign) { self.state.text_align = text_align; } - pub fn set_text_baseline(&mut self, text_baseline: TextBaseline) { + pub(crate) fn set_text_baseline(&mut self, text_baseline: TextBaseline) { self.state.text_baseline = text_baseline; } @@ -1495,7 +1272,7 @@ impl<'a> CanvasData<'a> { self.state.shadow_blur != 0.0f64) } - fn create_draw_target_for_shadow(&self, source_rect: &Rect<f32>) -> Box<dyn GenericDrawTarget> { + fn create_draw_target_for_shadow(&self, source_rect: &Rect<f32>) -> B::DrawTarget { let mut draw_target = self.drawtarget.create_similar_draw_target(&Size2D::new( source_rect.size.width as i32, source_rect.size.height as i32, @@ -1509,13 +1286,13 @@ impl<'a> CanvasData<'a> { fn draw_with_shadow<F>(&self, rect: &Rect<f32>, draw_shadow_source: F) where - F: FnOnce(&mut dyn GenericDrawTarget), + F: FnOnce(&mut B::DrawTarget), { let shadow_src_rect = self.state.transform.outer_transformed_rect(rect); let mut new_draw_target = self.create_draw_target_for_shadow(&shadow_src_rect); - draw_shadow_source(&mut *new_draw_target); + draw_shadow_source(&mut new_draw_target); self.drawtarget.draw_surface_with_shadow( - new_draw_target.snapshot(), + new_draw_target.surface(), &Point2D::new(shadow_src_rect.origin.x, shadow_src_rect.origin.y), &self.state.shadow_color, &Vector2D::new( @@ -1531,7 +1308,7 @@ impl<'a> CanvasData<'a> { /// canvas_size: The size of the canvas we're reading from /// read_rect: The area of the canvas we want to read from #[allow(unsafe_code)] - pub fn read_pixels( + pub(crate) fn read_pixels( &self, read_rect: Option<Rect<u64>>, canvas_size: Option<Size2D<u64>>, @@ -1546,11 +1323,11 @@ impl<'a> CanvasData<'a> { { vec![] } else { - let bytes = self.drawtarget.snapshot_data(); - pixels::rgba8_get_rect(bytes, canvas_size, read_rect).to_vec() + pixels::rgba8_get_rect(self.drawtarget.bytes().as_ref(), canvas_size, read_rect) + .to_vec() } } else { - self.drawtarget.snapshot_data().to_vec() + self.drawtarget.bytes().as_ref().to_vec() }; Snapshot::from_vec( @@ -1564,7 +1341,7 @@ impl<'a> CanvasData<'a> { } } -impl Drop for CanvasData<'_> { +impl<B: Backend> Drop for CanvasData<'_, B> { fn drop(&mut self) { self.compositor_api .update_images(vec![ImageUpdate::DeleteImage(self.image_key)]); @@ -1575,20 +1352,21 @@ const HANGING_BASELINE_DEFAULT: f32 = 0.8; const IDEOGRAPHIC_BASELINE_DEFAULT: f32 = 0.5; #[derive(Clone)] -pub struct CanvasPaintState<'a> { - pub draw_options: DrawOptions, - pub fill_style: Pattern<'a>, - pub stroke_style: Pattern<'a>, - pub stroke_opts: StrokeOptions, +pub(crate) struct CanvasPaintState<'a, B: Backend> { + pub(crate) draw_options: B::DrawOptions, + pub(crate) fill_style: B::Pattern<'a>, + pub(crate) stroke_style: B::Pattern<'a>, + pub(crate) stroke_opts: B::StrokeOptions, /// The current 2D transform matrix. - pub transform: Transform2D<f32>, - pub shadow_offset_x: f64, - pub shadow_offset_y: f64, - pub shadow_blur: f64, - pub shadow_color: Color, - pub font_style: Option<ServoArc<FontStyleStruct>>, - pub text_align: TextAlign, - pub text_baseline: TextBaseline, + pub(crate) transform: Transform2D<f32>, + pub(crate) shadow_offset_x: f64, + pub(crate) shadow_offset_y: f64, + pub(crate) shadow_blur: f64, + pub(crate) shadow_color: B::Color, + pub(crate) font_style: Option<ServoArc<FontStyleStruct>>, + pub(crate) text_align: TextAlign, + pub(crate) text_baseline: TextBaseline, + pub(crate) _backend: PhantomData<B>, } /// It writes an image to the destination target @@ -1598,14 +1376,14 @@ pub struct CanvasPaintState<'a> { /// dest_rect: Area of the destination target where the pixels will be copied /// smoothing_enabled: It determines if smoothing is applied to the image result /// premultiply: Determines whenever the image data should be premultiplied or not -fn write_image( - draw_target: &mut dyn GenericDrawTarget, +fn write_image<B: Backend>( + draw_target: &mut B::DrawTarget, mut image_data: Vec<u8>, image_size: Size2D<f64>, dest_rect: Rect<f64>, smoothing_enabled: bool, premultiply: bool, - draw_options: &DrawOptions, + draw_options: &B::DrawOptions, ) { if image_data.is_empty() { return; @@ -1634,25 +1412,11 @@ fn write_image( draw_target.draw_surface(source_surface, dest_rect, image_rect, filter, draw_options); } -pub trait RectToi32 { - fn to_i32(&self) -> Rect<i32>; +pub(crate) trait RectToi32 { fn ceil(&self) -> Rect<f64>; } impl RectToi32 for Rect<f64> { - fn to_i32(&self) -> Rect<i32> { - Rect::new( - Point2D::new( - self.origin.x.to_i32().unwrap(), - self.origin.y.to_i32().unwrap(), - ), - Size2D::new( - self.size.width.to_i32().unwrap(), - self.size.height.to_i32().unwrap(), - ), - ) - } - fn ceil(&self) -> Rect<f64> { Rect::new( Point2D::new(self.origin.x.ceil(), self.origin.y.ceil()), @@ -1661,22 +1425,6 @@ impl RectToi32 for Rect<f64> { } } -pub trait RectExt { - fn to_u64(&self) -> Rect<u64>; -} - -impl RectExt for Rect<f64> { - fn to_u64(&self) -> Rect<u64> { - self.cast() - } -} - -impl RectExt for Rect<u32> { - fn to_u64(&self) -> Rect<u64> { - self.cast() - } -} - fn replace_ascii_whitespace(text: String) -> String { text.chars() .map(|c| match c { diff --git a/components/canvas/canvas_paint_thread.rs b/components/canvas/canvas_paint_thread.rs index bb940d7ef81..82a221d560d 100644 --- a/components/canvas/canvas_paint_thread.rs +++ b/components/canvas/canvas_paint_thread.rs @@ -11,18 +11,21 @@ use canvas_traits::ConstellationCanvasMsg; use canvas_traits::canvas::*; use compositing_traits::CrossProcessCompositorApi; use crossbeam_channel::{Sender, select, unbounded}; -use euclid::default::Size2D; +use euclid::default::{Point2D, Rect, Size2D, Transform2D}; use fonts::{FontContext, SystemFontServiceProxy}; use ipc_channel::ipc::{self, IpcSender}; use ipc_channel::router::ROUTER; use log::warn; use net_traits::ResourceThreads; +use style::color::AbsoluteColor; +use style::properties::style_structs::Font as FontStyleStruct; use webrender_api::ImageKey; use crate::canvas_data::*; +use crate::raqote_backend::RaqoteBackend; pub struct CanvasPaintThread<'a> { - canvases: HashMap<CanvasId, CanvasData<'a>>, + canvases: HashMap<CanvasId, Canvas<'a>>, next_canvas_id: CanvasId, compositor_api: CrossProcessCompositorApi, font_context: Arc<FontContext>, @@ -113,10 +116,14 @@ impl<'a> CanvasPaintThread<'a> { let canvas_id = self.next_canvas_id; self.next_canvas_id.0 += 1; - let canvas_data = - CanvasData::new(size, self.compositor_api.clone(), self.font_context.clone()); + let canvas_data = CanvasData::new( + size, + self.compositor_api.clone(), + self.font_context.clone(), + RaqoteBackend, + ); let image_key = canvas_data.image_key(); - self.canvases.insert(canvas_id, canvas_data); + self.canvases.insert(canvas_id, Canvas::Raqote(canvas_data)); (canvas_id, image_key) } @@ -276,7 +283,347 @@ impl<'a> CanvasPaintThread<'a> { } } - fn canvas(&mut self, canvas_id: CanvasId) -> &mut CanvasData<'a> { + fn canvas(&mut self, canvas_id: CanvasId) -> &mut Canvas<'a> { self.canvases.get_mut(&canvas_id).expect("Bogus canvas id") } } + +enum Canvas<'a> { + Raqote(CanvasData<'a, RaqoteBackend>), +} + +impl Canvas<'_> { + fn set_fill_style(&mut self, style: FillOrStrokeStyle) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_fill_style(style), + } + } + + fn fill(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.fill(), + } + } + + fn fill_text(&mut self, text: String, x: f64, y: f64, max_width: Option<f64>, is_rtl: bool) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.fill_text(text, x, y, max_width, is_rtl), + } + } + + fn fill_rect(&mut self, rect: &Rect<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.fill_rect(rect), + } + } + + fn set_stroke_style(&mut self, style: FillOrStrokeStyle) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_stroke_style(style), + } + } + + fn stroke_rect(&mut self, rect: &Rect<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.stroke_rect(rect), + } + } + + fn begin_path(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.begin_path(), + } + } + + fn close_path(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.close_path(), + } + } + + fn fill_path(&mut self, path: &[PathSegment]) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.fill_path(path), + } + } + + fn stroke(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.stroke(), + } + } + + fn stroke_path(&mut self, path: &[PathSegment]) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.stroke_path(path), + } + } + + fn clip(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.clip(), + } + } + + fn is_point_in_path(&mut self, x: f64, y: f64, fill_rule: FillRule, chan: IpcSender<bool>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.is_point_in_path(x, y, fill_rule, chan), + } + } + + fn is_point_in_path_( + &mut self, + path: &[PathSegment], + x: f64, + y: f64, + fill_rule: FillRule, + chan: IpcSender<bool>, + ) { + match self { + Canvas::Raqote(canvas_data) => { + canvas_data.is_point_in_path_(path, x, y, fill_rule, chan) + }, + } + } + + fn clear_rect(&mut self, rect: &Rect<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.clear_rect(rect), + } + } + + fn draw_image( + &mut self, + data: &[u8], + size: Size2D<u64>, + dest_rect: Rect<f64>, + source_rect: Rect<f64>, + smoothing_enabled: bool, + is_premultiplied: bool, + ) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.draw_image( + data, + size, + dest_rect, + source_rect, + smoothing_enabled, + is_premultiplied, + ), + } + } + + fn read_pixels( + &mut self, + read_rect: Option<Rect<u64>>, + canvas_size: Option<Size2D<u64>>, + ) -> snapshot::Snapshot { + match self { + Canvas::Raqote(canvas_data) => canvas_data.read_pixels(read_rect, canvas_size), + } + } + + fn move_to(&mut self, point: &Point2D<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.move_to(point), + } + } + + fn line_to(&mut self, point: &Point2D<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.line_to(point), + } + } + + fn rect(&mut self, rect: &Rect<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.rect(rect), + } + } + + fn quadratic_curve_to(&mut self, cp: &Point2D<f32>, pt: &Point2D<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.quadratic_curve_to(cp, pt), + } + } + + fn bezier_curve_to(&mut self, cp1: &Point2D<f32>, cp2: &Point2D<f32>, pt: &Point2D<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.bezier_curve_to(cp1, cp2, pt), + } + } + + fn arc(&mut self, center: &Point2D<f32>, radius: f32, start: f32, end: f32, ccw: bool) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.arc(center, radius, start, end, ccw), + } + } + + fn arc_to(&mut self, cp1: &Point2D<f32>, cp2: &Point2D<f32>, radius: f32) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.arc_to(cp1, cp2, radius), + } + } + + #[allow(clippy::too_many_arguments)] + fn ellipse( + &mut self, + center: &Point2D<f32>, + radius_x: f32, + radius_y: f32, + rotation: f32, + start: f32, + end: f32, + ccw: bool, + ) { + match self { + Canvas::Raqote(canvas_data) => { + canvas_data.ellipse(center, radius_x, radius_y, rotation, start, end, ccw) + }, + } + } + + fn restore_context_state(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.restore_context_state(), + } + } + + fn save_context_state(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.save_context_state(), + } + } + + fn set_line_width(&mut self, width: f32) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_line_width(width), + } + } + + fn set_line_cap(&mut self, cap: LineCapStyle) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_line_cap(cap), + } + } + + fn set_line_join(&mut self, join: LineJoinStyle) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_line_join(join), + } + } + + fn set_miter_limit(&mut self, limit: f32) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_miter_limit(limit), + } + } + + fn set_line_dash(&mut self, items: Vec<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_line_dash(items), + } + } + + fn set_line_dash_offset(&mut self, offset: f32) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_line_dash_offset(offset), + } + } + + fn set_transform(&mut self, matrix: &Transform2D<f32>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_transform(matrix), + } + } + + fn set_global_alpha(&mut self, alpha: f32) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_global_alpha(alpha), + } + } + + fn set_global_composition(&mut self, op: CompositionOrBlending) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_global_composition(op), + } + } + + fn set_shadow_offset_x(&mut self, value: f64) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_shadow_offset_x(value), + } + } + + fn set_shadow_offset_y(&mut self, value: f64) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_shadow_offset_y(value), + } + } + + fn set_shadow_blur(&mut self, value: f64) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_shadow_blur(value), + } + } + + fn set_shadow_color(&mut self, color: AbsoluteColor) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_shadow_color(color), + } + } + + fn set_font(&mut self, font_style: FontStyleStruct) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_font(font_style), + } + } + + fn set_text_align(&mut self, text_align: TextAlign) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_text_align(text_align), + } + } + + fn set_text_baseline(&mut self, text_baseline: TextBaseline) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.set_text_baseline(text_baseline), + } + } + + fn measure_text(&mut self, text: String) -> TextMetrics { + match self { + Canvas::Raqote(canvas_data) => canvas_data.measure_text(text), + } + } + + fn clip_path(&mut self, path: &[PathSegment]) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.clip_path(path), + } + } + + fn get_transform(&self) -> Transform2D<f32> { + match self { + Canvas::Raqote(canvas_data) => canvas_data.get_transform(), + } + } + + fn put_image_data(&mut self, unwrap: Vec<u8>, rect: Rect<u64>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.put_image_data(unwrap, rect), + } + } + + fn update_image_rendering(&mut self) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.update_image_rendering(), + } + } + + fn recreate(&mut self, size: Option<Size2D<u64>>) { + match self { + Canvas::Raqote(canvas_data) => canvas_data.recreate(size), + } + } +} diff --git a/components/canvas/lib.rs b/components/canvas/lib.rs index 86c291fdc87..91ab58b0e8b 100644 --- a/components/canvas/lib.rs +++ b/components/canvas/lib.rs @@ -4,6 +4,7 @@ #![deny(unsafe_code)] +mod backend; mod raqote_backend; pub mod canvas_data; diff --git a/components/canvas/raqote_backend.rs b/components/canvas/raqote_backend.rs index 12137e41f41..efe0ffd05b8 100644 --- a/components/canvas/raqote_backend.rs +++ b/components/canvas/raqote_backend.rs @@ -7,20 +7,19 @@ use std::collections::HashMap; use canvas_traits::canvas::*; use cssparser::color::clamp_unit_f32; -use euclid::Angle; use euclid::default::{Point2D, Rect, Size2D, Transform2D, Vector2D}; use font_kit::font::Font; use fonts::{ByteIndex, FontIdentifier, FontTemplateRefMethods}; use log::warn; -use lyon_geom::Arc; use range::Range; use raqote::PathOp; use style::color::AbsoluteColor; -use crate::canvas_data::{ - self, Backend, CanvasPaintState, Color, CompositionOp, DrawOptions, Filter, GenericDrawTarget, - GenericPathBuilder, GradientStop, GradientStops, Path, SourceSurface, StrokeOptions, TextRun, +use crate::backend::{ + Backend, DrawOptionsHelpers, GenericDrawTarget, GenericPathBuilder, PathHelpers, + PatternHelpers, StrokeOptionsHelpers, }; +use crate::canvas_data::{CanvasPaintState, Filter, TextRun}; thread_local! { /// The shared font cache used by all canvases that render on a thread. It would be nicer @@ -30,80 +29,85 @@ thread_local! { static SHARED_FONT_CACHE: RefCell<HashMap<FontIdentifier, Font>> = RefCell::default(); } -#[derive(Default)] -pub struct RaqoteBackend; +#[derive(Clone, Default)] +pub(crate) struct RaqoteBackend; impl Backend for RaqoteBackend { - fn get_composition_op(&self, opts: &DrawOptions) -> CompositionOp { - CompositionOp::Raqote(opts.as_raqote().blend_mode) + type Pattern<'a> = Pattern<'a>; + type StrokeOptions = raqote::StrokeStyle; + type Color = raqote::SolidSource; + type DrawOptions = raqote::DrawOptions; + type CompositionOp = raqote::BlendMode; + type DrawTarget = raqote::DrawTarget; + type PathBuilder = PathBuilder; + type SourceSurface = Vec<u8>; // TODO: See if we can avoid the alloc (probably?) + type Bytes<'a> = &'a [u8]; + type Path = raqote::Path; + type GradientStop = raqote::GradientStop; + type GradientStops = Vec<raqote::GradientStop>; + + fn get_composition_op(&self, opts: &Self::DrawOptions) -> Self::CompositionOp { + opts.blend_mode } - fn need_to_draw_shadow(&self, color: &Color) -> bool { - color.as_raqote().a != 0 + fn need_to_draw_shadow(&self, color: &Self::Color) -> bool { + color.a != 0 } - fn set_shadow_color(&mut self, color: AbsoluteColor, state: &mut CanvasPaintState<'_>) { - state.shadow_color = Color::Raqote(color.to_raqote_style()); + fn set_shadow_color(&mut self, color: AbsoluteColor, state: &mut CanvasPaintState<'_, Self>) { + state.shadow_color = color.to_raqote_style(); } fn set_fill_style( &mut self, style: FillOrStrokeStyle, - state: &mut CanvasPaintState<'_>, - _drawtarget: &dyn GenericDrawTarget, + state: &mut CanvasPaintState<'_, Self>, + _drawtarget: &Self::DrawTarget, ) { if let Some(pattern) = style.to_raqote_pattern() { - state.fill_style = canvas_data::Pattern::Raqote(pattern); + state.fill_style = pattern; } } fn set_stroke_style( &mut self, style: FillOrStrokeStyle, - state: &mut CanvasPaintState<'_>, - _drawtarget: &dyn GenericDrawTarget, + state: &mut CanvasPaintState<'_, Self>, + _drawtarget: &Self::DrawTarget, ) { if let Some(pattern) = style.to_raqote_pattern() { - state.stroke_style = canvas_data::Pattern::Raqote(pattern); + state.stroke_style = pattern; } } fn set_global_composition( &mut self, op: CompositionOrBlending, - state: &mut CanvasPaintState<'_>, + state: &mut CanvasPaintState<'_, Self>, ) { - state.draw_options.as_raqote_mut().blend_mode = op.to_raqote_style(); - } - - fn create_drawtarget(&self, size: Size2D<u64>) -> Box<dyn GenericDrawTarget> { - Box::new(raqote::DrawTarget::new( - size.width as i32, - size.height as i32, - )) + state.draw_options.blend_mode = op.to_raqote_style(); } - fn recreate_paint_state<'a>(&self, _state: &CanvasPaintState<'a>) -> CanvasPaintState<'a> { - CanvasPaintState::default() + fn create_drawtarget(&self, size: Size2D<u64>) -> Self::DrawTarget { + raqote::DrawTarget::new(size.width as i32, size.height as i32) } -} -impl Default for CanvasPaintState<'_> { - fn default() -> Self { + fn new_paint_state<'a>(&self) -> CanvasPaintState<'a, Self> { let pattern = Pattern::Color(255, 0, 0, 0); CanvasPaintState { - draw_options: DrawOptions::Raqote(raqote::DrawOptions::new()), - fill_style: canvas_data::Pattern::Raqote(pattern.clone()), - stroke_style: canvas_data::Pattern::Raqote(pattern), - stroke_opts: StrokeOptions::Raqote(Default::default()), + draw_options: raqote::DrawOptions::new(), + fill_style: pattern.clone(), + stroke_style: pattern, + stroke_opts: Default::default(), transform: Transform2D::identity(), shadow_offset_x: 0.0, shadow_offset_y: 0.0, shadow_blur: 0.0, - shadow_color: Color::Raqote(raqote::SolidSource::from_unpremultiplied_argb(0, 0, 0, 0)), + shadow_color: raqote::SolidSource::from_unpremultiplied_argb(0, 0, 0, 0), font_style: None, text_align: TextAlign::default(), text_baseline: TextBaseline::default(), + _backend: std::marker::PhantomData, } } } @@ -230,136 +234,122 @@ impl Repetition { } } -impl canvas_data::Pattern<'_> { - pub fn source(&self) -> raqote::Source { +pub fn source<'a>(pattern: &Pattern<'a>) -> raqote::Source<'a> { + match pattern { + Pattern::Color(a, r, g, b) => raqote::Source::Solid( + raqote::SolidSource::from_unpremultiplied_argb(*a, *r, *g, *b), + ), + Pattern::LinearGradient(pattern) => raqote::Source::new_linear_gradient( + pattern.gradient.clone(), + pattern.start, + pattern.end, + raqote::Spread::Pad, + ), + Pattern::RadialGradient(pattern) => raqote::Source::new_two_circle_radial_gradient( + pattern.gradient.clone(), + pattern.center1, + pattern.radius1, + pattern.center2, + pattern.radius2, + raqote::Spread::Pad, + ), + Pattern::Surface(pattern) => raqote::Source::Image( + pattern.image, + pattern.extend, + pattern.filter, + pattern.transform, + ), + } +} + +impl PatternHelpers for Pattern<'_> { + fn is_zero_size_gradient(&self) -> bool { match self { - canvas_data::Pattern::Raqote(pattern) => match pattern { - Pattern::Color(a, r, g, b) => raqote::Source::Solid( - raqote::SolidSource::from_unpremultiplied_argb(*a, *r, *g, *b), - ), - Pattern::LinearGradient(pattern) => raqote::Source::new_linear_gradient( - pattern.gradient.clone(), - pattern.start, - pattern.end, - raqote::Spread::Pad, - ), - Pattern::RadialGradient(pattern) => raqote::Source::new_two_circle_radial_gradient( - pattern.gradient.clone(), - pattern.center1, - pattern.radius1, - pattern.center2, - pattern.radius2, - raqote::Spread::Pad, - ), - Pattern::Surface(pattern) => raqote::Source::Image( - pattern.image, - pattern.extend, - pattern.filter, - pattern.transform, - ), + Pattern::RadialGradient(pattern) => { + let centers_equal = pattern.center1 == pattern.center2; + let radii_equal = pattern.radius1 == pattern.radius2; + (centers_equal && radii_equal) || pattern.gradient.stops.is_empty() }, + Pattern::LinearGradient(pattern) => { + (pattern.start == pattern.end) || pattern.gradient.stops.is_empty() + }, + Pattern::Color(..) | Pattern::Surface(..) => false, } } - pub fn is_zero_size_gradient(&self) -> bool { + + fn draw_rect(&self, rect: &Rect<f32>) -> Rect<f32> { match self { - canvas_data::Pattern::Raqote(pattern) => match pattern { - Pattern::RadialGradient(pattern) => { - let centers_equal = pattern.center1 == pattern.center2; - let radii_equal = pattern.radius1 == pattern.radius2; - (centers_equal && radii_equal) || pattern.gradient.stops.is_empty() - }, - Pattern::LinearGradient(pattern) => { - (pattern.start == pattern.end) || pattern.gradient.stops.is_empty() - }, - Pattern::Color(..) | Pattern::Surface(..) => false, + Pattern::Surface(pattern) => { + let pattern_rect = Rect::new(Point2D::origin(), pattern.size()); + let mut draw_rect = rect.intersection(&pattern_rect).unwrap_or(Rect::zero()); + + match pattern.repetition() { + Repetition::NoRepeat => { + draw_rect.size.width = draw_rect.size.width.min(pattern_rect.size.width); + draw_rect.size.height = draw_rect.size.height.min(pattern_rect.size.height); + }, + Repetition::RepeatX => { + draw_rect.size.width = rect.size.width; + draw_rect.size.height = draw_rect.size.height.min(pattern_rect.size.height); + }, + Repetition::RepeatY => { + draw_rect.size.height = rect.size.height; + draw_rect.size.width = draw_rect.size.width.min(pattern_rect.size.width); + }, + Repetition::Repeat => { + draw_rect = *rect; + }, + } + + draw_rect }, + Pattern::Color(..) | Pattern::LinearGradient(..) | Pattern::RadialGradient(..) => *rect, } } } -impl StrokeOptions { - pub fn set_line_width(&mut self, _val: f32) { - match self { - StrokeOptions::Raqote(options) => options.width = _val, - } - } - pub fn set_miter_limit(&mut self, _val: f32) { - match self { - StrokeOptions::Raqote(options) => options.miter_limit = _val, - } +impl StrokeOptionsHelpers for raqote::StrokeStyle { + fn set_line_width(&mut self, _val: f32) { + self.width = _val; } - pub fn set_line_join(&mut self, val: LineJoinStyle) { - match self { - StrokeOptions::Raqote(options) => options.join = val.to_raqote_style(), - } + fn set_miter_limit(&mut self, _val: f32) { + self.miter_limit = _val; } - pub fn set_line_cap(&mut self, val: LineCapStyle) { - match self { - StrokeOptions::Raqote(options) => options.cap = val.to_raqote_style(), - } + fn set_line_join(&mut self, val: LineJoinStyle) { + self.join = val.to_raqote_style(); } - pub fn set_line_dash(&mut self, items: Vec<f32>) { - match self { - StrokeOptions::Raqote(options) => options.dash_array = items, - } + fn set_line_cap(&mut self, val: LineCapStyle) { + self.cap = val.to_raqote_style(); } - pub fn set_line_dash_offset(&mut self, offset: f32) { - match self { - StrokeOptions::Raqote(options) => options.dash_offset = offset, - } + fn set_line_dash(&mut self, items: Vec<f32>) { + self.dash_array = items; } - pub fn as_raqote(&self) -> &raqote::StrokeStyle { - match self { - StrokeOptions::Raqote(options) => options, - } + fn set_line_dash_offset(&mut self, offset: f32) { + self.dash_offset = offset; } } -impl DrawOptions { - pub fn set_alpha(&mut self, val: f32) { - match self { - DrawOptions::Raqote(draw_options) => draw_options.alpha = val, - } - } - pub fn as_raqote(&self) -> &raqote::DrawOptions { - match self { - DrawOptions::Raqote(options) => options, - } - } - fn as_raqote_mut(&mut self) -> &mut raqote::DrawOptions { - match self { - DrawOptions::Raqote(options) => options, - } +impl DrawOptionsHelpers for raqote::DrawOptions { + fn set_alpha(&mut self, val: f32) { + self.alpha = val; } } -impl Path { - pub fn transformed_copy_to_builder( - &self, - transform: &Transform2D<f32>, - ) -> Box<dyn GenericPathBuilder> { - Box::new(PathBuilder(Some(raqote::PathBuilder::from( - self.as_raqote().clone().transform(transform), - )))) +impl PathHelpers<RaqoteBackend> for raqote::Path { + fn transformed_copy_to_builder(&self, transform: &Transform2D<f32>) -> PathBuilder { + PathBuilder(Some(raqote::PathBuilder::from( + self.clone().transform(transform), + ))) } - pub fn contains_point(&self, x: f64, y: f64, path_transform: &Transform2D<f32>) -> bool { - self.as_raqote() - .clone() + fn contains_point(&self, x: f64, y: f64, path_transform: &Transform2D<f32>) -> bool { + self.clone() .transform(path_transform) .contains_point(0.1, x as f32, y as f32) } - pub fn copy_to_builder(&self) -> Box<dyn GenericPathBuilder> { - Box::new(PathBuilder(Some(raqote::PathBuilder::from( - self.as_raqote().clone(), - )))) - } - - pub fn as_raqote(&self) -> &raqote::Path { - match self { - Path::Raqote(p) => p, - } + fn copy_to_builder(&self) -> PathBuilder { + PathBuilder(Some(raqote::PathBuilder::from(self.clone()))) } } @@ -373,7 +363,7 @@ fn create_gradient_stops(gradient_stops: Vec<CanvasGradientStop>) -> Vec<raqote: stops } -impl GenericDrawTarget for raqote::DrawTarget { +impl GenericDrawTarget<RaqoteBackend> for raqote::DrawTarget { fn clear_rect(&mut self, rect: &Rect<f32>) { let mut pb = raqote::PathBuilder::new(); pb.rect( @@ -385,59 +375,47 @@ impl GenericDrawTarget for raqote::DrawTarget { let mut options = raqote::DrawOptions::new(); options.blend_mode = raqote::BlendMode::Clear; let pattern = Pattern::Color(0, 0, 0, 0); - GenericDrawTarget::fill( - self, - &Path::Raqote(pb.finish()), - canvas_data::Pattern::Raqote(pattern), - &DrawOptions::Raqote(options), - ); + <Self as GenericDrawTarget<RaqoteBackend>>::fill(self, &pb.finish(), pattern, &options); } #[allow(unsafe_code)] fn copy_surface( &mut self, - surface: SourceSurface, + surface: <RaqoteBackend as Backend>::SourceSurface, source: Rect<i32>, destination: Point2D<i32>, ) { let mut dt = raqote::DrawTarget::new(source.size.width, source.size.height); - let data = surface.as_raqote(); + let data = surface; let s = unsafe { std::slice::from_raw_parts(data.as_ptr() as *const u32, data.len() / 4) }; dt.get_data_mut().copy_from_slice(s); raqote::DrawTarget::copy_surface(self, &dt, source.to_box2d(), destination); } - // TODO(pylbrecht) - // Somehow a duplicate of `create_gradient_stops()` with different types. - // It feels cumbersome to convert GradientStop back and forth just to use - // `create_gradient_stops()`, so I'll leave this here for now. - fn create_gradient_stops(&self, gradient_stops: Vec<GradientStop>) -> GradientStops { - let mut stops = gradient_stops - .into_iter() - .map(|item| *item.as_raqote()) - .collect::<Vec<raqote::GradientStop>>(); - // https://www.w3.org/html/test/results/2dcontext/annotated-spec/canvas.html#testrefs.2d.gradient.interpolate.overlap - stops.sort_by(|a, b| a.position.partial_cmp(&b.position).unwrap()); - GradientStops::Raqote(stops) - } - fn create_path_builder(&self) -> Box<dyn GenericPathBuilder> { - Box::new(PathBuilder::new()) + fn create_path_builder(&self) -> <RaqoteBackend as Backend>::PathBuilder { + PathBuilder::new() } - fn create_similar_draw_target(&self, size: &Size2D<i32>) -> Box<dyn GenericDrawTarget> { - Box::new(raqote::DrawTarget::new(size.width, size.height)) + fn create_similar_draw_target( + &self, + size: &Size2D<i32>, + ) -> <RaqoteBackend as Backend>::DrawTarget { + raqote::DrawTarget::new(size.width, size.height) } - fn create_source_surface_from_data(&self, data: &[u8]) -> Option<SourceSurface> { - Some(SourceSurface::Raqote(data.to_vec())) + fn create_source_surface_from_data( + &self, + data: &[u8], + ) -> Option<<RaqoteBackend as Backend>::SourceSurface> { + Some(data.to_vec()) } #[allow(unsafe_code)] fn draw_surface( &mut self, - surface: SourceSurface, + surface: <RaqoteBackend as Backend>::SourceSurface, dest: Rect<f64>, source: Rect<f64>, filter: Filter, - draw_options: &DrawOptions, + draw_options: &<RaqoteBackend as Backend>::DrawOptions, ) { - let surface_data = surface.as_raqote(); + let surface_data = surface; let image = raqote::Image { width: source.size.width as i32, height: source.size.height as i32, @@ -470,33 +448,29 @@ impl GenericDrawTarget for raqote::DrawTarget { dest.size.height as f32, ); - GenericDrawTarget::fill( - self, - &Path::Raqote(pb.finish()), - canvas_data::Pattern::Raqote(pattern), - draw_options, - ); + <Self as GenericDrawTarget<RaqoteBackend>>::fill(self, &pb.finish(), pattern, draw_options); } fn draw_surface_with_shadow( &self, - _surface: SourceSurface, + _surface: <RaqoteBackend as Backend>::SourceSurface, _dest: &Point2D<f32>, - _color: &Color, + _color: &<RaqoteBackend as Backend>::Color, _offset: &Vector2D<f32>, _sigma: f32, - _operator: CompositionOp, + _operator: <RaqoteBackend as Backend>::CompositionOp, ) { warn!("no support for drawing shadows"); } - fn fill(&mut self, path: &Path, pattern: canvas_data::Pattern, draw_options: &DrawOptions) { - match draw_options.as_raqote().blend_mode { + fn fill( + &mut self, + path: &<RaqoteBackend as Backend>::Path, + pattern: <RaqoteBackend as Backend>::Pattern<'_>, + draw_options: &<RaqoteBackend as Backend>::DrawOptions, + ) { + match draw_options.blend_mode { raqote::BlendMode::Src => { self.clear(raqote::SolidSource::from_unpremultiplied_argb(0, 0, 0, 0)); - self.fill( - path.as_raqote(), - &pattern.source(), - draw_options.as_raqote(), - ); + self.fill(path, &source(&pattern), draw_options); }, raqote::BlendMode::Clear | raqote::BlendMode::SrcAtop | @@ -505,26 +479,19 @@ impl GenericDrawTarget for raqote::DrawTarget { raqote::BlendMode::Xor | raqote::BlendMode::DstOver | raqote::BlendMode::SrcOver => { - self.fill( - path.as_raqote(), - &pattern.source(), - draw_options.as_raqote(), - ); + self.fill(path, &source(&pattern), draw_options); }, raqote::BlendMode::SrcIn | raqote::BlendMode::SrcOut | raqote::BlendMode::DstIn | raqote::BlendMode::DstAtop => { - let mut options = *draw_options.as_raqote(); + let mut options = *draw_options; self.push_layer_with_blend(1., options.blend_mode); options.blend_mode = raqote::BlendMode::SrcOver; - self.fill(path.as_raqote(), &pattern.source(), &options); + self.fill(path, &source(&pattern), &options); self.pop_layer(); }, - _ => warn!( - "unrecognized blend mode: {:?}", - draw_options.as_raqote().blend_mode - ), + _ => warn!("unrecognized blend mode: {:?}", draw_options.blend_mode), } } @@ -532,8 +499,8 @@ impl GenericDrawTarget for raqote::DrawTarget { &mut self, text_runs: Vec<TextRun>, start: Point2D<f32>, - pattern: &canvas_data::Pattern, - draw_options: &DrawOptions, + pattern: &<RaqoteBackend as Backend>::Pattern<'_>, + draw_options: &<RaqoteBackend as Backend>::DrawOptions, ) { let mut advance = 0.; for run in text_runs.iter() { @@ -581,8 +548,8 @@ impl GenericDrawTarget for raqote::DrawTarget { run.font.descriptor.pt_size.to_f32_px(), &ids, &positions, - &pattern.source(), - draw_options.as_raqote(), + &source(pattern), + draw_options, ); }) } @@ -591,8 +558,8 @@ impl GenericDrawTarget for raqote::DrawTarget { fn fill_rect( &mut self, rect: &Rect<f32>, - pattern: canvas_data::Pattern, - draw_options: Option<&DrawOptions>, + pattern: <RaqoteBackend as Backend>::Pattern<'_>, + draw_options: Option<&<RaqoteBackend as Backend>::DrawOptions>, ) { let mut pb = raqote::PathBuilder::new(); pb.rect( @@ -602,16 +569,16 @@ impl GenericDrawTarget for raqote::DrawTarget { rect.size.height, ); let draw_options = if let Some(options) = draw_options { - *options.as_raqote() + *options } else { raqote::DrawOptions::new() }; - GenericDrawTarget::fill( + <Self as GenericDrawTarget<RaqoteBackend>>::fill( self, - &Path::Raqote(pb.finish()), + &pb.finish(), pattern, - &DrawOptions::Raqote(draw_options), + &draw_options, ); } fn get_size(&self) -> Size2D<i32> { @@ -623,41 +590,36 @@ impl GenericDrawTarget for raqote::DrawTarget { fn pop_clip(&mut self) { self.pop_clip(); } - fn push_clip(&mut self, path: &Path) { - self.push_clip(path.as_raqote()); + fn push_clip(&mut self, path: &<RaqoteBackend as Backend>::Path) { + self.push_clip(path); } fn set_transform(&mut self, matrix: &Transform2D<f32>) { self.set_transform(matrix); } - fn snapshot(&self) -> SourceSurface { - SourceSurface::Raqote(self.snapshot_data().to_vec()) + fn surface(&self) -> <RaqoteBackend as Backend>::SourceSurface { + self.bytes().to_vec() } fn stroke( &mut self, - path: &Path, - pattern: canvas_data::Pattern, - stroke_options: &StrokeOptions, - draw_options: &DrawOptions, + path: &<RaqoteBackend as Backend>::Path, + pattern: Pattern<'_>, + stroke_options: &<RaqoteBackend as Backend>::StrokeOptions, + draw_options: &<RaqoteBackend as Backend>::DrawOptions, ) { - self.stroke( - path.as_raqote(), - &pattern.source(), - stroke_options.as_raqote(), - draw_options.as_raqote(), - ); + self.stroke(path, &source(&pattern), stroke_options, draw_options); } fn stroke_line( &mut self, start: Point2D<f32>, end: Point2D<f32>, - pattern: canvas_data::Pattern, - stroke_options: &StrokeOptions, - draw_options: &DrawOptions, + pattern: <RaqoteBackend as Backend>::Pattern<'_>, + stroke_options: &<RaqoteBackend as Backend>::StrokeOptions, + draw_options: &<RaqoteBackend as Backend>::DrawOptions, ) { let mut pb = raqote::PathBuilder::new(); pb.move_to(start.x, start.y); pb.line_to(end.x, end.y); - let mut stroke_options = stroke_options.as_raqote().clone(); + let mut stroke_options = stroke_options.clone(); let cap = match stroke_options.join { raqote::LineJoin::Round => raqote::LineCap::Round, _ => raqote::LineCap::Butt, @@ -666,17 +628,17 @@ impl GenericDrawTarget for raqote::DrawTarget { self.stroke( &pb.finish(), - &pattern.source(), + &source(&pattern), &stroke_options, - draw_options.as_raqote(), + draw_options, ); } fn stroke_rect( &mut self, rect: &Rect<f32>, - pattern: canvas_data::Pattern, - stroke_options: &StrokeOptions, - draw_options: &DrawOptions, + pattern: <RaqoteBackend as Backend>::Pattern<'_>, + stroke_options: &<RaqoteBackend as Backend>::StrokeOptions, + draw_options: &<RaqoteBackend as Backend>::DrawOptions, ) { let mut pb = raqote::PathBuilder::new(); pb.rect( @@ -688,13 +650,13 @@ impl GenericDrawTarget for raqote::DrawTarget { self.stroke( &pb.finish(), - &pattern.source(), - stroke_options.as_raqote(), - draw_options.as_raqote(), + &source(&pattern), + stroke_options, + draw_options, ); } #[allow(unsafe_code)] - fn snapshot_data(&self) -> &[u8] { + fn bytes(&self) -> &[u8] { let v = self.get_data(); unsafe { std::slice::from_raw_parts(v.as_ptr() as *const u8, std::mem::size_of_val(v)) } } @@ -709,7 +671,7 @@ impl Filter { } } -struct PathBuilder(Option<raqote::PathBuilder>); +pub(crate) struct PathBuilder(Option<raqote::PathBuilder>); impl PathBuilder { fn new() -> PathBuilder { @@ -717,7 +679,7 @@ impl PathBuilder { } } -impl GenericPathBuilder for PathBuilder { +impl GenericPathBuilder<RaqoteBackend> for PathBuilder { fn arc( &mut self, origin: Point2D<f32>, @@ -726,7 +688,8 @@ impl GenericPathBuilder for PathBuilder { end_angle: f32, anticlockwise: bool, ) { - self.ellipse( + <PathBuilder as GenericPathBuilder<RaqoteBackend>>::ellipse( + self, origin, radius, radius, @@ -736,6 +699,7 @@ impl GenericPathBuilder for PathBuilder { anticlockwise, ); } + fn bezier_curve_to( &mut self, control_point1: &Point2D<f32>, @@ -751,66 +715,10 @@ impl GenericPathBuilder for PathBuilder { control_point3.y, ); } + fn close(&mut self) { self.0.as_mut().unwrap().close(); } - fn ellipse( - &mut self, - origin: Point2D<f32>, - radius_x: f32, - radius_y: f32, - rotation_angle: f32, - start_angle: f32, - end_angle: f32, - anticlockwise: bool, - ) { - let mut start = Angle::radians(start_angle); - let mut end = Angle::radians(end_angle); - - // Wrap angles mod 2 * PI if necessary - if !anticlockwise && start > end + Angle::two_pi() || - anticlockwise && end > start + Angle::two_pi() - { - start = start.positive(); - end = end.positive(); - } - - // Calculate the total arc we're going to sweep. - let sweep = match anticlockwise { - true => { - if end - start == Angle::two_pi() { - -Angle::two_pi() - } else if end > start { - -(Angle::two_pi() - (end - start)) - } else { - -(start - end) - } - }, - false => { - if start - end == Angle::two_pi() { - Angle::two_pi() - } else if start > end { - Angle::two_pi() - (start - end) - } else { - end - start - } - }, - }; - - let arc: Arc<f32> = Arc { - center: origin, - radii: Vector2D::new(radius_x, radius_y), - start_angle: start, - sweep_angle: sweep, - x_rotation: Angle::radians(rotation_angle), - }; - - self.line_to(arc.from()); - - arc.for_each_quadratic_bezier(&mut |q| { - self.quadratic_curve_to(&q.ctrl, &q.to); - }); - } fn svg_arc( &mut self, @@ -840,9 +748,9 @@ impl GenericPathBuilder for PathBuilder { fn get_current_point(&mut self) -> Option<Point2D<f32>> { let path = self.finish(); - self.0 = Some(path.as_raqote().clone().into()); + self.0 = Some(path.clone().into()); - path.as_raqote().ops.iter().last().and_then(|op| match op { + path.ops.iter().last().and_then(|op| match op { PathOp::MoveTo(point) | PathOp::LineTo(point) => Some(Point2D::new(point.x, point.y)), PathOp::CubicTo(_, _, point) => Some(Point2D::new(point.x, point.y)), PathOp::QuadTo(_, point) => Some(Point2D::new(point.x, point.y)), @@ -864,8 +772,8 @@ impl GenericPathBuilder for PathBuilder { end_point.y, ); } - fn finish(&mut self) -> Path { - Path::Raqote(self.0.take().unwrap().finish()) + fn finish(&mut self) -> raqote::Path { + self.0.take().unwrap().finish() } } @@ -977,14 +885,6 @@ impl ToRaqotePattern<'_> for FillOrStrokeStyle { } } -impl Color { - fn as_raqote(&self) -> &raqote::SolidSource { - match self { - Color::Raqote(s) => s, - } - } -} - impl ToRaqoteStyle for AbsoluteColor { type Target = raqote::SolidSource; @@ -1054,19 +954,3 @@ impl ToRaqoteStyle for CompositionStyle { } } } - -impl SourceSurface { - fn as_raqote(&self) -> &Vec<u8> { - match self { - SourceSurface::Raqote(s) => s, - } - } -} - -impl GradientStop { - fn as_raqote(&self) -> &raqote::GradientStop { - match self { - GradientStop::Raqote(s) => s, - } - } -} diff --git a/components/constellation/constellation.rs b/components/constellation/constellation.rs index ad89c435717..f3a15d7708d 100644 --- a/components/constellation/constellation.rs +++ b/components/constellation/constellation.rs @@ -371,6 +371,7 @@ pub struct Constellation<STF, SWF> { mem_profiler_chan: mem::ProfilerChan, /// A single WebRender document the constellation operates on. + #[cfg(feature = "webgpu")] webrender_document: DocumentId, /// Webrender related objects required by WebGPU threads @@ -715,6 +716,7 @@ where phantom: PhantomData, webdriver: WebDriverData::new(), document_states: HashMap::new(), + #[cfg(feature = "webgpu")] webrender_document: state.webrender_document, #[cfg(feature = "webgpu")] webrender_wgpu, diff --git a/components/devtools/actors/inspector/node.rs b/components/devtools/actors/inspector/node.rs index 10ff9801844..a731f15b2d8 100644 --- a/components/devtools/actors/inspector/node.rs +++ b/components/devtools/actors/inspector/node.rs @@ -78,6 +78,18 @@ pub struct NodeActorMsg { shadow_root_mode: Option<String>, traits: HashMap<String, ()>, attrs: Vec<AttrMsg>, + + /// The `DOCTYPE` name if this is a `DocumentType` node, `None` otherwise + #[serde(skip_serializing_if = "Option::is_none")] + name: Option<String>, + + /// The `DOCTYPE` public identifier if this is a `DocumentType` node, `None` otherwise + #[serde(skip_serializing_if = "Option::is_none")] + public_id: Option<String>, + + /// The `DOCTYPE` system identifier if this is a `DocumentType` node, `None` otherwise + #[serde(skip_serializing_if = "Option::is_none")] + system_id: Option<String>, } pub struct NodeActor { @@ -276,6 +288,9 @@ impl NodeInfoToProtocol for NodeInfo { value: attr.value, }) .collect(), + name: self.doctype_name, + public_id: self.doctype_public_identifier, + system_id: self.doctype_system_identifier, } } } diff --git a/components/layout/dom.rs b/components/layout/dom.rs index add4b3ac2d5..8f2697e670a 100644 --- a/components/layout/dom.rs +++ b/components/layout/dom.rs @@ -15,8 +15,7 @@ use script_layout_interface::wrapper_traits::{ LayoutDataTrait, LayoutNode, ThreadSafeLayoutElement, ThreadSafeLayoutNode, }; use script_layout_interface::{ - GenericLayoutDataTrait, HTMLCanvasDataSource, LayoutElementType, - LayoutNodeType as ScriptLayoutNodeType, + GenericLayoutDataTrait, LayoutElementType, LayoutNodeType as ScriptLayoutNodeType, }; use servo_arc::Arc as ServoArc; use style::properties::ComputedValues; @@ -29,7 +28,7 @@ use crate::flow::BlockLevelBox; use crate::flow::inline::InlineItem; use crate::fragment_tree::Fragment; use crate::geom::PhysicalSize; -use crate::replaced::{CanvasInfo, CanvasSource}; +use crate::replaced::CanvasInfo; use crate::table::TableLevelBox; use crate::taffy::TaffyItemBox; @@ -220,12 +219,7 @@ where fn as_canvas(self) -> Option<(CanvasInfo, PhysicalSize<f64>)> { let node = self.to_threadsafe(); let canvas_data = node.canvas_data()?; - let source = match canvas_data.source { - HTMLCanvasDataSource::WebGL(texture_id) => CanvasSource::WebGL(texture_id), - HTMLCanvasDataSource::Image(image_key) => CanvasSource::Image(image_key), - HTMLCanvasDataSource::WebGPU(image_key) => CanvasSource::WebGPU(image_key), - HTMLCanvasDataSource::Empty => CanvasSource::Empty, - }; + let source = canvas_data.source; Some(( CanvasInfo { source }, PhysicalSize::new(canvas_data.width.into(), canvas_data.height.into()), diff --git a/components/layout/flexbox/layout.rs b/components/layout/flexbox/layout.rs index a5540123681..e69b792e272 100644 --- a/components/layout/flexbox/layout.rs +++ b/components/layout/flexbox/layout.rs @@ -49,7 +49,6 @@ use crate::{ struct FlexContext<'a> { config: FlexContainerConfig, layout_context: &'a LayoutContext<'a>, - positioning_context: &'a mut PositioningContext, containing_block: &'a ContainingBlock<'a>, // For items container_inner_size_constraint: FlexRelativeVec2<SizeConstraint>, } @@ -657,7 +656,6 @@ impl FlexContainer { let mut flex_context = FlexContext { config: self.config.clone(), layout_context, - positioning_context, containing_block, // https://drafts.csswg.org/css-flexbox/#definite-sizes container_inner_size_constraint: self.config.flex_axis.vec2_to_flex_relative( @@ -1775,16 +1773,7 @@ impl FlexItem<'_> { ) -> Option<FlexItemLayoutResult> { let containing_block = flex_context.containing_block; let independent_formatting_context = &self.box_.independent_formatting_context; - let mut positioning_context = independent_formatting_context - .new_positioning_context() - .unwrap_or_else(|| { - PositioningContext::new_for_subtree( - flex_context - .positioning_context - .collects_for_nearest_positioned_ancestor(), - ) - }); - + let mut positioning_context = PositioningContext::default(); let item_writing_mode = independent_formatting_context.style().writing_mode; let item_is_horizontal = item_writing_mode.is_horizontal(); let flex_axis = flex_context.config.flex_axis; @@ -2617,17 +2606,7 @@ impl FlexItemBox { cross_size_stretches_to_container_size: bool, intrinsic_sizing_mode: IntrinsicSizingMode, ) -> Au { - let mut positioning_context = self - .independent_formatting_context - .new_positioning_context() - .unwrap_or_else(|| { - PositioningContext::new_for_subtree( - flex_context - .positioning_context - .collects_for_nearest_positioned_ancestor(), - ) - }); - + let mut positioning_context = PositioningContext::default(); let style = self.independent_formatting_context.style(); match &self.independent_formatting_context.contents { IndependentFormattingContextContents::Replaced(replaced) => { diff --git a/components/layout/flow/inline/line.rs b/components/layout/flow/inline/line.rs index e65eaed2367..80bab1080ed 100644 --- a/components/layout/flow/inline/line.rs +++ b/components/layout/flow/inline/line.rs @@ -331,7 +331,7 @@ impl LineItemLayout<'_, '_> { self.calculate_inline_box_block_start(inline_box_state, space_above_baseline); let positioning_context_or_start_offset_in_parent = - match inline_box.base.new_positioning_context() { + match PositioningContext::new_for_layout_box_base(&inline_box.base) { Some(positioning_context) => Either::Left(positioning_context), None => Either::Right(self.current_positioning_context_mut().len()), }; diff --git a/components/layout/flow/inline/mod.rs b/components/layout/flow/inline/mod.rs index 25fbaa324b1..2023f4e7174 100644 --- a/components/layout/flow/inline/mod.rs +++ b/components/layout/flow/inline/mod.rs @@ -2004,9 +2004,7 @@ impl IndependentFormattingContext { bidi_level: Level, ) { // We need to know the inline size of the atomic before deciding whether to do the line break. - let mut child_positioning_context = self - .new_positioning_context() - .unwrap_or_else(|| PositioningContext::new_for_subtree(true)); + let mut child_positioning_context = PositioningContext::default(); let IndependentFloatOrAtomicLayoutResult { mut fragment, baselines, diff --git a/components/layout/flow/mod.rs b/components/layout/flow/mod.rs index 983282dc389..772b150ae1c 100644 --- a/components/layout/flow/mod.rs +++ b/components/layout/flow/mod.rs @@ -689,16 +689,13 @@ fn layout_block_level_children_in_parallel( placement_state: &mut PlacementState, ignore_block_margins_for_stretch: LogicalSides1D<bool>, ) -> Vec<Fragment> { - let collects_for_nearest_positioned_ancestor = - positioning_context.collects_for_nearest_positioned_ancestor(); let mut layout_results: Vec<(Fragment, PositioningContext)> = Vec::with_capacity(child_boxes.len()); child_boxes .par_iter() .map(|child_box| { - let mut child_positioning_context = - PositioningContext::new_for_subtree(collects_for_nearest_positioned_ancestor); + let mut child_positioning_context = PositioningContext::default(); let fragment = child_box.borrow().layout( layout_context, &mut child_positioning_context, diff --git a/components/layout/flow/root.rs b/components/layout/flow/root.rs index c6498eeed63..bb9ff1d337a 100644 --- a/components/layout/flow/root.rs +++ b/components/layout/flow/root.rs @@ -385,8 +385,7 @@ impl BoxTree { style, }; - let mut positioning_context = - PositioningContext::new_for_containing_block_for_all_descendants(); + let mut positioning_context = PositioningContext::default(); let independent_layout = self.root.layout( layout_context, &mut positioning_context, diff --git a/components/layout/formatting_contexts.rs b/components/layout/formatting_contexts.rs index 4661c44592c..4982d0dae1a 100644 --- a/components/layout/formatting_contexts.rs +++ b/components/layout/formatting_contexts.rs @@ -295,10 +295,7 @@ impl IndependentNonReplacedContents { ); } - let mut child_positioning_context = PositioningContext::new_for_subtree( - positioning_context.collects_for_nearest_positioned_ancestor(), - ); - + let mut child_positioning_context = PositioningContext::default(); let result = self.layout_without_caching( layout_context, &mut child_positioning_context, diff --git a/components/layout/positioned.rs b/components/layout/positioned.rs index 6bfe2af87ef..ff361396fa3 100644 --- a/components/layout/positioned.rs +++ b/components/layout/positioned.rs @@ -43,16 +43,6 @@ pub(crate) struct AbsolutelyPositionedBox { } #[derive(Clone, MallocSizeOf)] -pub(crate) struct PositioningContext { - for_nearest_positioned_ancestor: Option<Vec<HoistedAbsolutelyPositionedBox>>, - - // For nearest `containing block for all descendants` as defined by the CSS transforms - // spec. - // https://www.w3.org/TR/css-transforms-1/#containing-block-for-all-descendants - for_nearest_containing_block_for_all_descendants: Vec<HoistedAbsolutelyPositionedBox>, -} - -#[derive(Clone, MallocSizeOf)] pub(crate) struct HoistedAbsolutelyPositionedBox { absolutely_positioned_box: ArcRefCell<AbsolutelyPositionedBox>, @@ -104,55 +94,26 @@ impl AbsolutelyPositionedBox { } } -impl IndependentFormattingContext { - #[inline] - pub(crate) fn new_positioning_context(&self) -> Option<PositioningContext> { - self.base.new_positioning_context() - } -} - -impl LayoutBoxBase { - #[inline] - pub(crate) fn new_positioning_context(&self) -> Option<PositioningContext> { - PositioningContext::new_for_style(&self.style, &self.base_fragment_info.flags) - } +#[derive(Clone, Default, MallocSizeOf)] +pub(crate) struct PositioningContext { + absolutes: Vec<HoistedAbsolutelyPositionedBox>, } impl PositioningContext { - pub(crate) fn new_for_containing_block_for_all_descendants() -> Self { - Self { - for_nearest_positioned_ancestor: None, - for_nearest_containing_block_for_all_descendants: Vec::new(), - } - } - - /// Create a [PositioningContext] to use for laying out a subtree. The idea is that - /// when subtree layout is finished, the newly hoisted boxes can be processed - /// (normally adjusting their static insets) and then appended to the parent - /// [PositioningContext]. - pub(crate) fn new_for_subtree(collects_for_nearest_positioned_ancestor: bool) -> Self { - Self { - for_nearest_positioned_ancestor: if collects_for_nearest_positioned_ancestor { - Some(Vec::new()) - } else { - None - }, - for_nearest_containing_block_for_all_descendants: Vec::new(), - } - } - - pub(crate) fn collects_for_nearest_positioned_ancestor(&self) -> bool { - self.for_nearest_positioned_ancestor.is_some() + #[inline] + pub(crate) fn new_for_layout_box_base(layout_box_base: &LayoutBoxBase) -> Option<Self> { + Self::new_for_style_and_fragment_flags( + &layout_box_base.style, + &layout_box_base.base_fragment_info.flags, + ) } - fn new_for_style(style: &ComputedValues, flags: &FragmentFlags) -> Option<Self> { - if style.establishes_containing_block_for_all_descendants(*flags) { - Some(Self::new_for_containing_block_for_all_descendants()) - } else if style.establishes_containing_block_for_absolute_descendants(*flags) { - Some(Self { - for_nearest_positioned_ancestor: Some(Vec::new()), - for_nearest_containing_block_for_all_descendants: Vec::new(), - }) + fn new_for_style_and_fragment_flags( + style: &ComputedValues, + flags: &FragmentFlags, + ) -> Option<Self> { + if style.establishes_containing_block_for_absolute_descendants(*flags) { + Some(Self::default()) } else { None } @@ -195,20 +156,9 @@ impl PositioningContext { offset: &PhysicalVec<Au>, index: PositioningContextLength, ) { - if let Some(hoisted_boxes) = self.for_nearest_positioned_ancestor.as_mut() { - hoisted_boxes - .iter_mut() - .skip(index.for_nearest_positioned_ancestor) - .for_each(|hoisted_fragment| { - hoisted_fragment - .fragment - .borrow_mut() - .adjust_offsets(offset) - }) - } - self.for_nearest_containing_block_for_all_descendants + self.absolutes .iter_mut() - .skip(index.for_nearest_containing_block_for_all_descendants) + .skip(index.0) .for_each(|hoisted_fragment| { hoisted_fragment .fragment @@ -227,19 +177,23 @@ impl PositioningContext { base: &LayoutBoxBase, fragment_layout_fn: impl FnOnce(&mut Self) -> BoxFragment, ) -> BoxFragment { - // Try to create a context, but if one isn't necessary, simply create the fragment - // using the given closure and the current `PositioningContext`. - let mut new_context = match base.new_positioning_context() { - Some(new_context) => new_context, - None => return fragment_layout_fn(self), - }; + // If a new `PositioningContext` isn't necessary, simply create the fragment using + // the given closure and the current `PositioningContext`. + let establishes_containing_block_for_absolutes = base + .style + .establishes_containing_block_for_absolute_descendants(base.base_fragment_info.flags); + if !establishes_containing_block_for_absolutes { + return fragment_layout_fn(self); + } + let mut new_context = PositioningContext::default(); let mut new_fragment = fragment_layout_fn(&mut new_context); - new_context.layout_collected_children(layout_context, &mut new_fragment); - // If the new context has any hoisted boxes for the nearest containing block for - // pass them up the tree. + // Lay out all of the absolutely positioned children for this fragment, and, if it + // isn't a containing block for fixed elements, then pass those up to the parent. + new_context.layout_collected_children(layout_context, &mut new_fragment); self.append(new_context); + if base.style.clone_position() == Position::Relative { new_fragment.content_rect.origin += relative_adjustement(&base.style, containing_block) .to_physical_vector(containing_block.style.writing_mode) @@ -248,13 +202,61 @@ impl PositioningContext { new_fragment } + fn take_boxes_for_fragment( + &mut self, + new_fragment: &BoxFragment, + boxes_to_layout_out: &mut Vec<HoistedAbsolutelyPositionedBox>, + boxes_to_continue_hoisting_out: &mut Vec<HoistedAbsolutelyPositionedBox>, + ) { + debug_assert!( + new_fragment + .style + .establishes_containing_block_for_absolute_descendants(new_fragment.base.flags) + ); + + if new_fragment + .style + .establishes_containing_block_for_all_descendants(new_fragment.base.flags) + { + boxes_to_layout_out.append(&mut self.absolutes); + return; + } + + // TODO: This could potentially use `extract_if` when that is stabilized. + let (mut boxes_to_layout, mut boxes_to_continue_hoisting) = self + .absolutes + .drain(..) + .partition(|hoisted_box| hoisted_box.position() != Position::Fixed); + boxes_to_layout_out.append(&mut boxes_to_layout); + boxes_to_continue_hoisting_out.append(&mut boxes_to_continue_hoisting); + } + // Lay out the hoisted boxes collected into this `PositioningContext` and add them // to the given `BoxFragment`. - pub fn layout_collected_children( + pub(crate) fn layout_collected_children( &mut self, layout_context: &LayoutContext, new_fragment: &mut BoxFragment, ) { + if self.absolutes.is_empty() { + return; + } + + // Sometimes we create temporary PositioningContexts just to collect hoisted absolutes and + // then these are processed later. In that case and if this fragment doesn't establish a + // containing block for absolutes at all, we just do nothing. All hoisted fragments will + // later be passed up to a parent PositioningContext. + // + // Handling this case here, when the PositioningContext is completely ineffectual other than + // as a temporary container for hoisted boxes, means that callers can execute less conditional + // code. + if !new_fragment + .style + .establishes_containing_block_for_absolute_descendants(new_fragment.base.flags) + { + return; + } + let padding_rect = PhysicalRect::new( // Ignore the content rect’s position in its own containing block: PhysicalPoint::origin(), @@ -268,83 +270,58 @@ impl PositioningContext { style: &new_fragment.style, }; - let take_hoisted_boxes_pending_layout = - |context: &mut Self| match context.for_nearest_positioned_ancestor.as_mut() { - Some(fragments) => mem::take(fragments), - None => mem::take(&mut context.for_nearest_containing_block_for_all_descendants), - }; + let mut fixed_position_boxes_to_hoist = Vec::new(); + let mut boxes_to_layout = Vec::new(); + self.take_boxes_for_fragment( + new_fragment, + &mut boxes_to_layout, + &mut fixed_position_boxes_to_hoist, + ); - // Loop because it’s possible that we discover (the static position of) - // more absolutely-positioned boxes while doing layout for others. - let mut hoisted_boxes = take_hoisted_boxes_pending_layout(self); - let mut laid_out_child_fragments = Vec::new(); - while !hoisted_boxes.is_empty() { + // Laying out a `position: absolute` child (which only establishes a containing block for + // `position: absolute` descendants) can result in more `position: fixed` descendants + // collecting in `self.absolutes`. We need to loop here in order to keep either laying them + // out or putting them into `fixed_position_boxes_to_hoist`. We know there aren't any more + // when `self.absolutes` is empty. + while !boxes_to_layout.is_empty() { HoistedAbsolutelyPositionedBox::layout_many( layout_context, - &mut hoisted_boxes, - &mut laid_out_child_fragments, - &mut self.for_nearest_containing_block_for_all_descendants, + std::mem::take(&mut boxes_to_layout), + &mut new_fragment.children, + &mut self.absolutes, &containing_block, new_fragment.padding, ); - hoisted_boxes = take_hoisted_boxes_pending_layout(self); - } - new_fragment.children.extend(laid_out_child_fragments); - } - - pub(crate) fn push(&mut self, box_: HoistedAbsolutelyPositionedBox) { - if let Some(nearest) = &mut self.for_nearest_positioned_ancestor { - let position = box_ - .absolutely_positioned_box - .borrow() - .context - .style() - .clone_position(); - match position { - Position::Fixed => {}, // fall through - Position::Absolute => return nearest.push(box_), - Position::Static | Position::Relative | Position::Sticky => unreachable!(), - } + self.take_boxes_for_fragment( + new_fragment, + &mut boxes_to_layout, + &mut fixed_position_boxes_to_hoist, + ); } - self.for_nearest_containing_block_for_all_descendants - .push(box_) + + // We replace here instead of simply preserving these in `take_boxes_for_fragment` + // so that we don't have to continually re-iterate over them when laying out in the + // loop above. + self.absolutes = fixed_position_boxes_to_hoist; } - pub(crate) fn is_empty(&self) -> bool { - self.for_nearest_containing_block_for_all_descendants - .is_empty() && - self.for_nearest_positioned_ancestor - .as_ref() - .is_none_or(|vector| vector.is_empty()) + pub(crate) fn push(&mut self, hoisted_box: HoistedAbsolutelyPositionedBox) { + debug_assert!(matches!( + hoisted_box.position(), + Position::Absolute | Position::Fixed + )); + self.absolutes.push(hoisted_box); } - pub(crate) fn append(&mut self, other: Self) { - if other.is_empty() { + pub(crate) fn append(&mut self, mut other: Self) { + if other.absolutes.is_empty() { return; } - - vec_append_owned( - &mut self.for_nearest_containing_block_for_all_descendants, - other.for_nearest_containing_block_for_all_descendants, - ); - - match ( - self.for_nearest_positioned_ancestor.as_mut(), - other.for_nearest_positioned_ancestor, - ) { - (Some(us), Some(them)) => vec_append_owned(us, them), - (None, Some(them)) => { - // This is the case where we have laid out the absolute children in a containing - // block for absolutes and we then are passing up the fixed-position descendants - // to the containing block for all descendants. - vec_append_owned( - &mut self.for_nearest_containing_block_for_all_descendants, - them, - ); - }, - (None, None) => {}, - _ => unreachable!(), + if self.absolutes.is_empty() { + self.absolutes = other.absolutes; + } else { + self.absolutes.append(&mut other.absolutes) } } @@ -354,19 +331,16 @@ impl PositioningContext { initial_containing_block: &DefiniteContainingBlock, fragments: &mut Vec<Fragment>, ) { - debug_assert!(self.for_nearest_positioned_ancestor.is_none()); - - // Loop because it’s possible that we discover (the static position of) - // more absolutely-positioned boxes while doing layout for others. - while !self - .for_nearest_containing_block_for_all_descendants - .is_empty() - { + // Laying out a `position: absolute` child (which only establishes a containing block for + // `position: absolute` descendants) can result in more `position: fixed` descendants + // collecting in `self.absolutes`. We need to loop here in order to keep laying them out. We + // know there aren't any more when `self.absolutes` is empty. + while !self.absolutes.is_empty() { HoistedAbsolutelyPositionedBox::layout_many( layout_context, - &mut mem::take(&mut self.for_nearest_containing_block_for_all_descendants), + mem::take(&mut self.absolutes), fragments, - &mut self.for_nearest_containing_block_for_all_descendants, + &mut self.absolutes, initial_containing_block, Default::default(), ) @@ -375,58 +349,46 @@ impl PositioningContext { /// Get the length of this [PositioningContext]. pub(crate) fn len(&self) -> PositioningContextLength { - PositioningContextLength { - for_nearest_positioned_ancestor: self - .for_nearest_positioned_ancestor - .as_ref() - .map_or(0, |vec| vec.len()), - for_nearest_containing_block_for_all_descendants: self - .for_nearest_containing_block_for_all_descendants - .len(), - } + PositioningContextLength(self.absolutes.len()) } /// Truncate this [PositioningContext] to the given [PositioningContextLength]. This /// is useful for "unhoisting" boxes in this context and returning it to the state at /// the time that [`PositioningContext::len()`] was called. pub(crate) fn truncate(&mut self, length: &PositioningContextLength) { - if let Some(vec) = self.for_nearest_positioned_ancestor.as_mut() { - vec.truncate(length.for_nearest_positioned_ancestor); - } - self.for_nearest_containing_block_for_all_descendants - .truncate(length.for_nearest_containing_block_for_all_descendants); + self.absolutes.truncate(length.0) } } /// A data structure which stores the size of a positioning context. #[derive(Clone, Copy, Debug, PartialEq)] -pub(crate) struct PositioningContextLength { - /// The number of boxes that will be hoisted the the nearest positioned ancestor for - /// layout. - for_nearest_positioned_ancestor: usize, - /// The number of boxes that will be hoisted the the nearest ancestor which - /// establishes a containing block for all descendants for layout. - for_nearest_containing_block_for_all_descendants: usize, -} +pub(crate) struct PositioningContextLength(usize); impl Zero for PositioningContextLength { fn zero() -> Self { - PositioningContextLength { - for_nearest_positioned_ancestor: 0, - for_nearest_containing_block_for_all_descendants: 0, - } + Self(0) } fn is_zero(&self) -> bool { - self.for_nearest_positioned_ancestor == 0 && - self.for_nearest_containing_block_for_all_descendants == 0 + self.0.is_zero() } } impl HoistedAbsolutelyPositionedBox { + fn position(&self) -> Position { + let position = self + .absolutely_positioned_box + .borrow() + .context + .style() + .clone_position(); + assert!(position == Position::Fixed || position == Position::Absolute); + position + } + pub(crate) fn layout_many( layout_context: &LayoutContext, - boxes: &mut [Self], + mut boxes: Vec<Self>, fragments: &mut Vec<Fragment>, for_nearest_containing_block_for_all_descendants: &mut Vec<HoistedAbsolutelyPositionedBox>, containing_block: &DefiniteContainingBlock, @@ -473,7 +435,7 @@ impl HoistedAbsolutelyPositionedBox { pub(crate) fn layout( &mut self, layout_context: &LayoutContext, - for_nearest_containing_block_for_all_descendants: &mut Vec<HoistedAbsolutelyPositionedBox>, + hoisted_absolutes_from_children: &mut Vec<HoistedAbsolutelyPositionedBox>, containing_block: &DefiniteContainingBlock, containing_block_padding: PhysicalSides<Au>, ) -> Fragment { @@ -596,7 +558,7 @@ impl HoistedAbsolutelyPositionedBox { .sizes })); - let mut positioning_context = context.new_positioning_context().unwrap(); + let mut positioning_context = PositioningContext::default(); let mut new_fragment = { let content_size: LogicalVec2<Au>; let fragments; @@ -709,6 +671,10 @@ impl HoistedAbsolutelyPositionedBox { ) .with_specific_layout_info(specific_layout_info) }; + + // This is an absolutely positioned element, which means it also establishes a + // containing block for absolutes. We lay out any absolutely positioned children + // here and pass the rest to `hoisted_absolutes_from_children.` positioning_context.layout_collected_children(layout_context, &mut new_fragment); // Any hoisted boxes that remain in this positioning context are going to be hoisted @@ -721,8 +687,7 @@ impl HoistedAbsolutelyPositionedBox { PositioningContextLength::zero(), ); - for_nearest_containing_block_for_all_descendants - .extend(positioning_context.for_nearest_containing_block_for_all_descendants); + hoisted_absolutes_from_children.extend(positioning_context.absolutes); let fragment = Fragment::Box(ArcRefCell::new(new_fragment)); context.base.set_fragment(fragment.clone()); @@ -1024,14 +989,6 @@ impl AbsoluteAxisSolver<'_> { } } -fn vec_append_owned<T>(a: &mut Vec<T>, mut b: Vec<T>) { - if a.is_empty() { - *a = b - } else { - a.append(&mut b) - } -} - /// <https://drafts.csswg.org/css2/visuren.html#relative-positioning> pub(crate) fn relative_adjustement( style: &ComputedValues, diff --git a/components/layout/replaced.rs b/components/layout/replaced.rs index b82fb947074..bbebc57aa97 100644 --- a/components/layout/replaced.rs +++ b/components/layout/replaced.rs @@ -3,7 +3,6 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ use std::cell::LazyCell; -use std::fmt; use std::sync::Arc; use app_units::Au; @@ -96,33 +95,9 @@ impl NaturalSizes { } } -#[derive(MallocSizeOf)] -pub(crate) enum CanvasSource { - WebGL(ImageKey), - Image(ImageKey), - WebGPU(ImageKey), - /// transparent black - Empty, -} - -impl fmt::Debug for CanvasSource { - fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!( - f, - "{}", - match *self { - CanvasSource::WebGL(_) => "WebGL", - CanvasSource::Image(_) => "Image", - CanvasSource::WebGPU(_) => "WebGPU", - CanvasSource::Empty => "Empty", - } - ) - } -} - #[derive(Debug, MallocSizeOf)] pub(crate) struct CanvasInfo { - pub source: CanvasSource, + pub source: Option<ImageKey>, } #[derive(Debug, MallocSizeOf)] @@ -388,12 +363,10 @@ impl ReplacedContents { return vec![]; } - let image_key = match canvas_info.source { - CanvasSource::WebGL(image_key) => image_key, - CanvasSource::WebGPU(image_key) => image_key, - CanvasSource::Image(image_key) => image_key, - CanvasSource::Empty => return vec![], + let Some(image_key) = canvas_info.source else { + return vec![]; }; + vec![Fragment::Image(ArcRefCell::new(ImageFragment { base: self.base_fragment_info.into(), style: style.clone(), diff --git a/components/layout/style_ext.rs b/components/layout/style_ext.rs index 023db6b07f1..68a4481a2be 100644 --- a/components/layout/style_ext.rs +++ b/components/layout/style_ext.rs @@ -712,15 +712,19 @@ impl ComputedValuesExt for ComputedValues { // From <https://www.w3.org/TR/css-transforms-1/#transform-rendering> // > For elements whose layout is governed by the CSS box model, any value other than // > `none` for the `transform` property results in the creation of a stacking context. + // + // From <https://www.w3.org/TR/css-transforms-2/#individual-transforms> + // > all other values […] create a stacking context and containing block for all + // > descendants, per usual for transforms. + // + // From <https://www.w3.org/TR/css-transforms-2/#perspective-property> + // > any value other than none establishes a stacking context. + // // From <https://www.w3.org/TR/css-transforms-2/#transform-style-property> // > A computed value of `preserve-3d` for `transform-style` on a transformable element // > establishes both a stacking context and a containing block for all descendants. - // From <https://www.w3.org/TR/css-transforms-2/#perspective-property> - // > any value other than none establishes a stacking context. - // TODO: handle individual transform properties (`translate`, `scale` and `rotate`). - // <https://www.w3.org/TR/css-transforms-2/#individual-transforms> if self.is_transformable(fragment_flags) && - (!self.get_box().transform.0.is_empty() || + (self.has_transform_or_perspective_style() || self.get_box().transform_style == ComputedTransformStyle::Preserve3d || will_change_bits .intersects(WillChangeBits::TRANSFORM | WillChangeBits::PERSPECTIVE)) diff --git a/components/layout/table/construct.rs b/components/layout/table/construct.rs index f20360d3b56..56e11320be4 100644 --- a/components/layout/table/construct.rs +++ b/components/layout/table/construct.rs @@ -1019,15 +1019,16 @@ where DisplayLayoutInternal::TableCell => { // This value will already have filtered out rowspan=0 // in quirks mode, so we don't have to worry about that. - // - // The HTML specification limits the parsed value of `rowspan` to - // 65534 and `colspan` to 1000, so we also enforce the same limits - // when dealing with arbitrary DOM elements (perhaps created via - // script). let (rowspan, colspan) = if info.pseudo_element_type.is_none() { let node = info.node.to_threadsafe(); - let rowspan = node.get_rowspan().unwrap_or(1).min(65534) as usize; - let colspan = node.get_colspan().unwrap_or(1).min(1000) as usize; + let rowspan = node.get_rowspan().unwrap_or(1) as usize; + let colspan = node.get_colspan().unwrap_or(1) as usize; + + // The HTML specification clamps value of `rowspan` to [0, 65534] and + // `colspan` to [1, 1000]. + assert!((1..=1000).contains(&colspan)); + assert!((0..=65534).contains(&rowspan)); + (rowspan, colspan) } else { (1, 1) @@ -1140,21 +1141,19 @@ fn add_column<'dom, Node: NodeExt<'dom>>( is_anonymous: bool, ) -> ArcRefCell<TableTrack> { let span = if column_info.pseudo_element_type.is_none() { - column_info - .node - .to_threadsafe() - .get_span() - .unwrap_or(1) - .min(1000) as usize + column_info.node.to_threadsafe().get_span().unwrap_or(1) } else { 1 }; + // The HTML specification clamps value of `span` for `<col>` to [1, 1000]. + assert!((1..=1000).contains(&span)); + let column = ArcRefCell::new(TableTrack { base: LayoutBoxBase::new(column_info.into(), column_info.style.clone()), group_index, is_anonymous, }); - collection.extend(repeat(column.clone()).take(span)); + collection.extend(repeat(column.clone()).take(span as usize)); column } diff --git a/components/layout/table/layout.rs b/components/layout/table/layout.rs index 0cbe3e9ca76..2efe339837e 100644 --- a/components/layout/table/layout.rs +++ b/components/layout/table/layout.rs @@ -1068,7 +1068,6 @@ impl<'a> TableLayout<'a> { &mut self, layout_context: &LayoutContext, containing_block_for_table: &ContainingBlock, - parent_positioning_context: &mut PositioningContext, ) { self.cells_laid_out = self .table @@ -1076,30 +1075,6 @@ impl<'a> TableLayout<'a> { .par_iter() .enumerate() .map(|(row_index, row_slots)| { - // When building the PositioningContext for this cell, we want it to have the same - // configuration for whatever PositioningContext the contents are ultimately added to. - let collect_for_nearest_positioned_ancestor = parent_positioning_context - .collects_for_nearest_positioned_ancestor() || - self.table.rows.get(row_index).is_some_and(|row| { - let row = row.borrow(); - let row_group_collects_for_nearest_positioned_ancestor = - row.group_index.is_some_and(|group_index| { - self.table.row_groups[group_index] - .borrow() - .base - .style - .establishes_containing_block_for_absolute_descendants( - FragmentFlags::empty(), - ) - }); - row_group_collects_for_nearest_positioned_ancestor || - row.base - .style - .establishes_containing_block_for_absolute_descendants( - FragmentFlags::empty(), - ) - }); - row_slots .par_iter() .enumerate() @@ -1141,10 +1116,7 @@ impl<'a> TableLayout<'a> { style: &cell.base.style, }; - let mut positioning_context = PositioningContext::new_for_subtree( - collect_for_nearest_positioned_ancestor, - ); - + let mut positioning_context = PositioningContext::default(); let layout = cell.contents.layout( layout_context, &mut positioning_context, @@ -1503,7 +1475,6 @@ impl<'a> TableLayout<'a> { layout_context: &LayoutContext, parent_positioning_context: &mut PositioningContext, ) -> BoxFragment { - let mut positioning_context = caption.context.new_positioning_context(); let containing_block = &ContainingBlock { size: ContainingBlockSize { inline: self.table_width + self.pbm.padding_border_sums.inline, @@ -1517,6 +1488,8 @@ impl<'a> TableLayout<'a> { // stretch block size. https://drafts.csswg.org/css-sizing-4/#stretch-fit-sizing let ignore_block_margins_for_stretch = LogicalSides1D::new(false, false); + let mut positioning_context = + PositioningContext::new_for_layout_box_base(&caption.context.base); let mut box_fragment = caption.context.layout_in_flow_block_level( layout_context, positioning_context @@ -1769,11 +1742,7 @@ impl<'a> TableLayout<'a> { ) -> BoxFragment { self.distributed_column_widths = Self::distribute_width_to_columns(self.assignable_width, &self.columns); - self.layout_cells_in_row( - layout_context, - containing_block_for_children, - positioning_context, - ); + self.layout_cells_in_row(layout_context, containing_block_for_children); let table_writing_mode = containing_block_for_children.style.writing_mode; let first_layout_row_heights = self.do_first_row_layout(table_writing_mode); self.compute_table_height_and_final_row_heights( @@ -2325,7 +2294,7 @@ impl<'a> RowFragmentLayout<'a> { Self { row: table_row, rect, - positioning_context: table_row.base.new_positioning_context(), + positioning_context: PositioningContext::new_for_layout_box_base(&table_row.base), containing_block, fragments: Vec::new(), } @@ -2379,11 +2348,11 @@ impl<'a> RowFragmentLayout<'a> { if let Some(mut row_positioning_context) = self.positioning_context.take() { row_positioning_context.layout_collected_children(layout_context, &mut row_fragment); - let positioning_context = row_group_fragment_layout + let parent_positioning_context = row_group_fragment_layout .as_mut() .and_then(|layout| layout.positioning_context.as_mut()) .unwrap_or(table_positioning_context); - positioning_context.append(row_positioning_context); + parent_positioning_context.append(row_positioning_context); } let fragment = Fragment::Box(ArcRefCell::new(row_fragment)); @@ -2410,7 +2379,7 @@ impl RowGroupFragmentLayout { let row_group = row_group.borrow(); ( dimensions.get_row_group_rect(&row_group), - row_group.base.new_positioning_context(), + PositioningContext::new_for_layout_box_base(&row_group.base), ) }; Self { diff --git a/components/layout/taffy/layout.rs b/components/layout/taffy/layout.rs index 3777c902053..a5838c1bd65 100644 --- a/components/layout/taffy/layout.rs +++ b/components/layout/taffy/layout.rs @@ -29,7 +29,7 @@ use crate::geom::{ use crate::layout_box_base::CacheableLayoutResult; use crate::positioned::{AbsolutelyPositionedBox, PositioningContext, PositioningContextLength}; use crate::sizing::{ComputeInlineContentSizes, ContentSizes, InlineContentSizesResult}; -use crate::style_ext::{ComputedValuesExt, LayoutStyle}; +use crate::style_ext::LayoutStyle; use crate::{ConstraintSpace, ContainingBlock, ContainingBlockSize}; const DUMMY_NODE_ID: taffy::NodeId = taffy::NodeId::new(u64::MAX); @@ -250,29 +250,15 @@ impl taffy::LayoutPartialTree for TaffyContainerContext<'_> { }, style, }; - let layout = { - let mut child_positioning_context = independent_context - .new_positioning_context() - .unwrap_or_else(|| { - PositioningContext::new_for_subtree( - self.positioning_context - .collects_for_nearest_positioned_ancestor(), - ) - }); - - let layout = non_replaced.layout_without_caching( - self.layout_context, - &mut child_positioning_context, - &content_box_size_override, - containing_block, - false, /* depends_on_block_constraints */ - ); - // Store layout data on child for later access - child.positioning_context = child_positioning_context; - - layout - }; + child.positioning_context = PositioningContext::default(); + let layout = non_replaced.layout_without_caching( + self.layout_context, + &mut child.positioning_context, + &content_box_size_override, + containing_block, + false, /* depends_on_block_constraints */ + ); child.child_fragments = layout.fragments; self.child_specific_layout_infos[usize::from(node_id)] = @@ -373,8 +359,7 @@ impl ComputeInlineContentSizes for TaffyContainer { let mut grid_context = TaffyContainerContext { layout_context, - positioning_context: - &mut PositioningContext::new_for_containing_block_for_all_descendants(), + positioning_context: &mut PositioningContext::default(), content_box_size_override: containing_block, style, source_child_nodes: &self.children, @@ -540,17 +525,6 @@ impl TaffyContainer { let child_specific_layout_info: Option<SpecificLayoutInfo> = std::mem::take(&mut container_ctx.child_specific_layout_infos[child_id]); - let establishes_containing_block_for_absolute_descendants = - if let TaffyItemBoxInner::InFlowBox(independent_box) = &child.taffy_level_box { - child - .style - .establishes_containing_block_for_absolute_descendants( - independent_box.base_fragment_info().flags, - ) - } else { - false - }; - let fragment = match &mut child.taffy_level_box { TaffyItemBoxInner::InFlowBox(independent_box) => { let mut fragment_info = independent_box.base_fragment_info(); @@ -573,29 +547,21 @@ impl TaffyContainer { }) .with_specific_layout_info(child_specific_layout_info); - if establishes_containing_block_for_absolute_descendants { - child.positioning_context.layout_collected_children( - container_ctx.layout_context, - &mut box_fragment, - ); - } - - let fragment = Fragment::Box(ArcRefCell::new(box_fragment)); - + child.positioning_context.layout_collected_children( + container_ctx.layout_context, + &mut box_fragment, + ); child .positioning_context - .adjust_static_position_of_hoisted_fragments( - &fragment, + .adjust_static_position_of_hoisted_fragments_with_offset( + &box_fragment.content_rect.origin.to_vector(), PositioningContextLength::zero(), ); - let child_positioning_context = std::mem::replace( - &mut child.positioning_context, - PositioningContext::new_for_containing_block_for_all_descendants(), - ); container_ctx .positioning_context - .append(child_positioning_context); - fragment + .append(std::mem::take(&mut child.positioning_context)); + + Fragment::Box(ArcRefCell::new(box_fragment)) }, TaffyItemBoxInner::OutOfFlowAbsolutelyPositionedBox(abs_pos_box) => { fn resolve_alignment(value: AlignFlags, auto: AlignFlags) -> AlignFlags { diff --git a/components/layout/taffy/mod.rs b/components/layout/taffy/mod.rs index 55a678cd89a..b1ff753ea78 100644 --- a/components/layout/taffy/mod.rs +++ b/components/layout/taffy/mod.rs @@ -110,7 +110,7 @@ impl TaffyItemBox { Self { taffy_layout: Default::default(), child_fragments: Vec::new(), - positioning_context: PositioningContext::new_for_containing_block_for_all_descendants(), + positioning_context: PositioningContext::default(), style, taffy_level_box: inner, } @@ -118,8 +118,7 @@ impl TaffyItemBox { pub(crate) fn invalidate_cached_fragment(&mut self) { self.taffy_layout = Default::default(); - self.positioning_context = - PositioningContext::new_for_containing_block_for_all_descendants(); + self.positioning_context = PositioningContext::default(); match self.taffy_level_box { TaffyItemBoxInner::InFlowBox(ref independent_formatting_context) => { independent_formatting_context diff --git a/components/script/canvas_context.rs b/components/script/canvas_context.rs index d85877c0f41..7dfdf48e3f5 100644 --- a/components/script/canvas_context.rs +++ b/components/script/canvas_context.rs @@ -6,20 +6,24 @@ use euclid::default::Size2D; use script_bindings::root::Dom; -use script_layout_interface::{HTMLCanvasData, HTMLCanvasDataSource}; +use script_layout_interface::HTMLCanvasData; use snapshot::Snapshot; +use webrender_api::ImageKey; use crate::dom::bindings::codegen::UnionTypes::HTMLCanvasElementOrOffscreenCanvas; use crate::dom::bindings::inheritance::Castable; use crate::dom::htmlcanvaselement::HTMLCanvasElement; use crate::dom::node::{Node, NodeDamage}; +#[cfg(feature = "webgpu")] +use crate::dom::types::GPUCanvasContext; use crate::dom::types::{ - CanvasRenderingContext2D, GPUCanvasContext, OffscreenCanvas, OffscreenCanvasRenderingContext2D, + CanvasRenderingContext2D, OffscreenCanvas, OffscreenCanvasRenderingContext2D, WebGL2RenderingContext, WebGLRenderingContext, }; pub(crate) trait LayoutCanvasRenderingContextHelpers { - fn canvas_data_source(self) -> HTMLCanvasDataSource; + /// `None` is rendered as transparent black (cleared canvas) + fn canvas_data_source(self) -> Option<ImageKey>; } pub(crate) trait LayoutHTMLCanvasElementHelpers { diff --git a/components/script/dom/canvasrenderingcontext2d.rs b/components/script/dom/canvasrenderingcontext2d.rs index 38bd38ad511..046d478e49d 100644 --- a/components/script/dom/canvasrenderingcontext2d.rs +++ b/components/script/dom/canvasrenderingcontext2d.rs @@ -7,9 +7,9 @@ use dom_struct::dom_struct; use euclid::default::Size2D; use profile_traits::ipc; use script_bindings::inheritance::Castable; -use script_layout_interface::HTMLCanvasDataSource; use servo_url::ServoUrl; use snapshot::Snapshot; +use webrender_api::ImageKey; use crate::canvas_context::{CanvasContext, CanvasHelpers, LayoutCanvasRenderingContextHelpers}; use crate::canvas_state::CanvasState; @@ -98,13 +98,13 @@ impl CanvasRenderingContext2D { } impl LayoutCanvasRenderingContextHelpers for LayoutDom<'_, CanvasRenderingContext2D> { - fn canvas_data_source(self) -> HTMLCanvasDataSource { + fn canvas_data_source(self) -> Option<ImageKey> { let canvas_state = &self.unsafe_get().canvas_state; if canvas_state.is_paintable() { - HTMLCanvasDataSource::Image(canvas_state.image_key()) + Some(canvas_state.image_key()) } else { - HTMLCanvasDataSource::Empty + None } } } diff --git a/components/script/dom/element.rs b/components/script/dom/element.rs index 2831fc3d8f0..c040078f707 100644 --- a/components/script/dom/element.rs +++ b/components/script/dom/element.rs @@ -3025,28 +3025,8 @@ impl ElementMethods<crate::DomTypeHolder> for Element { DomRoot::from_ref(self.upcast()) }; - // Step 3. Unsafely set HTML given target, this, and compliantHTML. - // Let newChildren be the result of the HTML fragment parsing algorithm. - let new_children = ServoParser::parse_html_fragment(self, html, true, can_gc); - - let context_document = { - if let Some(template) = self.downcast::<HTMLTemplateElement>() { - template.Content(can_gc).upcast::<Node>().owner_doc() - } else { - self.owner_document() - } - }; - - // Let fragment be a new DocumentFragment whose node document is contextElement's node document. - let frag = DocumentFragment::new(&context_document, can_gc); - - // For each node in newChildren, append node to fragment. - for child in new_children { - frag.upcast::<Node>().AppendChild(&child, can_gc).unwrap(); - } - - // Replace all with fragment within target. - Node::replace_all(Some(frag.upcast()), &target, can_gc); + // Step 3. Unsafely set HTML given target, this, and compliantHTML + Node::unsafely_set_html(&target, self, html, can_gc); } /// <https://html.spec.whatwg.org/multipage/#dom-element-gethtml> diff --git a/components/script/dom/gpucanvascontext.rs b/components/script/dom/gpucanvascontext.rs index 5304d0f5d3b..f47e1dfddd1 100644 --- a/components/script/dom/gpucanvascontext.rs +++ b/components/script/dom/gpucanvascontext.rs @@ -3,7 +3,7 @@ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */ use dom_struct::dom_struct; -use script_layout_interface::HTMLCanvasDataSource; +use webrender_api::ImageKey; use crate::dom::bindings::codegen::Bindings::GPUCanvasContextBinding::GPUCanvasContextMethods; use crate::dom::bindings::codegen::UnionTypes; @@ -31,7 +31,7 @@ impl GPUCanvasContextMethods<crate::DomTypeHolder> for GPUCanvasContext { } impl LayoutCanvasRenderingContextHelpers for LayoutDom<'_, GPUCanvasContext> { - fn canvas_data_source(self) -> HTMLCanvasDataSource { + fn canvas_data_source(self) -> Option<ImageKey> { unimplemented!() } } diff --git a/components/script/dom/htmlcanvaselement.rs b/components/script/dom/htmlcanvaselement.rs index cc6df183f42..56e008839ba 100644 --- a/components/script/dom/htmlcanvaselement.rs +++ b/components/script/dom/htmlcanvaselement.rs @@ -21,7 +21,7 @@ use image::{ColorType, ImageEncoder}; use ipc_channel::ipc::{self as ipcchan}; use js::error::throw_type_error; use js::rust::{HandleObject, HandleValue}; -use script_layout_interface::{HTMLCanvasData, HTMLCanvasDataSource}; +use script_layout_interface::HTMLCanvasData; use servo_media::streams::MediaStreamType; use servo_media::streams::registry::MediaStreamId; use snapshot::Snapshot; @@ -201,7 +201,7 @@ impl LayoutHTMLCanvasElementHelpers for LayoutDom<'_, HTMLCanvasElement> { Some(RenderingContext::WebGL2(context)) => context.to_layout().canvas_data_source(), #[cfg(feature = "webgpu")] Some(RenderingContext::WebGPU(context)) => context.to_layout().canvas_data_source(), - Some(RenderingContext::Placeholder(_)) | None => HTMLCanvasDataSource::Empty, + Some(RenderingContext::Placeholder(_)) | None => None, } }; diff --git a/components/script/dom/htmltablecellelement.rs b/components/script/dom/htmltablecellelement.rs index 4f312e928c4..8b553923230 100644 --- a/components/script/dom/htmltablecellelement.rs +++ b/components/script/dom/htmltablecellelement.rs @@ -70,13 +70,17 @@ impl HTMLTableCellElementMethods<crate::DomTypeHolder> for HTMLTableCellElement make_uint_getter!(ColSpan, "colspan", DEFAULT_COLSPAN); // https://html.spec.whatwg.org/multipage/#dom-tdth-colspan - make_uint_setter!(SetColSpan, "colspan", DEFAULT_COLSPAN); + // > The colSpan IDL attribute must reflect the colspan content attribute. It is clamped to + // > the range [1, 1000], and its default value is 1. + make_clamped_uint_setter!(SetColSpan, "colspan", 1, 1000, 1); // https://html.spec.whatwg.org/multipage/#dom-tdth-rowspan make_uint_getter!(RowSpan, "rowspan", DEFAULT_ROWSPAN); // https://html.spec.whatwg.org/multipage/#dom-tdth-rowspan - make_uint_setter!(SetRowSpan, "rowspan", DEFAULT_ROWSPAN); + // > The rowSpan IDL attribute must reflect the rowspan content attribute. It is clamped to + // > the range [0, 65534], and its default value is 1. + make_clamped_uint_setter!(SetRowSpan, "rowspan", 0, 65534, 1); // https://html.spec.whatwg.org/multipage/#dom-tdth-bgcolor make_getter!(BgColor, "bgcolor"); @@ -174,23 +178,26 @@ impl VirtualMethods for HTMLTableCellElement { match *local_name { local_name!("colspan") => { let mut attr = AttrValue::from_u32(value.into(), DEFAULT_COLSPAN); - if let AttrValue::UInt(_, ref mut val) = attr { - if *val == 0 { - *val = 1; - } + if let AttrValue::UInt(_, ref mut value) = attr { + // From <https://html.spec.whatwg.org/multipage/#dom-tdth-colspan>: + // > The colSpan IDL attribute must reflect the colspan content attribute. It is clamped to + // > the range [1, 1000], and its default value is 1. + *value = (*value).clamp(1, 1000); } attr }, local_name!("rowspan") => { let mut attr = AttrValue::from_u32(value.into(), DEFAULT_ROWSPAN); - if let AttrValue::UInt(_, ref mut val) = attr { - if *val == 0 { - let node = self.upcast::<Node>(); - let doc = node.owner_doc(); - // rowspan = 0 is not supported in quirks mode - if doc.quirks_mode() != QuirksMode::NoQuirks { - *val = 1; - } + if let AttrValue::UInt(_, ref mut value) = attr { + // From <https://html.spec.whatwg.org/multipage/#dom-tdth-rowspan>: + // > The rowSpan IDL attribute must reflect the rowspan content attribute. It is clamped to + // > the range [0, 65534], and its default value is 1. + // Note that rowspan = 0 is not supported in quirks mode. + let document = self.upcast::<Node>().owner_doc(); + if document.quirks_mode() != QuirksMode::NoQuirks { + *value = (*value).clamp(1, 65534); + } else { + *value = (*value).clamp(0, 65534); } } attr diff --git a/components/script/dom/htmltablecolelement.rs b/components/script/dom/htmltablecolelement.rs index c7ad4afd944..9e8eecf1147 100644 --- a/components/script/dom/htmltablecolelement.rs +++ b/components/script/dom/htmltablecolelement.rs @@ -20,8 +20,6 @@ use crate::dom::node::Node; use crate::dom::virtualmethods::VirtualMethods; use crate::script_runtime::CanGc; -const DEFAULT_SPAN: u32 = 1; - #[dom_struct] pub(crate) struct HTMLTableColElement { htmlelement: HTMLElement, @@ -62,9 +60,11 @@ impl HTMLTableColElement { impl HTMLTableColElementMethods<crate::DomTypeHolder> for HTMLTableColElement { // <https://html.spec.whatwg.org/multipage/#attr-col-span> - make_uint_getter!(Span, "span", DEFAULT_SPAN); + make_uint_getter!(Span, "span", 1); // <https://html.spec.whatwg.org/multipage/#attr-col-span> - make_uint_setter!(SetSpan, "span", DEFAULT_SPAN); + // > The span IDL attribute must reflect the content attribute of the same name. It is clamped + // > to the range [1, 1000], and its default value is 1. + make_clamped_uint_setter!(SetSpan, "span", 1, 1000, 1); } pub(crate) trait HTMLTableColElementLayoutHelpers<'dom> { @@ -96,11 +96,12 @@ impl VirtualMethods for HTMLTableColElement { fn parse_plain_attribute(&self, local_name: &LocalName, value: DOMString) -> AttrValue { match *local_name { local_name!("span") => { - let mut attr = AttrValue::from_u32(value.into(), DEFAULT_SPAN); + let mut attr = AttrValue::from_u32(value.into(), 1); if let AttrValue::UInt(_, ref mut val) = attr { - if *val == 0 { - *val = 1; - } + // From <https://html.spec.whatwg.org/multipage/#attr-col-span>: + // > The span IDL attribute must reflect the content attribute of the same name. + // > It is clamped to the range [1, 1000], and its default value is 1. + *val = (*val).clamp(1, 1000); } attr }, diff --git a/components/script/dom/macros.rs b/components/script/dom/macros.rs index c2f5ba37c21..997341984c6 100644 --- a/components/script/dom/macros.rs +++ b/components/script/dom/macros.rs @@ -318,6 +318,26 @@ macro_rules! make_uint_setter( ); #[macro_export] +macro_rules! make_clamped_uint_setter( + ($attr:ident, $htmlname:tt, $min:expr, $max:expr, $default:expr) => ( + fn $attr(&self, value: u32) { + use $crate::dom::bindings::inheritance::Castable; + use $crate::dom::element::Element; + use $crate::dom::values::UNSIGNED_LONG_MAX; + use $crate::script_runtime::CanGc; + let value = if value > UNSIGNED_LONG_MAX { + $default + } else { + value.clamp($min, $max) + }; + + let element = self.upcast::<Element>(); + element.set_uint_attribute(&html5ever::local_name!($htmlname), value, CanGc::note()) + } + ); +); + +#[macro_export] macro_rules! make_limited_uint_setter( ($attr:ident, $htmlname:tt, $default:expr) => ( fn $attr(&self, value: u32) -> $crate::dom::bindings::error::ErrorResult { diff --git a/components/script/dom/node.rs b/components/script/dom/node.rs index 1117eff6d3c..e9d36a01426 100644 --- a/components/script/dom/node.rs +++ b/components/script/dom/node.rs @@ -110,7 +110,7 @@ use crate::dom::pointerevent::{PointerEvent, PointerId}; use crate::dom::processinginstruction::ProcessingInstruction; use crate::dom::range::WeakRangeVec; use crate::dom::raredata::NodeRareData; -use crate::dom::servoparser::serialize_html_fragment; +use crate::dom::servoparser::{ServoParser, serialize_html_fragment}; use crate::dom::shadowroot::{IsUserAgentWidget, LayoutShadowRootHelpers, ShadowRoot}; use crate::dom::stylesheetlist::StyleSheetListOwner; use crate::dom::svgsvgelement::{LayoutSVGSVGElementHelpers, SVGSVGElement}; @@ -316,6 +316,34 @@ impl Node { } } + /// Implements the "unsafely set HTML" algorithm as specified in: + /// <https://html.spec.whatwg.org/multipage/#concept-unsafely-set-html> + pub fn unsafely_set_html( + target: &Node, + context_element: &Element, + html: DOMString, + can_gc: CanGc, + ) { + // Step 1. Let newChildren be the result of the HTML fragment parsing algorithm. + let new_children = ServoParser::parse_html_fragment(context_element, html, true, can_gc); + + // Step 2. Let fragment be a new DocumentFragment whose node document is contextElement's node document. + + let context_document = context_element.owner_document(); + let fragment = DocumentFragment::new(&context_document, can_gc); + + // Step 3. For each node in newChildren, append node to fragment. + for child in new_children { + fragment + .upcast::<Node>() + .AppendChild(&child, can_gc) + .unwrap(); + } + + // Step 4. Replace all with fragment within target. + Node::replace_all(Some(fragment.upcast()), target, can_gc); + } + pub(crate) fn clean_up_style_and_layout_data(&self) { self.owner_doc().cancel_animations_for_node(self); self.style_data.borrow_mut().take(); @@ -1283,6 +1311,21 @@ impl Node { is_shadow_host, shadow_root_mode, display, + doctype_name: self + .downcast::<DocumentType>() + .map(DocumentType::name) + .cloned() + .map(String::from), + doctype_public_identifier: self + .downcast::<DocumentType>() + .map(DocumentType::public_id) + .cloned() + .map(String::from), + doctype_system_identifier: self + .downcast::<DocumentType>() + .map(DocumentType::system_id) + .cloned() + .map(String::from), } } diff --git a/components/script/dom/shadowroot.rs b/components/script/dom/shadowroot.rs index 72b074ed6f4..14d9c24b10e 100644 --- a/components/script/dom/shadowroot.rs +++ b/components/script/dom/shadowroot.rs @@ -453,6 +453,15 @@ impl ShadowRootMethods<crate::DomTypeHolder> for ShadowRoot { self.slot_assignment_mode } + /// <https://html.spec.whatwg.org/multipage/#dom-shadowroot-sethtmlunsafe> + fn SetHTMLUnsafe(&self, html: DOMString, can_gc: CanGc) { + // Step 2. Unsafely set HTMl given this, this's shadow host, and complaintHTML + let target = self.upcast::<Node>(); + let context_element = self.Host(); + + Node::unsafely_set_html(target, &context_element, html, can_gc); + } + // https://dom.spec.whatwg.org/#dom-shadowroot-onslotchange event_handler!(onslotchange, GetOnslotchange, SetOnslotchange); } diff --git a/components/script/dom/webgl2renderingcontext.rs b/components/script/dom/webgl2renderingcontext.rs index 416454d8719..5e538b53b5f 100644 --- a/components/script/dom/webgl2renderingcontext.rs +++ b/components/script/dom/webgl2renderingcontext.rs @@ -22,10 +22,10 @@ use js::jsval::{BooleanValue, DoubleValue, Int32Value, NullValue, ObjectValue, U use js::rust::{CustomAutoRooterGuard, HandleObject, MutableHandleValue}; use js::typedarray::{ArrayBufferView, CreateWith, Float32, Int32Array, Uint32, Uint32Array}; use script_bindings::interfaces::WebGL2RenderingContextHelpers; -use script_layout_interface::HTMLCanvasDataSource; use servo_config::pref; use snapshot::Snapshot; use url::Host; +use webrender_api::ImageKey; use crate::canvas_context::CanvasContext; use crate::dom::bindings::codegen::Bindings::WebGL2RenderingContextBinding::{ @@ -4702,7 +4702,7 @@ impl WebGL2RenderingContextMethods<crate::DomTypeHolder> for WebGL2RenderingCont impl LayoutCanvasRenderingContextHelpers for LayoutDom<'_, WebGL2RenderingContext> { #[allow(unsafe_code)] - fn canvas_data_source(self) -> HTMLCanvasDataSource { + fn canvas_data_source(self) -> Option<ImageKey> { let this = self.unsafe_get(); unsafe { (*this.base.to_layout().unsafe_get()).layout_handle() } } diff --git a/components/script/dom/webglrenderingcontext.rs b/components/script/dom/webglrenderingcontext.rs index 9996a3cf504..98170f9655b 100644 --- a/components/script/dom/webglrenderingcontext.rs +++ b/components/script/dom/webglrenderingcontext.rs @@ -31,7 +31,6 @@ use js::typedarray::{ }; use net_traits::image_cache::ImageResponse; use pixels::{self, PixelFormat}; -use script_layout_interface::HTMLCanvasDataSource; use serde::{Deserialize, Serialize}; use servo_config::pref; use snapshot::Snapshot; @@ -875,9 +874,8 @@ impl WebGLRenderingContext { receiver.recv().unwrap() } - pub(crate) fn layout_handle(&self) -> HTMLCanvasDataSource { - let image_key = self.webrender_image; - HTMLCanvasDataSource::WebGL(image_key) + pub(crate) fn layout_handle(&self) -> Option<ImageKey> { + Some(self.webrender_image) } // https://www.khronos.org/registry/webgl/extensions/ANGLE_instanced_arrays/ @@ -4829,7 +4827,7 @@ impl WebGLRenderingContextMethods<crate::DomTypeHolder> for WebGLRenderingContex } impl LayoutCanvasRenderingContextHelpers for LayoutDom<'_, WebGLRenderingContext> { - fn canvas_data_source(self) -> HTMLCanvasDataSource { + fn canvas_data_source(self) -> Option<ImageKey> { (*self.unsafe_get()).layout_handle() } } diff --git a/components/script/dom/webgpu/gpucanvascontext.rs b/components/script/dom/webgpu/gpucanvascontext.rs index c81f96f651f..359b1b14003 100644 --- a/components/script/dom/webgpu/gpucanvascontext.rs +++ b/components/script/dom/webgpu/gpucanvascontext.rs @@ -8,7 +8,6 @@ use std::cell::RefCell; use arrayvec::ArrayVec; use dom_struct::dom_struct; use ipc_channel::ipc::{self}; -use script_layout_interface::HTMLCanvasDataSource; use snapshot::Snapshot; use webgpu_traits::{ ContextConfiguration, PRESENTATION_BUFFER_COUNT, WebGPU, WebGPUContextId, WebGPURequest, @@ -227,11 +226,11 @@ impl GPUCanvasContext { // Internal helper methods impl GPUCanvasContext { - fn layout_handle(&self) -> HTMLCanvasDataSource { + fn layout_handle(&self) -> Option<ImageKey> { if self.drawing_buffer.borrow().cleared { - HTMLCanvasDataSource::Empty + None } else { - HTMLCanvasDataSource::WebGPU(self.webrender_image) + Some(self.webrender_image) } } @@ -301,7 +300,7 @@ impl CanvasContext for GPUCanvasContext { } impl LayoutCanvasRenderingContextHelpers for LayoutDom<'_, GPUCanvasContext> { - fn canvas_data_source(self) -> HTMLCanvasDataSource { + fn canvas_data_source(self) -> Option<ImageKey> { (*self.unsafe_get()).layout_handle() } } diff --git a/components/script/dom/window.rs b/components/script/dom/window.rs index a685bbb25f2..90782e217b7 100644 --- a/components/script/dom/window.rs +++ b/components/script/dom/window.rs @@ -1246,7 +1246,7 @@ impl WindowMethods<crate::DomTypeHolder> for Window { let rv = jsval_to_webdriver(cx, &self.globalscope, val, realm, can_gc); let opt_chan = self.webdriver_script_chan.borrow_mut().take(); if let Some(chan) = opt_chan { - chan.send(rv).unwrap(); + let _ = chan.send(rv); } } @@ -1255,9 +1255,9 @@ impl WindowMethods<crate::DomTypeHolder> for Window { let opt_chan = self.webdriver_script_chan.borrow_mut().take(); if let Some(chan) = opt_chan { if let Ok(rv) = rv { - chan.send(Err(WebDriverJSError::JSException(rv))).unwrap(); + let _ = chan.send(Err(WebDriverJSError::JSException(rv))); } else { - chan.send(rv).unwrap(); + let _ = chan.send(rv); } } } @@ -1265,7 +1265,7 @@ impl WindowMethods<crate::DomTypeHolder> for Window { fn WebdriverTimeout(&self) { let opt_chan = self.webdriver_script_chan.borrow_mut().take(); if let Some(chan) = opt_chan { - chan.send(Err(WebDriverJSError::Timeout)).unwrap(); + let _ = chan.send(Err(WebDriverJSError::Timeout)); } } diff --git a/components/script_bindings/codegen/Bindings.conf b/components/script_bindings/codegen/Bindings.conf index 4ab0b21cabe..6396e3ced0c 100644 --- a/components/script_bindings/codegen/Bindings.conf +++ b/components/script_bindings/codegen/Bindings.conf @@ -579,7 +579,7 @@ DOMInterfaces = { }, 'ShadowRoot': { - 'canGc': ['ElementFromPoint', 'ElementsFromPoint', 'SetInnerHTML', 'GetHTML', 'InnerHTML'], + 'canGc': ['SetHTMLUnsafe', 'ElementFromPoint', 'ElementsFromPoint', 'SetInnerHTML', 'GetHTML', 'InnerHTML'], }, 'StaticRange': { diff --git a/components/script_bindings/webidls/ShadowRoot.webidl b/components/script_bindings/webidls/ShadowRoot.webidl index 6e3f2032294..cb0926afc10 100644 --- a/components/script_bindings/webidls/ShadowRoot.webidl +++ b/components/script_bindings/webidls/ShadowRoot.webidl @@ -25,7 +25,7 @@ ShadowRoot includes DocumentOrShadowRoot; // https://html.spec.whatwg.org/multipage/#dom-parsing-and-serialization partial interface ShadowRoot { - // [CEReactions] undefined setHTMLUnsafe((TrustedHTML or DOMString) html); + [CEReactions] undefined setHTMLUnsafe(DOMString html); DOMString getHTML(optional GetHTMLOptions options = {}); // [CEReactions] attribute (TrustedHTML or [LegacyNullToEmptyString] DOMString) innerHTML; diff --git a/components/servo/lib.rs b/components/servo/lib.rs index 6f39e773e4e..366685e1123 100644 --- a/components/servo/lib.rs +++ b/components/servo/lib.rs @@ -120,6 +120,7 @@ pub use {bluetooth, bluetooth_traits}; use crate::proxies::ConstellationProxy; use crate::responders::ServoErrorChannel; pub use crate::servo_delegate::{ServoDelegate, ServoError}; +use crate::webrender_api::FrameReadyParams; pub use crate::webview::{WebView, WebViewBuilder}; pub use crate::webview_delegate::{ AllowOrDenyRequest, AuthenticationRequest, FormControl, NavigationRequest, PermissionRequest, @@ -233,14 +234,13 @@ impl webrender_api::RenderNotifier for RenderNotifier { fn new_frame_ready( &self, document_id: DocumentId, - _scrolled: bool, - composite_needed: bool, - _frame_publish_id: FramePublishId, + _: FramePublishId, + frame_ready_params: &FrameReadyParams, ) { self.compositor_proxy .send(CompositorMsg::NewWebRenderFrameReady( document_id, - composite_needed, + frame_ready_params.render, )); } } diff --git a/components/shared/devtools/lib.rs b/components/shared/devtools/lib.rs index 0cf99d22658..c07f4529073 100644 --- a/components/shared/devtools/lib.rs +++ b/components/shared/devtools/lib.rs @@ -144,6 +144,15 @@ pub struct NodeInfo { pub shadow_root_mode: Option<ShadowRootMode>, pub is_shadow_host: bool, pub display: Option<String>, + + /// The `DOCTYPE` name if this is a `DocumentType` node, `None` otherwise + pub doctype_name: Option<String>, + + /// The `DOCTYPE` public identifier if this is a `DocumentType` node , `None` otherwise + pub doctype_public_identifier: Option<String>, + + /// The `DOCTYPE` system identifier if this is a `DocumentType` node, `None` otherwise + pub doctype_system_identifier: Option<String>, } pub struct StartedTimelineMarker { diff --git a/components/shared/script_layout/lib.rs b/components/shared/script_layout/lib.rs index a40b8c403c1..66baccd5147 100644 --- a/components/shared/script_layout/lib.rs +++ b/components/shared/script_layout/lib.rs @@ -117,16 +117,8 @@ pub enum LayoutElementType { SVGSVGElement, } -pub enum HTMLCanvasDataSource { - WebGL(ImageKey), - Image(ImageKey), - WebGPU(ImageKey), - /// transparent black - Empty, -} - pub struct HTMLCanvasData { - pub source: HTMLCanvasDataSource, + pub source: Option<ImageKey>, pub width: u32, pub height: u32, } diff --git a/components/webdriver_server/actions.rs b/components/webdriver_server/actions.rs index f69a09a2577..fbede5b5887 100644 --- a/components/webdriver_server/actions.rs +++ b/components/webdriver_server/actions.rs @@ -76,7 +76,7 @@ fn compute_tick_duration(tick_actions: &ActionSequence) -> u64 { } }, ActionsType::Key { actions: _ } => (), - ActionsType::Wheel { .. } => todo!("Not implemented."), + ActionsType::Wheel { .. } => log::error!("not implemented"), } duration } @@ -176,7 +176,10 @@ impl Handler { } } }, - ActionsType::Wheel { .. } => todo!("Not implemented."), + ActionsType::Wheel { .. } => { + log::error!("not yet implemented"); + return Err(ErrorStatus::UnsupportedOperation); + }, } Ok(()) diff --git a/components/webdriver_server/capabilities.rs b/components/webdriver_server/capabilities.rs index 477a3bfd34c..32596f5275a 100644 --- a/components/webdriver_server/capabilities.rs +++ b/components/webdriver_server/capabilities.rs @@ -4,7 +4,7 @@ use serde_json::{Map, Value}; use webdriver::capabilities::{BrowserCapabilities, Capabilities}; -use webdriver::error::{WebDriverError, WebDriverResult}; +use webdriver::error::{ErrorStatus, WebDriverError, WebDriverResult}; pub struct ServoCapabilities { pub browser_name: String, @@ -79,42 +79,42 @@ impl BrowserCapabilities for ServoCapabilities { &mut self, _: &serde_json::Map<std::string::String, Value>, ) -> Result<bool, WebDriverError> { - todo!() + Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "")) } fn webauthn_virtual_authenticators( &mut self, _: &serde_json::Map<std::string::String, Value>, ) -> Result<bool, WebDriverError> { - todo!() + Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "")) } fn webauthn_extension_uvm( &mut self, _: &serde_json::Map<std::string::String, Value>, ) -> Result<bool, WebDriverError> { - todo!() + Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "")) } fn webauthn_extension_prf( &mut self, _: &serde_json::Map<std::string::String, Value>, ) -> Result<bool, WebDriverError> { - todo!() + Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "")) } fn webauthn_extension_large_blob( &mut self, _: &serde_json::Map<std::string::String, Value>, ) -> Result<bool, WebDriverError> { - todo!() + Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "")) } fn webauthn_extension_cred_blob( &mut self, _: &serde_json::Map<std::string::String, Value>, ) -> Result<bool, WebDriverError> { - todo!() + Err(WebDriverError::new(ErrorStatus::UnsupportedOperation, "")) } } diff --git a/components/webdriver_server/lib.rs b/components/webdriver_server/lib.rs index ce83a8f3cc1..d003ebf8adb 100644 --- a/components/webdriver_server/lib.rs +++ b/components/webdriver_server/lib.rs @@ -29,7 +29,7 @@ use embedder_traits::{ use euclid::{Rect, Size2D}; use http::method::Method; use image::{DynamicImage, ImageFormat, RgbaImage}; -use ipc_channel::ipc::{self, IpcSender}; +use ipc_channel::ipc::{self, IpcReceiver, IpcSender}; use ipc_channel::router::ROUTER; use keyboard_types::webdriver::send_keys; use log::{debug, info}; @@ -678,7 +678,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); self.top_level_script_command(WebDriverScriptCommand::GetUrl(sender))?; - let url = receiver.recv().unwrap(); + let url = wait_for_script_response(receiver)?; Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(url.as_str())?, @@ -694,7 +694,7 @@ impl Handler { .send(EmbedderToConstellationMessage::WebDriverCommand(cmd_msg)) .unwrap(); - let window_size = receiver.recv().unwrap(); + let window_size = wait_for_script_response(receiver)?; let window_size_response = WindowRectResponse { x: 0, y: 0, @@ -738,7 +738,7 @@ impl Handler { .unwrap(); }); - let window_size = receiver.recv().unwrap(); + let window_size = wait_for_script_response(receiver)?; let window_size_response = WindowRectResponse { x: 0, y: 0, @@ -756,7 +756,7 @@ impl Handler { sender, ))?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(is_enabled) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(is_enabled)?, ))), @@ -772,7 +772,7 @@ impl Handler { sender, ))?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(is_selected) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(is_selected)?, ))), @@ -812,7 +812,7 @@ impl Handler { self.top_level_script_command(WebDriverScriptCommand::GetTitle(sender))?; - let value = receiver.recv().unwrap(); + let value = wait_for_script_response(receiver)?; Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(value)?, ))) @@ -874,7 +874,7 @@ impl Handler { }, } - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => { let value_resp = serde_json::to_value( value.map(|x| serde_json::to_value(WebElement(x)).unwrap()), @@ -1005,7 +1005,7 @@ impl Handler { let cmd = WebDriverScriptCommand::GetBrowsingContextId(frame_id, sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(browsing_context_id) => { self.session_mut()?.browsing_context_id = browsing_context_id; Ok(WebDriverResponse::Void) @@ -1047,7 +1047,7 @@ impl Handler { }, } - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => { let resp_value: Vec<Value> = value .into_iter() @@ -1103,7 +1103,7 @@ impl Handler { }, } - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => { let value_resp = serde_json::to_value( value.map(|x| serde_json::to_value(WebElement(x)).unwrap()), @@ -1156,7 +1156,7 @@ impl Handler { }, } - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => { let resp_value: Vec<Value> = value .into_iter() @@ -1175,7 +1175,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::GetElementRect(element.to_string(), sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(rect) => { let response = ElementRectResponse { x: rect.origin.x, @@ -1193,7 +1193,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::GetElementText(element.to_string(), sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(value)?, ))), @@ -1205,9 +1205,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::GetActiveElement(sender); self.browsing_context_script_command(cmd)?; - let value = receiver - .recv() - .unwrap() + let value = wait_for_script_response(receiver)? .map(|x| serde_json::to_value(WebElement(x)).unwrap()); Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(value)?, @@ -1218,7 +1216,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::GetComputedRole(element.to_string(), sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(value)?, ))), @@ -1230,7 +1228,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::GetElementTagName(element.to_string(), sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(value)?, ))), @@ -1250,7 +1248,7 @@ impl Handler { sender, ); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(value)?, ))), @@ -1272,7 +1270,7 @@ impl Handler { ); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(SendableWebDriverJSValue(value))?, ))), @@ -1289,7 +1287,7 @@ impl Handler { let cmd = WebDriverScriptCommand::GetElementCSS(element.to_string(), name.to_owned(), sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(value) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(value)?, ))), @@ -1301,7 +1299,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::GetCookies(sender); self.browsing_context_script_command(cmd)?; - let cookies = receiver.recv().unwrap(); + let cookies = wait_for_script_response(receiver)?; let response = cookies .into_iter() .map(|cookie| cookie_msg_to_cookie(cookie.into_inner())) @@ -1313,12 +1311,14 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::GetCookie(name, sender); self.browsing_context_script_command(cmd)?; - let cookies = receiver.recv().unwrap(); - let response = cookies + let cookies = wait_for_script_response(receiver)?; + let Some(response) = cookies .into_iter() .map(|cookie| cookie_msg_to_cookie(cookie.into_inner())) .next() - .unwrap(); + else { + return Err(WebDriverError::new(ErrorStatus::NoSuchCookie, "")); + }; Ok(WebDriverResponse::Cookie(CookieResponse(response))) } @@ -1342,7 +1342,7 @@ impl Handler { let cmd = WebDriverScriptCommand::AddCookie(cookie_builder.build(), sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(_) => Ok(WebDriverResponse::Void), Err(response) => match response { WebDriverCookieError::InvalidDomain => Err(WebDriverError::new( @@ -1361,7 +1361,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::DeleteCookie(name, sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(_) => Ok(WebDriverResponse::Void), Err(error) => Err(WebDriverError::new(error, "")), } @@ -1371,7 +1371,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let cmd = WebDriverScriptCommand::DeleteCookies(sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(_) => Ok(WebDriverResponse::Void), Err(error) => Err(WebDriverError::new(error, "")), } @@ -1426,7 +1426,7 @@ impl Handler { let cmd = WebDriverScriptCommand::GetPageSource(sender); self.browsing_context_script_command(cmd)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(source) => Ok(WebDriverResponse::Generic(ValueResponse( serde_json::to_value(source)?, ))), @@ -1487,9 +1487,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let command = WebDriverScriptCommand::ExecuteScript(script, sender); self.browsing_context_script_command(command)?; - let result = receiver - .recv() - .unwrap_or(Err(WebDriverJSError::BrowsingContextNotFound)); + let result = wait_for_script_response(receiver)?; self.postprocess_js_result(result) } @@ -1533,9 +1531,7 @@ impl Handler { let (sender, receiver) = ipc::channel().unwrap(); let command = WebDriverScriptCommand::ExecuteAsyncScript(script, sender); self.browsing_context_script_command(command)?; - let result = receiver - .recv() - .unwrap_or(Err(WebDriverJSError::BrowsingContextNotFound)); + let result = wait_for_script_response(receiver)?; self.postprocess_js_result(result) } @@ -1589,10 +1585,7 @@ impl Handler { .unwrap(); // TODO: distinguish the not found and not focusable cases - receiver - .recv() - .unwrap() - .map_err(|error| WebDriverError::new(error, ""))?; + wait_for_script_response(receiver)?.map_err(|error| WebDriverError::new(error, ""))?; let input_events = send_keys(&keys.text); @@ -1615,7 +1608,7 @@ impl Handler { let command = WebDriverScriptCommand::ElementClick(element.to_string(), sender); self.browsing_context_script_command(command)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(element_id) => match element_id { Some(element_id) => { let id = Uuid::new_v4().to_string(); @@ -1688,7 +1681,7 @@ impl Handler { .send(EmbedderToConstellationMessage::WebDriverCommand(cmd_msg)) .unwrap(); - if let Some(x) = receiver.recv().unwrap() { + if let Some(x) = wait_for_script_response(receiver)? { img = Some(x); break; }; @@ -1739,7 +1732,7 @@ impl Handler { let command = WebDriverScriptCommand::GetBoundingClientRect(element.to_string(), sender); self.browsing_context_script_command(command)?; - match receiver.recv().unwrap() { + match wait_for_script_response(receiver)? { Ok(rect) => { let encoded = self.take_screenshot(Some(Rect::from_untyped(&rect)))?; @@ -1944,3 +1937,12 @@ fn webdriver_value_to_js_argument(v: &Value) -> String { }, } } + +fn wait_for_script_response<T>(receiver: IpcReceiver<T>) -> Result<T, WebDriverError> +where + T: for<'de> Deserialize<'de> + Serialize, +{ + receiver + .recv() + .map_err(|_| WebDriverError::new(ErrorStatus::NoSuchWindow, "")) +} diff --git a/python/servo/testing_commands.py b/python/servo/testing_commands.py index 845b09b622a..860217d062a 100644 --- a/python/servo/testing_commands.py +++ b/python/servo/testing_commands.py @@ -432,9 +432,9 @@ class MachCommands(CommandBase): return [py, avd, apk] @Command('test-jquery', description='Run the jQuery test suite', category='testing') - @CommandBase.common_command_arguments(build_configuration=False, build_type=True) - def test_jquery(self, build_type: BuildType): - return self.jquery_test_runner("test", build_type) + @CommandBase.common_command_arguments(binary_selection=True) + def test_jquery(self, servo_binary: str): + return self.jquery_test_runner("test", servo_binary) @Command('test-dromaeo', description='Run the Dromaeo test suite', category='testing') @CommandArgument('tests', default=["recommended"], nargs="...", help="Specific tests to run") diff --git a/python/wpt/run.py b/python/wpt/run.py index 97639ff34b6..b40287cbd96 100644 --- a/python/wpt/run.py +++ b/python/wpt/run.py @@ -51,6 +51,11 @@ def run_tests(default_binary_path: str, **kwargs): os.environ["RUST_BACKTRACE"] = "1" os.environ["HOST_FILE"] = os.path.join(SERVO_ROOT, "tests", "wpt", "hosts") + # The pytest framework used in the webdriver conformance tests dumps the + # environment variables when unexpected results occur, and this variable + # makes CI logs unreadable. + github_context = os.environ.pop("GITHUB_CONTEXT", None) + set_if_none(kwargs, "product", "servo") set_if_none(kwargs, "config", os.path.join(WPT_PATH, "config.ini")) set_if_none(kwargs, "include_manifest", os.path.join(WPT_PATH, "include.ini")) @@ -142,6 +147,9 @@ def run_tests(default_binary_path: str, **kwargs): kwargs["pause_after_test"] = False wptrunner.run_tests(**kwargs) + if github_context: + os.environ["GITHUB_CONTEXT"] = github_context + # Use the second run to mark tests from the first run as flaky, but # discard the results otherwise. # TODO: It might be a good idea to send the new results to the diff --git a/tests/wpt/include.ini b/tests/wpt/include.ini index fdbd71b9ee6..ba81ab64b83 100644 --- a/tests/wpt/include.ini +++ b/tests/wpt/include.ini @@ -278,10 +278,26 @@ skip: true skip: false [WebCryptoAPI] skip: false +[webdriver] + skip: false + [tests] + skip: false + [bidi] + skip: true + [classic] + skip: true + [interop] + skip: true [webgl] skip: false [webidl] skip: false +[webmessaging] + skip: false +[websockets] + skip: false +[webstorage] + skip: false [webvr] skip: false [webvtt] @@ -292,12 +308,6 @@ skip: true skip: false [dom-overlay] skip: true -[webmessaging] - skip: false -[websockets] - skip: false -[webstorage] - skip: false [workers] skip: false [modules] diff --git a/tests/wpt/meta/MANIFEST.json b/tests/wpt/meta/MANIFEST.json index b5e319c83c3..c74943bb031 100644 --- a/tests/wpt/meta/MANIFEST.json +++ b/tests/wpt/meta/MANIFEST.json @@ -2794,6 +2794,13 @@ }, "css-grid": { "abspos": { + "abspos-in-flexbox-in-grid-crash.html": [ + "a2f71fb78e7f6fd82ea539e3af6c76d36f21e134", + [ + null, + {} + ] + ], "positioned-grid-items-crash.html": [ "228a6264df77fe82587a4116f231ff09537c8372", [ @@ -4916,6 +4923,13 @@ {} ] ], + "colspan-zero-crash.html": [ + "a50586a5bfa7551724b838a0438339a34b4930fb", + [ + null, + {} + ] + ], "crashtests": { "caption-repaint-crash.html": [ "6a024d0c1d7ef58da06a489d80d187bcb2a3e350", @@ -7833,6 +7847,13 @@ {} ] ], + "iframe-hit-test-during-load-event-crash.html": [ + "f668fc51573647e633fc3ac6430735d6fb4dfea7", + [ + null, + {} + ] + ], "iframe-loading-lazy-simple-crash.html": [ "b0b251438f73811ce2ec4d82fe47ffb3a2445c93", [ @@ -278356,6 +278377,45 @@ {} ] ], + "stacking-context-002.html": [ + "ff1d06dcc11ff445abc8ecaebe305836aa6ab14f", + [ + null, + [ + [ + "/css/reference/ref-filled-green-100px-square.xht", + "==" + ] + ], + {} + ] + ], + "stacking-context-003.html": [ + "6852722ed79183119f2a3fb142077b9e7c638e91", + [ + null, + [ + [ + "/css/reference/ref-filled-green-100px-square.xht", + "==" + ] + ], + {} + ] + ], + "stacking-context-004.html": [ + "6d7ec896736db0dc813a6e80ac4c75b7066e12e0", + [ + null, + [ + [ + "/css/reference/ref-filled-green-100px-square.xht", + "==" + ] + ], + {} + ] + ], "translate-fill-box.html": [ "8892d63327964cf1e9c16a3febaecf5af4d1cceb", [ @@ -739702,14 +739762,14 @@ ], "processing-model-1": { "col-span-limits.html": [ - "a4a425b9c1f70926c77ad3eb1b8a8a87a4655de9", + "2a1ac80e65ad37a0e15ca383e67889b79f2308d0", [ null, {} ] ], "span-limits.html": [ - "cdfa61bbcdc06ea62b80d042440d55fb0c89a186", + "798639b387562a54965d5283673a50773c2a3c49", [ null, { diff --git a/tests/wpt/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/iframe-nosrc.html.ini b/tests/wpt/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/iframe-nosrc.html.ini index 02a8e91ea04..d5f4fa2f799 100644 --- a/tests/wpt/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/iframe-nosrc.html.ini +++ b/tests/wpt/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/iframe-nosrc.html.ini @@ -2,8 +2,5 @@ [window.open] expected: FAIL - [link click] - expected: FAIL - [form submission] expected: FAIL diff --git a/tests/wpt/meta/html/canvas/element/manual/imagebitmap/createImageBitmap-transfer.html.ini b/tests/wpt/meta/html/canvas/element/manual/imagebitmap/createImageBitmap-transfer.html.ini index 7e036a1c4e4..5d2657041d1 100644 --- a/tests/wpt/meta/html/canvas/element/manual/imagebitmap/createImageBitmap-transfer.html.ini +++ b/tests/wpt/meta/html/canvas/element/manual/imagebitmap/createImageBitmap-transfer.html.ini @@ -1,5 +1,5 @@ [createImageBitmap-transfer.html] - expected: TIMEOUT + expected: ERROR [Transfer ImageBitmap created from a vector HTMLImageElement] expected: FAIL diff --git a/tests/wpt/meta/html/dom/idlharness.https.html.ini b/tests/wpt/meta/html/dom/idlharness.https.html.ini index ac7504347d7..25375c6ea47 100644 --- a/tests/wpt/meta/html/dom/idlharness.https.html.ini +++ b/tests/wpt/meta/html/dom/idlharness.https.html.ini @@ -5732,9 +5732,6 @@ [SVGSVGElement interface: attribute onunload] expected: FAIL - [ShadowRoot interface: operation setHTMLUnsafe((TrustedHTML or DOMString))] - expected: FAIL - [OffscreenCanvasRenderingContext2D interface: operation getContextAttributes()] expected: FAIL diff --git a/tests/wpt/meta/html/dom/reflection-tabular.html.ini b/tests/wpt/meta/html/dom/reflection-tabular.html.ini index 7550e2dc15d..1aeec1b3ef7 100644 --- a/tests/wpt/meta/html/dom/reflection-tabular.html.ini +++ b/tests/wpt/meta/html/dom/reflection-tabular.html.ini @@ -1487,9 +1487,6 @@ [colgroup.tabIndex: IDL set to -2147483648] expected: FAIL - [colgroup.span: setAttribute() to 2147483647] - expected: FAIL - [colgroup.span: setAttribute() to 2147483648] expected: FAIL @@ -1499,9 +1496,6 @@ [colgroup.span: setAttribute() to 4294967296] expected: FAIL - [colgroup.span: setAttribute() to 1001] - expected: FAIL - [colgroup.span: IDL set to 0] expected: FAIL @@ -2276,9 +2270,6 @@ [col.tabIndex: IDL set to -2147483648] expected: FAIL - [col.span: setAttribute() to 2147483647] - expected: FAIL - [col.span: setAttribute() to 2147483648] expected: FAIL @@ -2288,9 +2279,6 @@ [col.span: setAttribute() to 4294967296] expected: FAIL - [col.span: setAttribute() to 1001] - expected: FAIL - [col.span: IDL set to 0] expected: FAIL @@ -5657,9 +5645,6 @@ [td.tabIndex: IDL set to -2147483648] expected: FAIL - [td.colSpan: setAttribute() to 2147483647] - expected: FAIL - [td.colSpan: setAttribute() to 2147483648] expected: FAIL @@ -5669,9 +5654,6 @@ [td.colSpan: setAttribute() to 4294967296] expected: FAIL - [td.colSpan: setAttribute() to 1001] - expected: FAIL - [td.colSpan: IDL set to 0] expected: FAIL @@ -5684,9 +5666,6 @@ [td.colSpan: IDL set to 1001] expected: FAIL - [td.rowSpan: setAttribute() to 2147483647] - expected: FAIL - [td.rowSpan: setAttribute() to 2147483648] expected: FAIL @@ -5696,9 +5675,6 @@ [td.rowSpan: setAttribute() to 4294967296] expected: FAIL - [td.rowSpan: setAttribute() to 65535] - expected: FAIL - [td.rowSpan: IDL set to 2147483647] expected: FAIL @@ -7157,9 +7133,6 @@ [th.tabIndex: IDL set to -2147483648] expected: FAIL - [th.colSpan: setAttribute() to 2147483647] - expected: FAIL - [th.colSpan: setAttribute() to 2147483648] expected: FAIL @@ -7169,9 +7142,6 @@ [th.colSpan: setAttribute() to 4294967296] expected: FAIL - [th.colSpan: setAttribute() to 1001] - expected: FAIL - [th.colSpan: IDL set to 0] expected: FAIL @@ -7184,9 +7154,6 @@ [th.colSpan: IDL set to 1001] expected: FAIL - [th.rowSpan: setAttribute() to 2147483647] - expected: FAIL - [th.rowSpan: setAttribute() to 2147483648] expected: FAIL @@ -7196,9 +7163,6 @@ [th.rowSpan: setAttribute() to 4294967296] expected: FAIL - [th.rowSpan: setAttribute() to 65535] - expected: FAIL - [th.rowSpan: IDL set to 2147483647] expected: FAIL diff --git a/tests/wpt/meta/html/infrastructure/urls/base-url/document-base-url-window-initiator-is-not-opener.https.window.js.ini b/tests/wpt/meta/html/infrastructure/urls/base-url/document-base-url-window-initiator-is-not-opener.https.window.js.ini index 8b8af2b9c2e..2ef0896e3b3 100644 --- a/tests/wpt/meta/html/infrastructure/urls/base-url/document-base-url-window-initiator-is-not-opener.https.window.js.ini +++ b/tests/wpt/meta/html/infrastructure/urls/base-url/document-base-url-window-initiator-is-not-opener.https.window.js.ini @@ -1,3 +1,4 @@ [document-base-url-window-initiator-is-not-opener.https.window.html] + expected: TIMEOUT [window.open() gets base url from initiator not opener.] expected: [FAIL, PASS, TIMEOUT] diff --git a/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-1.html.ini b/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-1.html.ini index 62a6e7fc812..bbc1f35d8d9 100644 --- a/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-1.html.ini +++ b/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-1.html.ini @@ -1,4 +1,3 @@ [iframe_sandbox_popups_nonescaping-1.html] - expected: CRASH [Check that popups from a sandboxed iframe do not escape the sandbox] - expected: NOTRUN + expected: FAIL diff --git a/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-3.html.ini b/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-3.html.ini index d5fd800f09d..ccdaf8d61b2 100644 --- a/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-3.html.ini +++ b/tests/wpt/meta/html/semantics/embedded-content/the-iframe-element/iframe_sandbox_popups_nonescaping-3.html.ini @@ -1,4 +1,3 @@ [iframe_sandbox_popups_nonescaping-3.html] - expected: TIMEOUT [Check that popups from a sandboxed iframe do not escape the sandbox] expected: NOTRUN diff --git a/tests/wpt/meta/html/webappapis/dynamic-markup-insertion/html-unsafe-methods/setHTMLUnsafe-CEReactions.html.ini b/tests/wpt/meta/html/webappapis/dynamic-markup-insertion/html-unsafe-methods/setHTMLUnsafe-CEReactions.html.ini deleted file mode 100644 index d0b3986d561..00000000000 --- a/tests/wpt/meta/html/webappapis/dynamic-markup-insertion/html-unsafe-methods/setHTMLUnsafe-CEReactions.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[setHTMLUnsafe-CEReactions.html] - [ShadowRoot.setHTMLUnsafe should trigger custom element reactions.] - expected: FAIL diff --git a/tests/wpt/meta/html/webappapis/dynamic-markup-insertion/html-unsafe-methods/setHTMLUnsafe.html.ini b/tests/wpt/meta/html/webappapis/dynamic-markup-insertion/html-unsafe-methods/setHTMLUnsafe.html.ini deleted file mode 100644 index 850b529ff76..00000000000 --- a/tests/wpt/meta/html/webappapis/dynamic-markup-insertion/html-unsafe-methods/setHTMLUnsafe.html.ini +++ /dev/null @@ -1,6 +0,0 @@ -[setHTMLUnsafe.html] - [ShadowRoot: setHTMLUnsafe with no shadowdom.] - expected: FAIL - - [ShadowRoot: setHTMLUnsafe with shadowdom.] - expected: FAIL diff --git a/tests/wpt/meta/navigation-timing/test-navigation-type-reload.html.ini b/tests/wpt/meta/navigation-timing/test-navigation-type-reload.html.ini index 0bb708b5b98..fb5e4d1adbe 100644 --- a/tests/wpt/meta/navigation-timing/test-navigation-type-reload.html.ini +++ b/tests/wpt/meta/navigation-timing/test-navigation-type-reload.html.ini @@ -22,9 +22,3 @@ [Reload domComplete > Original domComplete] expected: FAIL - - [Reload loadEventEnd > Original loadEventEnd] - expected: FAIL - - [Reload loadEventStart > Original loadEventStart] - expected: FAIL diff --git a/tests/wpt/meta/shadow-dom/declarative/gethtml.html.ini b/tests/wpt/meta/shadow-dom/declarative/gethtml.html.ini deleted file mode 100644 index 3a96cb5998d..00000000000 --- a/tests/wpt/meta/shadow-dom/declarative/gethtml.html.ini +++ /dev/null @@ -1,4896 +0,0 @@ -[gethtml.html] - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <article><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <aside><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <blockquote><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <div><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <footer><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h1><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h2><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h3><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h4><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h5><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <h6><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <header><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <main><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <nav><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <p><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <section><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=false, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=false, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=open, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=undefined, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=false, clonable=true, without shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, with shadow tree contents.] - expected: FAIL - - [ShadowRoot.getHTML() on <span><span>light</span>, with declarative shadow, mode=closed, delegatesFocus=true, serializable=true, clonable=true, without shadow tree contents.] - expected: FAIL diff --git a/tests/wpt/meta/trusted-types/block-string-assignment-to-ShadowRoot-setHTMLUnsafe.html.ini b/tests/wpt/meta/trusted-types/block-string-assignment-to-ShadowRoot-setHTMLUnsafe.html.ini index 1e95f7f9744..855ee5803f5 100644 --- a/tests/wpt/meta/trusted-types/block-string-assignment-to-ShadowRoot-setHTMLUnsafe.html.ini +++ b/tests/wpt/meta/trusted-types/block-string-assignment-to-ShadowRoot-setHTMLUnsafe.html.ini @@ -1,9 +1,9 @@ [block-string-assignment-to-ShadowRoot-setHTMLUnsafe.html] - [shadowRoot.setHTMLUnsafe(html) assigned via policy (successful HTML transformation).] + [`shadowRoot.setHTMLUnsafe(string)` assigned via default policy (successful HTML transformation).] expected: FAIL - [`shadowRoot.setHTMLUnsafe(string)` assigned via default policy (successful HTML transformation).] + [`shadowRoot.setHTMLUnsafe(string)` throws.] expected: FAIL - [`shadowRoot.setHTMLUnsafe(string)` assigned via default policy does not throw] + [`shadowRoot.setHTMLUnsafe(null)` throws.] expected: FAIL diff --git a/tests/wpt/meta/trusted-types/trusted-types-reporting-for-ShadowRoot-setHTMLUnsafe.html.ini b/tests/wpt/meta/trusted-types/trusted-types-reporting-for-ShadowRoot-setHTMLUnsafe.html.ini index f42e7fa4f8b..79d9d1805d8 100644 --- a/tests/wpt/meta/trusted-types/trusted-types-reporting-for-ShadowRoot-setHTMLUnsafe.html.ini +++ b/tests/wpt/meta/trusted-types/trusted-types-reporting-for-ShadowRoot-setHTMLUnsafe.html.ini @@ -1,6 +1,3 @@ [trusted-types-reporting-for-ShadowRoot-setHTMLUnsafe.html] - [No violation reported for TrustedHTML.] - expected: FAIL - [Violation report for plain string.] expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/accept_alert/accept.py.ini b/tests/wpt/meta/webdriver/tests/classic/accept_alert/accept.py.ini new file mode 100644 index 00000000000..00caf69c8d5 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/accept_alert/accept.py.ini @@ -0,0 +1,27 @@ +[accept.py] + [test_null_response_value] + expected: FAIL + + [test_no_top_level_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_no_user_prompt] + expected: FAIL + + [test_accept_alert] + expected: FAIL + + [test_accept_confirm] + expected: FAIL + + [test_accept_prompt] + expected: FAIL + + [test_unexpected_alert] + expected: FAIL + + [test_accept_in_popup_window] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/add_cookie/add.py.ini b/tests/wpt/meta/webdriver/tests/classic/add_cookie/add.py.ini new file mode 100644 index 00000000000..37610cfc8ee --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/add_cookie/add.py.ini @@ -0,0 +1,42 @@ +[add.py] + [test_no_browsing_context] + expected: FAIL + + [test_cookie_unsupported_scheme[about\]] + expected: FAIL + + [test_cookie_unsupported_scheme[blob\]] + expected: FAIL + + [test_cookie_unsupported_scheme[data\]] + expected: FAIL + + [test_cookie_unsupported_scheme[file\]] + expected: FAIL + + [test_cookie_unsupported_scheme[ftp\]] + expected: FAIL + + [test_cookie_unsupported_scheme[javascript\]] + expected: FAIL + + [test_cookie_unsupported_scheme[websocket\]] + expected: FAIL + + [test_cookie_unsupported_scheme[secure websocket\]] + expected: FAIL + + [test_add_non_session_cookie] + expected: FAIL + + [test_add_cookie_with_valid_samesite_flag[None\]] + expected: FAIL + + [test_add_cookie_with_valid_samesite_flag[Lax\]] + expected: FAIL + + [test_add_cookie_with_valid_samesite_flag[Strict\]] + expected: FAIL + + [test_add_cookie_with_invalid_samesite_flag] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/add_cookie/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/add_cookie/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/add_cookie/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/back/back.py.ini b/tests/wpt/meta/webdriver/tests/classic/back/back.py.ini new file mode 100644 index 00000000000..10d35cc69e3 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/back/back.py.ini @@ -0,0 +1,19 @@ +[back.py] + disabled: consistent panic + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR + + [test_seen_nodes[http\]] + expected: FAIL + + [test_seen_nodes[https\]] + expected: FAIL + + [test_seen_nodes[https coop\]] + expected: FAIL + + [test_history_pushstate] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/back/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/back/user_prompts.py.ini new file mode 100644 index 00000000000..fcf10a0526c --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/back/user_prompts.py.ini @@ -0,0 +1,73 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert\]] + expected: FAIL + + [test_accept[capabilities0-beforeunload\]] + expected: FAIL + + [test_accept[capabilities0-confirm\]] + expected: FAIL + + [test_accept[capabilities0-prompt\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert\]] + expected: FAIL + + [test_dismiss[capabilities0-beforeunload\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-beforeunload\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[beforeunload-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/close_window/close.py.ini b/tests/wpt/meta/webdriver/tests/classic/close_window/close.py.ini new file mode 100644 index 00000000000..b1f13cee75e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/close_window/close.py.ini @@ -0,0 +1,19 @@ +[close.py] + disabled: panic in test_close_browsing_context_with_accepted_beforeunload_prompt + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_close_browsing_context_with_accepted_beforeunload_prompt[tab\]] + expected: FAIL + + [test_close_browsing_context_with_accepted_beforeunload_prompt[window\]] + expected: ERROR + + [test_close_last_browsing_context] + expected: ERROR + + [test_element_usage_after_closing_browsing_context] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/close_window/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/close_window/user_prompts.py.ini new file mode 100644 index 00000000000..fcf10a0526c --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/close_window/user_prompts.py.ini @@ -0,0 +1,73 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert\]] + expected: FAIL + + [test_accept[capabilities0-beforeunload\]] + expected: FAIL + + [test_accept[capabilities0-confirm\]] + expected: FAIL + + [test_accept[capabilities0-prompt\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert\]] + expected: FAIL + + [test_dismiss[capabilities0-beforeunload\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-beforeunload\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[beforeunload-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/delete_all_cookies/delete.py.ini b/tests/wpt/meta/webdriver/tests/classic/delete_all_cookies/delete.py.ini new file mode 100644 index 00000000000..1a53a7bbaf5 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/delete_all_cookies/delete.py.ini @@ -0,0 +1,3 @@ +[delete.py] + [test_no_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/delete_all_cookies/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/delete_all_cookies/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/delete_all_cookies/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/delete_cookie/delete.py.ini b/tests/wpt/meta/webdriver/tests/classic/delete_cookie/delete.py.ini new file mode 100644 index 00000000000..1a53a7bbaf5 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/delete_cookie/delete.py.ini @@ -0,0 +1,3 @@ +[delete.py] + [test_no_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/delete_cookie/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/delete_cookie/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/delete_cookie/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/delete_session/delete.py.ini b/tests/wpt/meta/webdriver/tests/classic/delete_session/delete.py.ini new file mode 100644 index 00000000000..ee03ab08fe3 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/delete_session/delete.py.ini @@ -0,0 +1,7 @@ +[delete.py] + expected: ERROR + [test_null_response_value] + expected: FAIL + + [test_accepted_beforeunload_prompt] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/dismiss_alert/dismiss.py.ini b/tests/wpt/meta/webdriver/tests/classic/dismiss_alert/dismiss.py.ini new file mode 100644 index 00000000000..cd2546ede8b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/dismiss_alert/dismiss.py.ini @@ -0,0 +1,24 @@ +[dismiss.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_no_user_prompt] + expected: FAIL + + [test_dismiss_alert] + expected: FAIL + + [test_dismiss_confirm] + expected: FAIL + + [test_dismiss_prompt] + expected: FAIL + + [test_unexpected_alert] + expected: FAIL + + [test_dismiss_in_popup_window] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_clear/clear.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_clear/clear.py.ini new file mode 100644 index 00000000000..541ffc25ca6 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_clear/clear.py.ini @@ -0,0 +1,2 @@ +[clear.py] + expected: TIMEOUT diff --git a/tests/wpt/meta/webdriver/tests/classic/element_clear/disabled.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_clear/disabled.py.ini new file mode 100644 index 00000000000..f6367167d66 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_clear/disabled.py.ini @@ -0,0 +1,115 @@ +[disabled.py] + expected: TIMEOUT + [test_button[button\]] + expected: FAIL + + [test_button[reset\]] + expected: FAIL + + [test_button[submit\]] + expected: FAIL + + [test_input[button\]] + expected: FAIL + + [test_input[checkbox\]] + expected: FAIL + + [test_input[color\]] + expected: FAIL + + [test_input[date\]] + expected: FAIL + + [test_input[datetime-local\]] + expected: FAIL + + [test_input[email\]] + expected: FAIL + + [test_input[file\]] + expected: FAIL + + [test_input[image\]] + expected: FAIL + + [test_input[month\]] + expected: FAIL + + [test_input[number\]] + expected: FAIL + + [test_input[password\]] + expected: FAIL + + [test_input[radio\]] + expected: FAIL + + [test_input[range\]] + expected: FAIL + + [test_input[reset\]] + expected: FAIL + + [test_input[search\]] + expected: FAIL + + [test_input[submit\]] + expected: FAIL + + [test_input[tel\]] + expected: FAIL + + [test_input[text\]] + expected: FAIL + + [test_input[time\]] + expected: FAIL + + [test_input[url\]] + expected: FAIL + + [test_input[week\]] + expected: FAIL + + [test_textarea] + expected: FAIL + + [test_fieldset_descendant] + expected: FAIL + + [test_fieldset_descendant_first_legend] + expected: FAIL + + [test_fieldset_descendant_not_first_legend] + expected: FAIL + + [test_option] + expected: FAIL + + [test_option_optgroup] + expected: FAIL + + [test_option_select] + expected: FAIL + + [test_optgroup_select] + expected: FAIL + + [test_select] + expected: FAIL + + [test_xhtml[button\]] + expected: FAIL + + [test_xhtml[input\]] + expected: FAIL + + [test_xhtml[select\]] + expected: FAIL + + [test_xhtml[textarea\]] + expected: FAIL + + [test_xml] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_clear/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_clear/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_clear/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/bubbling.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/bubbling.py.ini new file mode 100644 index 00000000000..d99f3672ef6 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/bubbling.py.ini @@ -0,0 +1,6 @@ +[bubbling.py] + [test_click_event_bubbles_to_parents] + expected: FAIL + + [test_spin_event_loop] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/center_point.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/center_point.py.ini new file mode 100644 index 00000000000..3e3bfa2708e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/center_point.py.ini @@ -0,0 +1,33 @@ +[center_point.py] + [test_entirely_in_view] + expected: FAIL + + [test_css_pixel_rounding[1\]] + expected: FAIL + + [test_css_pixel_rounding[2\]] + expected: FAIL + + [test_css_pixel_rounding[3\]] + expected: FAIL + + [test_css_pixel_rounding[4\]] + expected: FAIL + + [test_css_pixel_rounding[5\]] + expected: FAIL + + [test_css_pixel_rounding[6\]] + expected: FAIL + + [test_css_pixel_rounding[7\]] + expected: FAIL + + [test_css_pixel_rounding[8\]] + expected: FAIL + + [test_css_pixel_rounding[9\]] + expected: FAIL + + [test_css_pixel_rounding[10\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/click.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/click.py.ini new file mode 100644 index 00000000000..ad0f9714ad1 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/click.py.ini @@ -0,0 +1,21 @@ +[click.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/events.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/events.py.ini new file mode 100644 index 00000000000..8f57d96cef8 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/events.py.ini @@ -0,0 +1,3 @@ +[events.py] + [test_event_mousemove] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/interactability.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/interactability.py.ini new file mode 100644 index 00000000000..982ea5ca753 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/interactability.py.ini @@ -0,0 +1,33 @@ +[interactability.py] + [test_display_none] + expected: FAIL + + [test_visibility_hidden] + expected: FAIL + + [test_hidden] + expected: FAIL + + [test_element_not_interactable_css_transform[translate(-100px, -100px)\]] + expected: FAIL + + [test_element_not_interactable_css_transform[rotate(50deg)\]] + expected: FAIL + + [test_element_not_interactable_out_of_view] + expected: FAIL + + [test_zero_sized_element[div\]] + expected: FAIL + + [test_zero_sized_element[span\]] + expected: FAIL + + [test_element_intercepted] + expected: FAIL + + [test_element_intercepted_no_pointer_events] + expected: FAIL + + [test_element_not_visible_overflow_hidden] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/navigate.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/navigate.py.ini new file mode 100644 index 00000000000..4811bba2d43 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/navigate.py.ini @@ -0,0 +1,49 @@ +[navigate.py] + expected: TIMEOUT + [test_numbers_link] + expected: FAIL + + [test_multi_line_link] + expected: FAIL + + [test_navigation_retains_input_state] + expected: FAIL + + [test_link_hash] + expected: FAIL + + [test_link_from_toplevel_context_with_target[\]] + expected: FAIL + + [test_link_from_toplevel_context_with_target[_blank\]] + expected: FAIL + + [test_link_from_toplevel_context_with_target[_parent\]] + expected: FAIL + + [test_link_from_toplevel_context_with_target[_self\]] + expected: FAIL + + [test_link_from_toplevel_context_with_target[_top\]] + expected: FAIL + + [test_link_from_nested_context_with_target[\]] + expected: FAIL + + [test_link_from_nested_context_with_target[_blank\]] + expected: FAIL + + [test_link_from_nested_context_with_target[_parent\]] + expected: FAIL + + [test_link_from_nested_context_with_target[_self\]] + expected: FAIL + + [test_link_from_nested_context_with_target[_top\]] + expected: FAIL + + [test_link_cross_origin] + expected: FAIL + + [test_link_closes_window] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/scroll_into_view.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/scroll_into_view.py.ini new file mode 100644 index 00000000000..87c9c813881 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/scroll_into_view.py.ini @@ -0,0 +1,30 @@ +[scroll_into_view.py] + [test_scroll_into_view] + expected: ERROR + + [test_partially_visible_does_not_scroll[9\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[8\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[7\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[6\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[5\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[4\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[3\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[2\]] + expected: ERROR + + [test_partially_visible_does_not_scroll[1\]] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/select.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/select.py.ini new file mode 100644 index 00000000000..2bf7e5abac4 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/select.py.ini @@ -0,0 +1,15 @@ +[select.py] + [test_click_option] + expected: FAIL + + [test_click_preselected_option] + expected: FAIL + + [test_click_deselects_others] + expected: FAIL + + [test_click_selected_option] + expected: FAIL + + [test_out_of_view_dropdown] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/shadow_dom.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/shadow_dom.py.ini new file mode 100644 index 00000000000..92d8bfe9a3d --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/shadow_dom.py.ini @@ -0,0 +1,15 @@ +[shadow_dom.py] + [test_shadow_element_click[host_element\]] + expected: FAIL + + [test_shadow_element_click[checkbox_element\]] + expected: FAIL + + [test_nested_shadow_element_click[outer_element\]] + expected: FAIL + + [test_nested_shadow_element_click[inner_element\]] + expected: FAIL + + [test_nested_shadow_element_click[checkbox\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_click/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_click/user_prompts.py.ini new file mode 100644 index 00000000000..a050673119e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_click/user_prompts.py.ini @@ -0,0 +1,73 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-beforeunload\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[beforeunload-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/content_editable.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/content_editable.py.ini new file mode 100644 index 00000000000..3cf383a34ff --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/content_editable.py.ini @@ -0,0 +1,9 @@ +[content_editable.py] + [test_sets_insertion_point_to_end] + expected: FAIL + + [test_sets_insertion_point_to_after_last_text_node] + expected: FAIL + + [test_no_move_caret_if_focused] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/events.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/events.py.ini new file mode 100644 index 00000000000..26b3aaa641b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/events.py.ini @@ -0,0 +1,9 @@ +[events.py] + [test_file_upload] + expected: FAIL + + [test_form_control_send_text[input\]] + expected: FAIL + + [test_form_control_send_text[textarea\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/file_upload.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/file_upload.py.ini new file mode 100644 index 00000000000..4fd4b29e87f --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/file_upload.py.ini @@ -0,0 +1,55 @@ +[file_upload.py] + expected: TIMEOUT + [test_empty_text] + expected: FAIL + + [test_multiple_files] + expected: FAIL + + [test_multiple_files_last_path_not_found] + expected: FAIL + + [test_multiple_files_without_multiple_attribute] + expected: FAIL + + [test_multiple_files_send_twice] + expected: FAIL + + [test_multiple_files_reset_with_element_clear] + expected: FAIL + + [test_single_file] + expected: FAIL + + [test_single_file_replaces_without_multiple_attribute] + expected: FAIL + + [test_single_file_appends_with_multiple_attribute] + expected: FAIL + + [test_transparent] + expected: FAIL + + [test_obscured] + expected: FAIL + + [test_outside_viewport] + expected: FAIL + + [test_hidden] + expected: FAIL + + [test_display_none] + expected: FAIL + + [test_not_focused] + expected: FAIL + + [test_focused] + expected: ERROR + + [test_strict_hidden] + expected: ERROR + + [test_strict_display_none] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/form_controls.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/form_controls.py.ini new file mode 100644 index 00000000000..5d4a3bd4de5 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/form_controls.py.ini @@ -0,0 +1,6 @@ +[form_controls.py] + [test_input_append] + expected: FAIL + + [test_textarea_append] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/interactability.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/interactability.py.ini new file mode 100644 index 00000000000..9510b686ea1 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/interactability.py.ini @@ -0,0 +1,24 @@ +[interactability.py] + [test_document_element_is_interactable] + expected: FAIL + + [test_iframe_is_interactable] + expected: FAIL + + [test_readonly_element] + expected: FAIL + + [test_not_a_focusable_element] + expected: FAIL + + [test_display_none] + expected: FAIL + + [test_visibility_hidden] + expected: FAIL + + [test_hidden] + expected: FAIL + + [test_disabled] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/scroll_into_view.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/scroll_into_view.py.ini new file mode 100644 index 00000000000..3e260cade03 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/scroll_into_view.py.ini @@ -0,0 +1,27 @@ +[scroll_into_view.py] + [test_element_outside_of_not_scrollable_viewport] + expected: FAIL + + [test_element_outside_of_scrollable_viewport] + expected: FAIL + + [test_contenteditable_element_outside_of_scrollable_viewport] + expected: FAIL + + [test_element_already_in_viewport[{block: 'start'}\]] + expected: FAIL + + [test_element_already_in_viewport[{block: 'center'}\]] + expected: FAIL + + [test_element_already_in_viewport[{block: 'end'}\]] + expected: FAIL + + [test_element_already_in_viewport[{block: 'nearest'}\]] + expected: FAIL + + [test_element_just_outside_viewport[Just above viewport\]] + expected: FAIL + + [test_element_just_outside_viewport[Just below viewport\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/send_keys.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/send_keys.py.ini new file mode 100644 index 00000000000..b2b09490191 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/send_keys.py.ini @@ -0,0 +1,21 @@ +[send_keys.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/element_send_keys/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/element_send_keys/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_async_script/arguments.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/arguments.py.ini new file mode 100644 index 00000000000..6bcbe1197f6 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/arguments.py.ini @@ -0,0 +1,2 @@ +[arguments.py] + expected: TIMEOUT diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_async_script/collections.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/collections.py.ini new file mode 100644 index 00000000000..5d0711fe4ad --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/collections.py.ini @@ -0,0 +1,12 @@ +[collections.py] + [test_array_in_array] + expected: FAIL + + [test_dom_token_list] + expected: FAIL + + [test_file_list] + expected: FAIL + + [test_html_all_collection] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_async_script/execute_async.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/execute_async.py.ini new file mode 100644 index 00000000000..6885d2e743e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/execute_async.py.ini @@ -0,0 +1,21 @@ +[execute_async.py] + [test_no_browsing_context] + expected: FAIL + + [test_abort_by_user_prompt[alert\]] + expected: FAIL + + [test_abort_by_user_prompt[confirm\]] + expected: FAIL + + [test_abort_by_user_prompt[prompt\]] + expected: FAIL + + [test_abort_by_user_prompt_twice[alert\]] + expected: FAIL + + [test_abort_by_user_prompt_twice[confirm\]] + expected: FAIL + + [test_abort_by_user_prompt_twice[prompt\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_async_script/node.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/node.py.ini new file mode 100644 index 00000000000..99dbcbef513 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/node.py.ini @@ -0,0 +1,33 @@ +[node.py] + [test_detached_shadow_root[top_context\]] + expected: FAIL + + [test_detached_shadow_root[child_context\]] + expected: FAIL + + [test_stale_element[top_context\]] + expected: FAIL + + [test_stale_element[child_context\]] + expected: FAIL + + [test_element_reference[shadow-root\]] + expected: FAIL + + [test_not_supported_nodes[attribute\]] + expected: FAIL + + [test_not_supported_nodes[text\]] + expected: FAIL + + [test_not_supported_nodes[processing_instruction\]] + expected: FAIL + + [test_not_supported_nodes[comment\]] + expected: FAIL + + [test_not_supported_nodes[document\]] + expected: FAIL + + [test_not_supported_nodes[doctype\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_async_script/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/user_prompts.py.ini new file mode 100644 index 00000000000..a050673119e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/user_prompts.py.ini @@ -0,0 +1,73 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-beforeunload\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[beforeunload-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_async_script/window.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/window.py.ini new file mode 100644 index 00000000000..5cd736463b1 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_async_script/window.py.ini @@ -0,0 +1,6 @@ +[window.py] + [test_web_reference[window\]] + expected: FAIL + + [test_window_open] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_script/arguments.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_script/arguments.py.ini new file mode 100644 index 00000000000..8818990c5ef --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_script/arguments.py.ini @@ -0,0 +1,88 @@ +[arguments.py] + expected: TIMEOUT + [test_no_such_element_with_unknown_id] + expected: FAIL + + [test_no_such_element_from_other_window_handle[open\]] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_no_such_shadow_root_with_unknown_id] + expected: FAIL + + [test_no_such_shadow_root_from_other_window_handle[open\]] + expected: FAIL + + [test_no_such_shadow_root_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_shadow_root_from_other_frame[open\]] + expected: FAIL + + [test_no_such_shadow_root_from_other_frame[closed\]] + expected: FAIL + + [test_detached_shadow_root_reference[top_context\]] + expected: FAIL + + [test_detached_shadow_root_reference[child_context\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[None-frame\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[None-window\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[False-frame\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[False-window\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[42-frame\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[42-window\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[value3-frame\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[value3-window\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[value4-frame\]] + expected: FAIL + + [test_invalid_argument_for_window_with_invalid_type[value4-window\]] + expected: FAIL + + [test_no_such_window_for_window_with_invalid_value] + expected: FAIL + + [test_element_reference[frame\]] + expected: FAIL + + [test_element_reference[node\]] + expected: FAIL + + [test_element_reference[shadow-root\]] + expected: FAIL + + [test_element_reference[window\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_script/collections.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_script/collections.py.ini new file mode 100644 index 00000000000..68e5ec4b830 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_script/collections.py.ini @@ -0,0 +1,12 @@ +[collections.py] + [test_dom_token_list] + expected: FAIL + + [test_file_list] + expected: FAIL + + [test_html_all_collection] + expected: FAIL + + [test_array_in_array] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_script/execute.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_script/execute.py.ini new file mode 100644 index 00000000000..8a1571d1d7b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_script/execute.py.ini @@ -0,0 +1,24 @@ +[execute.py] + [test_no_browsing_context] + expected: FAIL + + [test_opening_new_window_keeps_current_window_handle] + expected: FAIL + + [test_abort_by_user_prompt[alert\]] + expected: FAIL + + [test_abort_by_user_prompt[confirm\]] + expected: FAIL + + [test_abort_by_user_prompt[prompt\]] + expected: FAIL + + [test_abort_by_user_prompt_twice[alert\]] + expected: FAIL + + [test_abort_by_user_prompt_twice[confirm\]] + expected: FAIL + + [test_abort_by_user_prompt_twice[prompt\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_script/node.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_script/node.py.ini new file mode 100644 index 00000000000..dd95e12798a --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_script/node.py.ini @@ -0,0 +1,33 @@ +[node.py] + [test_detached_shadow_root[top_context\]] + expected: FAIL + + [test_detached_shadow_root[child_context\]] + expected: FAIL + + [test_stale_element[top_context\]] + expected: FAIL + + [test_stale_element[child_context\]] + expected: FAIL + + [test_web_reference[shadow-root\]] + expected: FAIL + + [test_not_supported_nodes[attribute\]] + expected: FAIL + + [test_not_supported_nodes[text\]] + expected: FAIL + + [test_not_supported_nodes[processing_instruction\]] + expected: FAIL + + [test_not_supported_nodes[comment\]] + expected: FAIL + + [test_not_supported_nodes[document\]] + expected: ERROR + + [test_not_supported_nodes[doctype\]] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_script/promise.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_script/promise.py.ini new file mode 100644 index 00000000000..d5d950aa7ac --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_script/promise.py.ini @@ -0,0 +1,27 @@ +[promise.py] + [test_promise_resolve] + expected: FAIL + + [test_promise_resolve_delayed] + expected: FAIL + + [test_promise_all_resolve] + expected: FAIL + + [test_await_promise_resolve] + expected: FAIL + + [test_promise_resolve_timeout] + expected: FAIL + + [test_promise_reject] + expected: FAIL + + [test_promise_reject_delayed] + expected: FAIL + + [test_promise_all_reject] + expected: FAIL + + [test_promise_reject_timeout] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_script/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_script/user_prompts.py.ini new file mode 100644 index 00000000000..a050673119e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_script/user_prompts.py.ini @@ -0,0 +1,73 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-beforeunload\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[beforeunload-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/execute_script/window.py.ini b/tests/wpt/meta/webdriver/tests/classic/execute_script/window.py.ini new file mode 100644 index 00000000000..9de464ed4f0 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/execute_script/window.py.ini @@ -0,0 +1,15 @@ +[window.py] + [test_web_reference[window\]] + expected: FAIL + + [test_web_reference_in_array[window\]] + expected: FAIL + + [test_web_reference_in_object[window\]] + expected: FAIL + + [test_window_open] + expected: FAIL + + [test_same_id_after_cross_origin_navigation] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_element/find.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_element/find.py.ini new file mode 100644 index 00000000000..7564f644b10 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_element/find.py.ini @@ -0,0 +1,34 @@ +[find.py] + expected: TIMEOUT + [test_no_browsing_context] + expected: ERROR + + [test_no_such_element_with_unknown_selector[not-existent\]] + expected: FAIL + + [test_no_such_element_with_unknown_selector[existent-other-frame\]] + expected: FAIL + + [test_no_such_element_with_unknown_selector[existent-inside-shadow-root\]] + expected: FAIL + + [test_find_element[xpath-//a\]] + expected: FAIL + + [test_xhtml_namespace[css selector-#linkText\]] + expected: FAIL + + [test_xhtml_namespace[link text-full link text\]] + expected: FAIL + + [test_xhtml_namespace[partial link text-link text\]] + expected: FAIL + + [test_xhtml_namespace[tag name-a\]] + expected: FAIL + + [test_xhtml_namespace[xpath-//*[name()='a'\]\]] + expected: FAIL + + [test_htmldocument[xpath-/html\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_element/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_element/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_element/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_element_from_element/find.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_element_from_element/find.py.ini new file mode 100644 index 00000000000..64a0652b75b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_element_from_element/find.py.ini @@ -0,0 +1,52 @@ +[find.py] + expected: TIMEOUT + [test_no_browsing_context] + expected: ERROR + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_with_unknown_selector[not-existent\]] + expected: FAIL + + [test_no_such_element_with_unknown_selector[existent-other-frame\]] + expected: FAIL + + [test_no_such_element_with_unknown_selector[existent-inside-shadow-root\]] + expected: FAIL + + [test_no_such_element_with_startnode_from_other_window_handle] + expected: FAIL + + [test_no_such_element_with_startnode_from_other_frame] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_find_element[xpath-//a\]] + expected: FAIL + + [test_xhtml_namespace[css selector-#linkText\]] + expected: FAIL + + [test_xhtml_namespace[link text-full link text\]] + expected: FAIL + + [test_xhtml_namespace[partial link text-link text\]] + expected: FAIL + + [test_xhtml_namespace[tag name-a\]] + expected: FAIL + + [test_xhtml_namespace[xpath-//*[name()='a'\]\]] + expected: FAIL + + [test_parent_htmldocument] + expected: FAIL + + [test_parent_of_document_node_errors] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_element_from_element/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_element_from_element/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_element_from_element/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_element_from_shadow_root/find.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_element_from_shadow_root/find.py.ini new file mode 100644 index 00000000000..dba98c7726b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_element_from_shadow_root/find.py.ini @@ -0,0 +1,157 @@ +[find.py] + expected: TIMEOUT + [test_null_parameter_value] + expected: FAIL + + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR + + [test_no_such_shadow_root_with_element] + expected: FAIL + + [test_no_such_shadow_root_with_unknown_shadow_root] + expected: FAIL + + [test_no_such_shadow_root_with_shadow_root_from_other_window_handle] + expected: FAIL + + [test_no_such_shadow_root_with_shadow_root_from_other_frame] + expected: FAIL + + [test_detached_shadow_root[top_context\]] + expected: FAIL + + [test_detached_shadow_root[child_context\]] + expected: FAIL + + [test_no_such_element_with_unknown_selector[not-existent\]] + expected: FAIL + + [test_no_such_element_with_unknown_selector[existent-other-frame\]] + expected: FAIL + + [test_no_such_element_with_unknown_selector[existent-outside-shadow-root\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[True\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[None\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[1\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[shadow_root_id3\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[shadow_root_id4\]] + expected: FAIL + + [test_invalid_using_argument[a\]] + expected: FAIL + + [test_invalid_using_argument[True\]] + expected: FAIL + + [test_invalid_using_argument[None\]] + expected: FAIL + + [test_invalid_using_argument[1\]] + expected: FAIL + + [test_invalid_using_argument[using4\]] + expected: FAIL + + [test_invalid_using_argument[using5\]] + expected: FAIL + + [test_invalid_selector_argument[None\]] + expected: FAIL + + [test_invalid_selector_argument[value1\]] + expected: FAIL + + [test_invalid_selector_argument[value2\]] + expected: FAIL + + [test_found_element_equivalence] + expected: FAIL + + [test_find_element[open-css selector-#linkText\]] + expected: FAIL + + [test_find_element[open-link text-full link text\]] + expected: FAIL + + [test_find_element[open-partial link text-link text\]] + expected: FAIL + + [test_find_element[open-tag name-a\]] + expected: FAIL + + [test_find_element[open-xpath-//a\]] + expected: FAIL + + [test_find_element[closed-css selector-#linkText\]] + expected: FAIL + + [test_find_element[closed-link text-full link text\]] + expected: FAIL + + [test_find_element[closed-partial link text-link text\]] + expected: FAIL + + [test_find_element[closed-tag name-a\]] + expected: FAIL + + [test_find_element[closed-xpath-//a\]] + expected: FAIL + + [test_find_element_link_text[<a href=#>link text</a>-link text\]] + expected: FAIL + + [test_find_element_link_text[<a href=#> link text </a>-link text\]] + expected: FAIL + + [test_find_element_link_text[<a href=#>link<br>text</a>-link\\ntext\]] + expected: FAIL + + [test_find_element_link_text[<a href=#>link&text</a>-link&text\]] + expected: FAIL + + [test_find_element_link_text[<a href=#>LINK TEXT</a>-LINK TEXT\]] + expected: FAIL + + [test_find_element_link_text[<a href=# style='text-transform: uppercase'>link text</a>-LINK TEXT\]] + expected: FAIL + + [test_find_element_partial_link_text[<a href=#>partial link text</a>-link\]] + expected: FAIL + + [test_find_element_partial_link_text[<a href=#> partial link text </a>-link\]] + expected: FAIL + + [test_find_element_partial_link_text[<a href=#>partial link text</a>-k t\]] + expected: FAIL + + [test_find_element_partial_link_text[<a href=#>partial link<br>text</a>-k\\nt\]] + expected: FAIL + + [test_find_element_partial_link_text[<a href=#>partial link&text</a>-k&t\]] + expected: FAIL + + [test_find_element_partial_link_text[<a href=#>PARTIAL LINK TEXT</a>-LINK\]] + expected: FAIL + + [test_find_element_partial_link_text[<a href=# style='text-transform: uppercase'>partial link text</a>-LINK\]] + expected: FAIL + + [test_find_element_in_nested_shadow_root[open\]] + expected: FAIL + + [test_find_element_in_nested_shadow_root[closed\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_element_from_shadow_root/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_element_from_shadow_root/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_element_from_shadow_root/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_elements/find.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_elements/find.py.ini new file mode 100644 index 00000000000..44f232824bb --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_elements/find.py.ini @@ -0,0 +1,76 @@ +[find.py] + expected: TIMEOUT + [test_no_browsing_context] + expected: ERROR + + [test_find_elements[css selector-#linkText\]] + expected: FAIL + + [test_find_elements[link text-full link text\]] + expected: FAIL + + [test_find_elements[partial link text-link text\]] + expected: FAIL + + [test_find_elements[tag name-a\]] + expected: FAIL + + [test_find_elements[xpath-//a\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link text</a>-link text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#> link text </a>-link text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link<br>text</a>-link\\ntext\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link&text</a>-link&text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>LINK TEXT</a>-LINK TEXT\]] + expected: FAIL + + [test_find_elements_link_text[<a href=# style='text-transform: uppercase'>link text</a>-LINK TEXT\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link text</a>-link\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#> partial link text </a>-link\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link text</a>-k t\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link<br>text</a>-k\\nt\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link&text</a>-k&t\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>PARTIAL LINK TEXT</a>-LINK\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=# style='text-transform: uppercase'>partial link text</a>-LINK\]] + expected: FAIL + + [test_xhtml_namespace[css selector-#linkText\]] + expected: FAIL + + [test_xhtml_namespace[link text-full link text\]] + expected: FAIL + + [test_xhtml_namespace[partial link text-link text\]] + expected: FAIL + + [test_xhtml_namespace[tag name-a\]] + expected: FAIL + + [test_xhtml_namespace[xpath-//*[name()='a'\]\]] + expected: FAIL + + [test_htmldocument[xpath-/html\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_elements/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_elements/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_elements/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_elements_from_element/find.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_element/find.py.ini new file mode 100644 index 00000000000..69ec1b4bbcc --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_element/find.py.ini @@ -0,0 +1,82 @@ +[find.py] + expected: TIMEOUT + [test_no_browsing_context] + expected: ERROR + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_with_startnode_from_other_window_handle] + expected: FAIL + + [test_no_such_element_with_startnode_from_other_frame] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_find_elements[xpath-//a\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link text</a>-link text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#> link text </a>-link text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link<br>text</a>-link\\ntext\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link&text</a>-link&text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>LINK TEXT</a>-LINK TEXT\]] + expected: FAIL + + [test_find_elements_link_text[<a href=# style='text-transform: uppercase'>link text</a>-LINK TEXT\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link text</a>-link\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#> partial link text </a>-link\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link text</a>-k t\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link<br>text</a>-k\\nt\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link&text</a>-k&t\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>PARTIAL LINK TEXT</a>-LINK\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=# style='text-transform: uppercase'>partial link text</a>-LINK\]] + expected: FAIL + + [test_xhtml_namespace[css selector-#linkText\]] + expected: FAIL + + [test_xhtml_namespace[link text-full link text\]] + expected: FAIL + + [test_xhtml_namespace[partial link text-link text\]] + expected: FAIL + + [test_xhtml_namespace[tag name-a\]] + expected: FAIL + + [test_xhtml_namespace[xpath-//*[name()='a'\]\]] + expected: FAIL + + [test_parent_htmldocument] + expected: FAIL + + [test_parent_of_document_node_errors] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_elements_from_element/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_element/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_element/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_elements_from_shadow_root/find.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_shadow_root/find.py.ini new file mode 100644 index 00000000000..5328af1b701 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_shadow_root/find.py.ini @@ -0,0 +1,157 @@ +[find.py] + expected: TIMEOUT + [test_null_parameter_value] + expected: FAIL + + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR + + [test_no_such_shadow_root_with_element] + expected: FAIL + + [test_no_such_shadow_root_with_unknown_shadow_root] + expected: FAIL + + [test_no_such_shadow_root_with_shadow_root_from_other_window_handle] + expected: FAIL + + [test_no_such_shadow_root_with_shadow_root_from_other_frame] + expected: FAIL + + [test_detached_shadow_root[top_context\]] + expected: FAIL + + [test_detached_shadow_root[child_context\]] + expected: FAIL + + [test_no_elements_with_unknown_selector[not-existent\]] + expected: FAIL + + [test_no_elements_with_unknown_selector[existent-other-frame\]] + expected: FAIL + + [test_no_elements_with_unknown_selector[existent-outside-shadow-root\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[True\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[None\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[1\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[shadow_root_id3\]] + expected: FAIL + + [test_invalid_shadow_root_id_argument[shadow_root_id4\]] + expected: FAIL + + [test_invalid_using_argument[a\]] + expected: FAIL + + [test_invalid_using_argument[True\]] + expected: FAIL + + [test_invalid_using_argument[None\]] + expected: FAIL + + [test_invalid_using_argument[1\]] + expected: FAIL + + [test_invalid_using_argument[using4\]] + expected: FAIL + + [test_invalid_using_argument[using5\]] + expected: FAIL + + [test_invalid_selector_argument[None\]] + expected: FAIL + + [test_invalid_selector_argument[value1\]] + expected: FAIL + + [test_invalid_selector_argument[value2\]] + expected: FAIL + + [test_find_elements_equivalence] + expected: FAIL + + [test_find_elements[open-css selector-#linkText\]] + expected: FAIL + + [test_find_elements[open-link text-full link text\]] + expected: FAIL + + [test_find_elements[open-partial link text-link text\]] + expected: FAIL + + [test_find_elements[open-tag name-a\]] + expected: FAIL + + [test_find_elements[open-xpath-//a\]] + expected: FAIL + + [test_find_elements[closed-css selector-#linkText\]] + expected: FAIL + + [test_find_elements[closed-link text-full link text\]] + expected: FAIL + + [test_find_elements[closed-partial link text-link text\]] + expected: FAIL + + [test_find_elements[closed-tag name-a\]] + expected: FAIL + + [test_find_elements[closed-xpath-//a\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link text</a>-link text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#> link text </a>-link text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link<br>text</a>-link\\ntext\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>link&text</a>-link&text\]] + expected: FAIL + + [test_find_elements_link_text[<a href=#>LINK TEXT</a>-LINK TEXT\]] + expected: FAIL + + [test_find_elements_link_text[<a href=# style='text-transform: uppercase'>link text</a>-LINK TEXT\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link text</a>-link\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#> partial link text </a>-link\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link text</a>-k t\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link<br>text</a>-k\\nt\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>partial link&text</a>-k&t\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=#>PARTIAL LINK TEXT</a>-LINK\]] + expected: FAIL + + [test_find_elements_partial_link_text[<a href=# style='text-transform: uppercase'>partial link text</a>-LINK\]] + expected: FAIL + + [test_find_elements_in_nested_shadow_root[open\]] + expected: FAIL + + [test_find_elements_in_nested_shadow_root[closed\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/find_elements_from_shadow_root/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_shadow_root/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/find_elements_from_shadow_root/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/forward/forward.py.ini b/tests/wpt/meta/webdriver/tests/classic/forward/forward.py.ini new file mode 100644 index 00000000000..12538247f27 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/forward/forward.py.ini @@ -0,0 +1,34 @@ +[forward.py] + disabled: consistent panic + [test_no_top_browsing_context] + expected: ERROR + + [test_no_browsing_context] + expected: ERROR + + [test_basic] + expected: ERROR + + [test_no_browsing_history] + expected: ERROR + + [test_seen_nodes[http\]] + expected: ERROR + + [test_seen_nodes[https\]] + expected: ERROR + + [test_seen_nodes[https coop\]] + expected: ERROR + + [test_history_pushstate] + expected: ERROR + + [test_data_urls] + expected: ERROR + + [test_fragments] + expected: ERROR + + [test_removed_iframe] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/forward/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/forward/user_prompts.py.ini new file mode 100644 index 00000000000..326fdd875ad --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/forward/user_prompts.py.ini @@ -0,0 +1,3 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + expected: TIMEOUT diff --git a/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/from_minimized_window.py.ini b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/from_minimized_window.py.ini new file mode 100644 index 00000000000..99b10143b3e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/from_minimized_window.py.ini @@ -0,0 +1,3 @@ +[from_minimized_window.py] + [test_fullscreen_from_minimized_window] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/fullscreen.py.ini b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/fullscreen.py.ini new file mode 100644 index 00000000000..d03f4481fba --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/fullscreen.py.ini @@ -0,0 +1,18 @@ +[fullscreen.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_response_payload] + expected: FAIL + + [test_fullscreen_from_normal_window] + expected: FAIL + + [test_fullscreen_from_maximized_window] + expected: FAIL + + [test_fullscreen_twice_is_idempotent] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/stress.py.ini b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/stress.py.ini new file mode 100644 index 00000000000..a6c136ac885 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/stress.py.ini @@ -0,0 +1,15 @@ +[stress.py] + [test_stress[0\]] + expected: FAIL + + [test_stress[1\]] + expected: FAIL + + [test_stress[2\]] + expected: FAIL + + [test_stress[3\]] + expected: FAIL + + [test_stress[4\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/fullscreen_window/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_active_element/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_active_element/get.py.ini new file mode 100644 index 00000000000..2d7e863ee5b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_active_element/get.py.ini @@ -0,0 +1,6 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_active_element/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_active_element/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_active_element/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_alert_text/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_alert_text/get.py.ini new file mode 100644 index 00000000000..fa50e27c0d1 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_alert_text/get.py.ini @@ -0,0 +1,22 @@ +[get.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR + + [test_no_user_prompt] + expected: FAIL + + [test_get_alert_text] + expected: FAIL + + [test_get_confirm_text] + expected: FAIL + + [test_get_prompt_text] + expected: FAIL + + [test_unexpected_alert] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_computed_label/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_computed_label/get.py.ini new file mode 100644 index 00000000000..6f7cda2f119 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_computed_label/get.py.ini @@ -0,0 +1,42 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_invalid_value] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[open\]] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_get_computed_label[<button>ok</button>-button-ok\]] + expected: FAIL + + [test_get_computed_label[<button aria-labelledby="one two"></button><div id=one>ok</div><div id=two>go</div>-button-ok go\]] + expected: FAIL + + [test_get_computed_label[<button aria-label=foo>bar</button>-button-foo\]] + expected: FAIL + + [test_get_computed_label[<label><input> foo</label>-input-foo\]] + expected: FAIL + + [test_get_computed_label[<label for=b>foo<label><input id=b>-input-foo\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_computed_label/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_computed_label/user_prompts.py.ini new file mode 100644 index 00000000000..913351aaa55 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_computed_label/user_prompts.py.ini @@ -0,0 +1,2 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734
\ No newline at end of file diff --git a/tests/wpt/meta/webdriver/tests/classic/get_computed_role/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_computed_role/get.py.ini new file mode 100644 index 00000000000..abd4a7750b7 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_computed_role/get.py.ini @@ -0,0 +1,24 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_computed_roles[<article>foo</article>-article-article\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_computed_role/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_computed_role/user_prompts.py.ini new file mode 100644 index 00000000000..b168410dab1 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_computed_role/user_prompts.py.ini @@ -0,0 +1,2 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 diff --git a/tests/wpt/meta/webdriver/tests/classic/get_current_url/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_current_url/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_current_url/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_attribute/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_attribute/get.py.ini new file mode 100644 index 00000000000..69b4a4c7d0b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_attribute/get.py.ini @@ -0,0 +1,94 @@ +[get.py] + expected: TIMEOUT + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[open\]] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_normal] + expected: FAIL + + [test_boolean_attribute[audio-attrs0\]] + expected: FAIL + + [test_boolean_attribute[button-attrs1\]] + expected: FAIL + + [test_boolean_attribute[details-attrs2\]] + expected: FAIL + + [test_boolean_attribute[dialog-attrs3\]] + expected: FAIL + + [test_boolean_attribute[fieldset-attrs4\]] + expected: FAIL + + [test_boolean_attribute[form-attrs5\]] + expected: FAIL + + [test_boolean_attribute[iframe-attrs6\]] + expected: FAIL + + [test_boolean_attribute[img-attrs7\]] + expected: FAIL + + [test_boolean_attribute[input-attrs8\]] + expected: FAIL + + [test_boolean_attribute[menuitem-attrs9\]] + expected: FAIL + + [test_boolean_attribute[ol-attrs10\]] + expected: FAIL + + [test_boolean_attribute[optgroup-attrs11\]] + expected: FAIL + + [test_boolean_attribute[option-attrs12\]] + expected: FAIL + + [test_boolean_attribute[script-attrs13\]] + expected: FAIL + + [test_boolean_attribute[select-attrs14\]] + expected: FAIL + + [test_boolean_attribute[textarea-attrs15\]] + expected: FAIL + + [test_boolean_attribute[track-attrs16\]] + expected: FAIL + + [test_boolean_attribute[video-attrs17\]] + expected: FAIL + + [test_global_boolean_attributes] + expected: FAIL + + [test_anchor_href[relative\]] + expected: FAIL + + [test_anchor_href[absolute\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_attribute/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_attribute/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_attribute/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_css_value/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_css_value/get.py.ini new file mode 100644 index 00000000000..bcd25112776 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_css_value/get.py.ini @@ -0,0 +1,21 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_css_value/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_css_value/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_css_value/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_property/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_property/get.py.ini new file mode 100644 index 00000000000..646e2846e18 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_property/get.py.ini @@ -0,0 +1,94 @@ +[get.py] + expected: TIMEOUT + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[open\]] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_property_non_existent] + expected: FAIL + + [test_content_attribute] + expected: FAIL + + [test_idl_attribute] + expected: FAIL + + [test_primitives["foobar"-foobar\]] + expected: FAIL + + [test_primitives[42-42\]] + expected: FAIL + + [test_primitives[js_primitive2-py_primitive2\]] + expected: FAIL + + [test_primitives[js_primitive3-py_primitive3\]] + expected: FAIL + + [test_primitives[null-None\]] + expected: FAIL + + [test_primitives[undefined-None\]] + expected: FAIL + + [test_collection_dom_token_list] + expected: FAIL + + [test_primitives_set_by_execute_script["foobar"-foobar\]] + expected: FAIL + + [test_primitives_set_by_execute_script[42-42\]] + expected: FAIL + + [test_primitives_set_by_execute_script[js_primitive2-py_primitive2\]] + expected: FAIL + + [test_primitives_set_by_execute_script[js_primitive3-py_primitive3\]] + expected: FAIL + + [test_primitives_set_by_execute_script[null-None\]] + expected: FAIL + + [test_primitives_set_by_execute_script[undefined-None\]] + expected: FAIL + + [test_web_reference[frame-WebFrame\]] + expected: FAIL + + [test_web_reference[shadowRoot-ShadowRoot\]] + expected: FAIL + + [test_web_reference[window-WebWindow\]] + expected: FAIL + + [test_mutated_element] + expected: FAIL + + [test_anchor_href[relative\]] + expected: FAIL + + [test_anchor_href[absolute\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_property/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_property/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_property/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_rect/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_rect/get.py.ini new file mode 100644 index 00000000000..065e9fbc4ce --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_rect/get.py.ini @@ -0,0 +1,24 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_basic] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_rect/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_rect/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_rect/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_shadow_root/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_shadow_root/get.py.ini new file mode 100644 index 00000000000..1b3957f08c8 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_shadow_root/get.py.ini @@ -0,0 +1,33 @@ +[get.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_invalid_value] + expected: FAIL + + [test_no_such_element_from_other_window_handle[open\]] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_get_shadow_root] + expected: FAIL + + [test_no_shadow_root] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_shadow_root/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_shadow_root/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_shadow_root/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_tag_name/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_tag_name/get.py.ini new file mode 100644 index 00000000000..b810c389100 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_tag_name/get.py.ini @@ -0,0 +1,24 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_get_element_tag_name] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_tag_name/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_tag_name/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_tag_name/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_text/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_text/get.py.ini new file mode 100644 index 00000000000..5f04f967054 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_text/get.py.ini @@ -0,0 +1,42 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_transform_capitalize[space\]] + expected: FAIL + + [test_transform_capitalize[dash\]] + expected: FAIL + + [test_transform_capitalize[underscore\]] + expected: FAIL + + [test_shadow_root_slot[custom outside\]] + expected: FAIL + + [test_shadow_root_slot[default visible\]] + expected: FAIL + + [test_shadow_root_slot[default outside\]] + expected: FAIL + + [test_shadow_root_slot[default hidden\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_element_text/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_element_text/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_element_text/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_named_cookie/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_named_cookie/get.py.ini new file mode 100644 index 00000000000..93b889d3a59 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_named_cookie/get.py.ini @@ -0,0 +1,12 @@ +[get.py] + [test_no_browsing_context] + expected: FAIL + + [test_get_named_session_cookie] + expected: FAIL + + [test_get_named_cookie] + expected: FAIL + + [test_duplicated_cookie] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_named_cookie/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_named_cookie/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_named_cookie/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_page_source/source.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_page_source/source.py.ini new file mode 100644 index 00000000000..f1326acbc2f --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_page_source/source.py.ini @@ -0,0 +1,3 @@ +[source.py] + [test_no_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_page_source/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_page_source/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_page_source/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_title/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_title/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_title/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_window_handle/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_window_handle/get.py.ini new file mode 100644 index 00000000000..0fb70be2b4d --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_window_handle/get.py.ini @@ -0,0 +1,3 @@ +[get.py] + [test_no_top_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_window_handle/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_window_handle/user_prompts.py.ini new file mode 100644 index 00000000000..0bc849b2704 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_window_handle/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert\]] + expected: FAIL + + [test_accept[capabilities0-confirm\]] + expected: FAIL + + [test_accept[capabilities0-prompt\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss[capabilities0-alert\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert\]] + expected: FAIL + + [test_default[confirm\]] + expected: FAIL + + [test_default[prompt\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_window_handles/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_window_handles/user_prompts.py.ini new file mode 100644 index 00000000000..0bc849b2704 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_window_handles/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert\]] + expected: FAIL + + [test_accept[capabilities0-confirm\]] + expected: FAIL + + [test_accept[capabilities0-prompt\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss[capabilities0-alert\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert\]] + expected: FAIL + + [test_default[confirm\]] + expected: FAIL + + [test_default[prompt\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_window_rect/get.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_window_rect/get.py.ini new file mode 100644 index 00000000000..3394ac22306 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_window_rect/get.py.ini @@ -0,0 +1,6 @@ +[get.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_payload] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/get_window_rect/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/get_window_rect/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/get_window_rect/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/idlharness.window.js.ini b/tests/wpt/meta/webdriver/tests/classic/idlharness.window.js.ini new file mode 100644 index 00000000000..ee8e266e35f --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/idlharness.window.js.ini @@ -0,0 +1,6 @@ +[idlharness.window.html] + [Navigator interface: attribute webdriver] + expected: FAIL + + [Navigator interface: navigator must inherit property "webdriver" with the proper type] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/interface/interface.py.ini b/tests/wpt/meta/webdriver/tests/classic/interface/interface.py.ini new file mode 100644 index 00000000000..9efc2c79243 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/interface/interface.py.ini @@ -0,0 +1,3 @@ +[interface.py] + [test_navigator_webdriver_active] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/is_element_enabled/enabled.py.ini b/tests/wpt/meta/webdriver/tests/classic/is_element_enabled/enabled.py.ini new file mode 100644 index 00000000000..1f97f812861 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/is_element_enabled/enabled.py.ini @@ -0,0 +1,2 @@ +[enabled.py] + expected: TIMEOUT diff --git a/tests/wpt/meta/webdriver/tests/classic/is_element_enabled/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/is_element_enabled/user_prompts.py.ini new file mode 100644 index 00000000000..913351aaa55 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/is_element_enabled/user_prompts.py.ini @@ -0,0 +1,2 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734
\ No newline at end of file diff --git a/tests/wpt/meta/webdriver/tests/classic/is_element_selected/selected.py.ini b/tests/wpt/meta/webdriver/tests/classic/is_element_selected/selected.py.ini new file mode 100644 index 00000000000..f75724979c5 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/is_element_selected/selected.py.ini @@ -0,0 +1,21 @@ +[selected.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/is_element_selected/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/is_element_selected/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/is_element_selected/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/maximize_window/from_minimized_window.py.ini b/tests/wpt/meta/webdriver/tests/classic/maximize_window/from_minimized_window.py.ini new file mode 100644 index 00000000000..5d3e1ccc1b2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/maximize_window/from_minimized_window.py.ini @@ -0,0 +1,3 @@ +[from_minimized_window.py] + [test_restore_from_minimized] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/maximize_window/maximize.py.ini b/tests/wpt/meta/webdriver/tests/classic/maximize_window/maximize.py.ini new file mode 100644 index 00000000000..83d5c2fcf84 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/maximize_window/maximize.py.ini @@ -0,0 +1,21 @@ +[maximize.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_response_payload] + expected: FAIL + + [test_fully_exit_fullscreen] + expected: FAIL + + [test_maximize_from_normal_window] + expected: FAIL + + [test_maximize_with_window_already_at_maximum_size] + expected: FAIL + + [test_maximize_twice_is_idempotent] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/maximize_window/stress.py.ini b/tests/wpt/meta/webdriver/tests/classic/maximize_window/stress.py.ini new file mode 100644 index 00000000000..a6c136ac885 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/maximize_window/stress.py.ini @@ -0,0 +1,15 @@ +[stress.py] + [test_stress[0\]] + expected: FAIL + + [test_stress[1\]] + expected: FAIL + + [test_stress[2\]] + expected: FAIL + + [test_stress[3\]] + expected: FAIL + + [test_stress[4\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/maximize_window/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/maximize_window/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/maximize_window/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/minimize_window/minimize.py.ini b/tests/wpt/meta/webdriver/tests/classic/minimize_window/minimize.py.ini new file mode 100644 index 00000000000..75af78405d0 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/minimize_window/minimize.py.ini @@ -0,0 +1,21 @@ +[minimize.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_response_payload] + expected: FAIL + + [test_restore_from_fullscreen] + expected: FAIL + + [test_restore_from_maximized] + expected: FAIL + + [test_minimize_from_normal_window] + expected: FAIL + + [test_minimize_twice_is_idempotent] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/minimize_window/stress.py.ini b/tests/wpt/meta/webdriver/tests/classic/minimize_window/stress.py.ini new file mode 100644 index 00000000000..a6c136ac885 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/minimize_window/stress.py.ini @@ -0,0 +1,15 @@ +[stress.py] + [test_stress[0\]] + expected: FAIL + + [test_stress[1\]] + expected: FAIL + + [test_stress[2\]] + expected: FAIL + + [test_stress[3\]] + expected: FAIL + + [test_stress[4\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/minimize_window/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/minimize_window/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/minimize_window/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/navigate_to/navigate.py.ini b/tests/wpt/meta/webdriver/tests/classic/navigate_to/navigate.py.ini new file mode 100644 index 00000000000..2464f4b2b4d --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/navigate_to/navigate.py.ini @@ -0,0 +1,12 @@ +[navigate.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_seen_nodes[http\]] + expected: FAIL + + [test_seen_nodes[https\]] + expected: FAIL + + [test_seen_nodes[https coop\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/navigate_to/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/navigate_to/user_prompts.py.ini new file mode 100644 index 00000000000..fcf10a0526c --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/navigate_to/user_prompts.py.ini @@ -0,0 +1,73 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert\]] + expected: FAIL + + [test_accept[capabilities0-beforeunload\]] + expected: FAIL + + [test_accept[capabilities0-confirm\]] + expected: FAIL + + [test_accept[capabilities0-prompt\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert\]] + expected: FAIL + + [test_dismiss[capabilities0-beforeunload\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-beforeunload\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[beforeunload-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/new_session/create_alwaysMatch.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_session/create_alwaysMatch.py.ini new file mode 100644 index 00000000000..c837e638bb0 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_session/create_alwaysMatch.py.ini @@ -0,0 +1,21 @@ +[create_alwaysMatch.py] + [test_valid[timeouts-value12\]] + expected: FAIL + + [test_valid[strictFileInteractability-True\]] + expected: FAIL + + [test_valid[test:extension-False\]] + expected: FAIL + + [test_valid[test:extension-abc\]] + expected: FAIL + + [test_valid[test:extension-123\]] + expected: FAIL + + [test_valid[test:extension-value22\]] + expected: FAIL + + [test_valid[test:extension-value23\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/new_session/create_firstMatch.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_session/create_firstMatch.py.ini new file mode 100644 index 00000000000..3752bebca7b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_session/create_firstMatch.py.ini @@ -0,0 +1,21 @@ +[create_firstMatch.py] + [test_valid[timeouts-value12\]] + expected: FAIL + + [test_valid[strictFileInteractability-True\]] + expected: FAIL + + [test_valid[test:extension-False\]] + expected: FAIL + + [test_valid[test:extension-abc\]] + expected: FAIL + + [test_valid[test:extension-123\]] + expected: FAIL + + [test_valid[test:extension-value22\]] + expected: FAIL + + [test_valid[test:extension-value23\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/new_session/response.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_session/response.py.ini new file mode 100644 index 00000000000..b5c5cede365 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_session/response.py.ini @@ -0,0 +1,3 @@ +[response.py] + [test_capability_user_agent] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/new_session/unhandled_prompt_behavior.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_session/unhandled_prompt_behavior.py.ini new file mode 100644 index 00000000000..ff2e1c72126 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_session/unhandled_prompt_behavior.py.ini @@ -0,0 +1,24 @@ +[unhandled_prompt_behavior.py] + [test_unhandled_prompt_behavior_as_object_default[handler0-expected_capability0-True-True\]] + expected: FAIL + + [test_unhandled_prompt_behavior_as_object_default[handler1-expected_capability1-True-False\]] + expected: FAIL + + [test_unhandled_prompt_behavior_as_object_default[handler2-expected_capability2-False-True\]] + expected: FAIL + + [test_beforeunload_prompts_always_automatically_accepted[accept\]] + expected: FAIL + + [test_beforeunload_prompts_always_automatically_accepted[accept and notify\]] + expected: FAIL + + [test_beforeunload_prompts_always_automatically_accepted[dismiss\]] + expected: FAIL + + [test_beforeunload_prompts_always_automatically_accepted[dismiss and notify\]] + expected: FAIL + + [test_beforeunload_prompts_always_automatically_accepted[ignore\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/new_session/websocket_url.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_session/websocket_url.py.ini new file mode 100644 index 00000000000..76e42fd0ed0 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_session/websocket_url.py.ini @@ -0,0 +1,3 @@ +[websocket_url.py] + [test_bidi_upgrade] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/new_window/new.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_window/new.py.ini new file mode 100644 index 00000000000..7288018eebf --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_window/new.py.ini @@ -0,0 +1,6 @@ +[new.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/new_window/new_tab.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_window/new_tab.py.ini new file mode 100644 index 00000000000..77be6174789 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_window/new_tab.py.ini @@ -0,0 +1,15 @@ +[new_tab.py] + [test_keeps_current_window_handle] + expected: ERROR + + [test_opens_about_blank_in_new_tab] + expected: ERROR + + [test_initial_selection_for_contenteditable] + expected: ERROR + + [test_sets_no_window_name] + expected: ERROR + + [test_sets_no_opener] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/new_window/new_window.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_window/new_window.py.ini new file mode 100644 index 00000000000..5ea6fe581f7 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_window/new_window.py.ini @@ -0,0 +1,12 @@ +[new_window.py] + [test_payload] + expected: FAIL + + [test_keeps_current_window_handle] + expected: FAIL + + [test_opens_about_blank_in_new_window] + expected: FAIL + + [test_initial_selection_for_contenteditable] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/new_window/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/new_window/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/new_window/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/invalid.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/invalid.py.ini new file mode 100644 index 00000000000..39649c5204a --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/invalid.py.ini @@ -0,0 +1,91 @@ +[invalid.py] + expected: TIMEOUT + [test_input_source_action_sequence_actions_pause_duration_invalid_value[9007199254740992-none\]] + expected: FAIL + + [test_input_source_action_sequence_actions_pause_duration_invalid_value[9007199254740992-key\]] + expected: FAIL + + [test_input_source_action_sequence_actions_pause_duration_invalid_value[9007199254740992-pointer\]] + expected: FAIL + + [test_input_source_action_sequence_actions_pause_duration_invalid_value[9007199254740992-wheel\]] + expected: FAIL + + [test_pointer_action_up_down_button_invalid_value[9007199254740992-pointerDown\]] + expected: FAIL + + [test_pointer_action_up_down_button_invalid_value[9007199254740992-pointerUp\]] + expected: FAIL + + [test_pointer_action_common_properties_dimensions_invalid_value[9007199254740992-width-pointerDown\]] + expected: FAIL + + [test_pointer_action_common_properties_dimensions_invalid_value[9007199254740992-width-pointerMove\]] + expected: FAIL + + [test_pointer_action_common_properties_dimensions_invalid_value[9007199254740992-width-pointerUp\]] + expected: FAIL + + [test_pointer_action_common_properties_dimensions_invalid_value[9007199254740992-height-pointerDown\]] + expected: FAIL + + [test_pointer_action_common_properties_dimensions_invalid_value[9007199254740992-height-pointerMove\]] + expected: FAIL + + [test_pointer_action_common_properties_dimensions_invalid_value[9007199254740992-height-pointerUp\]] + expected: FAIL + + [test_wheel_action_scroll_coordinate_invalid_type[None-x\]] + expected: FAIL + + [test_wheel_action_scroll_coordinate_invalid_type[None-y\]] + expected: FAIL + + [test_wheel_action_scroll_coordinate_invalid_value[-9007199254740992-x\]] + expected: FAIL + + [test_wheel_action_scroll_coordinate_invalid_value[-9007199254740992-y\]] + expected: FAIL + + [test_wheel_action_scroll_coordinate_invalid_value[9007199254740992-x\]] + expected: FAIL + + [test_wheel_action_scroll_coordinate_invalid_value[9007199254740992-y\]] + expected: FAIL + + [test_wheel_action_scroll_delta_invalid_type[None-x\]] + expected: FAIL + + [test_wheel_action_scroll_delta_invalid_type[None-y\]] + expected: FAIL + + [test_wheel_action_scroll_delta_invalid_value[-9007199254740992-x\]] + expected: FAIL + + [test_wheel_action_scroll_delta_invalid_value[-9007199254740992-y\]] + expected: FAIL + + [test_wheel_action_scroll_delta_invalid_value[9007199254740992-x\]] + expected: FAIL + + [test_wheel_action_scroll_delta_invalid_value[9007199254740992-y\]] + expected: FAIL + + [test_wheel_action_scroll_origin_pointer_not_supported] + expected: FAIL + + [test_wheel_action_scroll_origin_element_invalid_value] + expected: FAIL + + [test_wheel_action_scroll_missing_property[x\]] + expected: FAIL + + [test_wheel_action_scroll_missing_property[y\]] + expected: FAIL + + [test_wheel_action_scroll_missing_property[deltaX\]] + expected: FAIL + + [test_wheel_action_scroll_missing_property[deltaY\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/key.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key.py.ini new file mode 100644 index 00000000000..0a9efbca289 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key.py.ini @@ -0,0 +1,24 @@ +[key.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_key_down_closes_browsing_context] + expected: FAIL + + [test_backspace_erases_keys] + expected: FAIL + + [test_element_in_shadow_tree[outer-open\]] + expected: FAIL + + [test_element_in_shadow_tree[outer-closed\]] + expected: FAIL + + [test_element_in_shadow_tree[inner-open\]] + expected: FAIL + + [test_element_in_shadow_tree[inner-closed\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_events.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_events.py.ini new file mode 100644 index 00000000000..6dabfbb793f --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_events.py.ini @@ -0,0 +1,273 @@ +[key_events.py] + [test_modifier_key_sends_correct_events[\\ue00a-ALT\]] + expected: FAIL + + [test_modifier_key_sends_correct_events[\\ue009-CONTROL\]] + expected: FAIL + + [test_modifier_key_sends_correct_events[\\ue03d-META\]] + expected: FAIL + + [test_modifier_key_sends_correct_events[\\ue008-SHIFT\]] + expected: FAIL + + [test_modifier_key_sends_correct_events[\\ue052-R_ALT\]] + expected: FAIL + + [test_modifier_key_sends_correct_events[\\ue051-R_CONTROL\]] + expected: FAIL + + [test_modifier_key_sends_correct_events[\\ue053-R_META\]] + expected: FAIL + + [test_modifier_key_sends_correct_events[\\ue050-R_SHIFT\]] + expected: FAIL + + [test_non_printable_key_sends_events[\\ue00c-ESCAPE\]] + expected: FAIL + + [test_non_printable_key_sends_events[\\ue014-RIGHT\]] + expected: FAIL + + [test_printable_key_sends_correct_events[a-KeyA0\]] + expected: FAIL + + [test_printable_key_sends_correct_events[a-KeyA1\]] + expected: FAIL + + [test_printable_key_sends_correct_events["-Quote\]] + expected: FAIL + + [test_printable_key_sends_correct_events[,-Comma\]] + expected: FAIL + + [test_printable_key_sends_correct_events[\\xe0-\]] + expected: FAIL + + [test_printable_key_sends_correct_events[\\u0416-\]] + expected: FAIL + + [test_printable_key_sends_correct_events[@-Digit2\]] + expected: FAIL + + [test_printable_key_sends_correct_events[\\u2603-\]] + expected: FAIL + + [test_printable_key_sends_correct_events[\\uf6c2-\]] + expected: FAIL + + [test_sequence_of_keydown_printable_keys_sends_events] + expected: FAIL + + [test_sequence_of_keydown_printable_characters_sends_events] + expected: FAIL + + [test_special_key_sends_keydown[ADD-expected0\]] + expected: FAIL + + [test_special_key_sends_keydown[ALT-expected1\]] + expected: FAIL + + [test_special_key_sends_keydown[BACKSPACE-expected2\]] + expected: FAIL + + [test_special_key_sends_keydown[CANCEL-expected3\]] + expected: FAIL + + [test_special_key_sends_keydown[CLEAR-expected4\]] + expected: FAIL + + [test_special_key_sends_keydown[CONTROL-expected5\]] + expected: FAIL + + [test_special_key_sends_keydown[DECIMAL-expected6\]] + expected: FAIL + + [test_special_key_sends_keydown[DELETE-expected7\]] + expected: FAIL + + [test_special_key_sends_keydown[DIVIDE-expected8\]] + expected: FAIL + + [test_special_key_sends_keydown[DOWN-expected9\]] + expected: FAIL + + [test_special_key_sends_keydown[END-expected10\]] + expected: FAIL + + [test_special_key_sends_keydown[ENTER-expected11\]] + expected: FAIL + + [test_special_key_sends_keydown[EQUALS-expected12\]] + expected: FAIL + + [test_special_key_sends_keydown[ESCAPE-expected13\]] + expected: FAIL + + [test_special_key_sends_keydown[F1-expected14\]] + expected: FAIL + + [test_special_key_sends_keydown[F10-expected15\]] + expected: FAIL + + [test_special_key_sends_keydown[F11-expected16\]] + expected: FAIL + + [test_special_key_sends_keydown[F12-expected17\]] + expected: FAIL + + [test_special_key_sends_keydown[F2-expected18\]] + expected: FAIL + + [test_special_key_sends_keydown[F3-expected19\]] + expected: FAIL + + [test_special_key_sends_keydown[F4-expected20\]] + expected: FAIL + + [test_special_key_sends_keydown[F5-expected21\]] + expected: FAIL + + [test_special_key_sends_keydown[F6-expected22\]] + expected: FAIL + + [test_special_key_sends_keydown[F7-expected23\]] + expected: FAIL + + [test_special_key_sends_keydown[F8-expected24\]] + expected: FAIL + + [test_special_key_sends_keydown[F9-expected25\]] + expected: FAIL + + [test_special_key_sends_keydown[HELP-expected26\]] + expected: FAIL + + [test_special_key_sends_keydown[HOME-expected27\]] + expected: FAIL + + [test_special_key_sends_keydown[INSERT-expected28\]] + expected: FAIL + + [test_special_key_sends_keydown[LEFT-expected29\]] + expected: FAIL + + [test_special_key_sends_keydown[META-expected30\]] + expected: FAIL + + [test_special_key_sends_keydown[MULTIPLY-expected31\]] + expected: FAIL + + [test_special_key_sends_keydown[NULL-expected32\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD0-expected33\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD1-expected34\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD2-expected35\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD3-expected36\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD4-expected37\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD5-expected38\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD6-expected39\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD7-expected40\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD8-expected41\]] + expected: FAIL + + [test_special_key_sends_keydown[NUMPAD9-expected42\]] + expected: FAIL + + [test_special_key_sends_keydown[PAGE_DOWN-expected43\]] + expected: FAIL + + [test_special_key_sends_keydown[PAGE_UP-expected44\]] + expected: FAIL + + [test_special_key_sends_keydown[PAUSE-expected45\]] + expected: FAIL + + [test_special_key_sends_keydown[RETURN-expected46\]] + expected: FAIL + + [test_special_key_sends_keydown[RIGHT-expected47\]] + expected: FAIL + + [test_special_key_sends_keydown[R_ALT-expected48\]] + expected: FAIL + + [test_special_key_sends_keydown[R_ARROWDOWN-expected49\]] + expected: FAIL + + [test_special_key_sends_keydown[R_ARROWLEFT-expected50\]] + expected: FAIL + + [test_special_key_sends_keydown[R_ARROWRIGHT-expected51\]] + expected: FAIL + + [test_special_key_sends_keydown[R_ARROWUP-expected52\]] + expected: FAIL + + [test_special_key_sends_keydown[R_CONTROL-expected53\]] + expected: FAIL + + [test_special_key_sends_keydown[R_DELETE-expected54\]] + expected: FAIL + + [test_special_key_sends_keydown[R_END-expected55\]] + expected: FAIL + + [test_special_key_sends_keydown[R_HOME-expected56\]] + expected: FAIL + + [test_special_key_sends_keydown[R_INSERT-expected57\]] + expected: FAIL + + [test_special_key_sends_keydown[R_META-expected58\]] + expected: FAIL + + [test_special_key_sends_keydown[R_PAGEDOWN-expected59\]] + expected: FAIL + + [test_special_key_sends_keydown[R_PAGEUP-expected60\]] + expected: FAIL + + [test_special_key_sends_keydown[R_SHIFT-expected61\]] + expected: FAIL + + [test_special_key_sends_keydown[SEMICOLON-expected62\]] + expected: FAIL + + [test_special_key_sends_keydown[SEPARATOR-expected63\]] + expected: FAIL + + [test_special_key_sends_keydown[SHIFT-expected64\]] + expected: FAIL + + [test_special_key_sends_keydown[SPACE-expected65\]] + expected: FAIL + + [test_special_key_sends_keydown[SUBTRACT-expected66\]] + expected: FAIL + + [test_special_key_sends_keydown[TAB-expected67\]] + expected: FAIL + + [test_special_key_sends_keydown[UP-expected68\]] + expected: FAIL + + [test_special_key_sends_keydown[ZENKAKUHANKAKU-expected69\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_modifiers.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_modifiers.py.ini new file mode 100644 index 00000000000..70b4b687388 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_modifiers.py.ini @@ -0,0 +1,12 @@ +[key_modifiers.py] + [test_shift_modifier_and_non_printable_keys[\\ue008\]] + expected: FAIL + + [test_shift_modifier_and_non_printable_keys[\\ue050\]] + expected: FAIL + + [test_shift_modifier_generates_capital_letters[\\ue008\]] + expected: FAIL + + [test_shift_modifier_generates_capital_letters[\\ue050\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_shortcuts.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_shortcuts.py.ini new file mode 100644 index 00000000000..43e9ac6cf32 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_shortcuts.py.ini @@ -0,0 +1,3 @@ +[key_shortcuts.py] + [test_mod_a_mod_c_right_mod_v_pastes_text] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_special_keys.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_special_keys.py.ini new file mode 100644 index 00000000000..9f97050ec49 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_special_keys.py.ini @@ -0,0 +1,12 @@ +[key_special_keys.py] + [test_codepoint_keys_behave_correctly[\\U0001f604\]] + expected: FAIL + + [test_codepoint_keys_behave_correctly[\\U0001f60d\]] + expected: FAIL + + [test_codepoint_keys_behave_correctly[\\u0ba8\\u0bbf\]] + expected: FAIL + + [test_codepoint_keys_behave_correctly[\\u1100\\u1161\\u11a8\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_tentative.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_tentative.py.ini new file mode 100644 index 00000000000..a16bb76d7c7 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/key_tentative.py.ini @@ -0,0 +1,6 @@ +[key_tentative.py] + [test_grapheme_cluster[\\u0e01\\u0e33\]] + expected: FAIL + + [test_grapheme_cluster[\\U0001f937\\U0001f3fd\\u200d\\u2640\\ufe0f\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/navigation.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/navigation.py.ini new file mode 100644 index 00000000000..38af76d3cf4 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/navigation.py.ini @@ -0,0 +1,6 @@ +[navigation.py] + [test_key] + expected: FAIL + + [test_pointer] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/none.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/none.py.ini new file mode 100644 index 00000000000..1dad7888c51 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/none.py.ini @@ -0,0 +1,6 @@ +[none.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/perform.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/perform.py.ini new file mode 100644 index 00000000000..b4a8841b9ae --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/perform.py.ini @@ -0,0 +1,9 @@ +[perform.py] + [test_input_source_action_sequence_actions_pause_duration_valid[wheel\]] + expected: FAIL + + [test_input_source_action_sequence_actions_pause_duration_missing[wheel\]] + expected: FAIL + + [test_input_source_action_sequence_pointer_parameters_not_processed[wheel\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_contextmenu.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_contextmenu.py.ini new file mode 100644 index 00000000000..e0fb2381634 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_contextmenu.py.ini @@ -0,0 +1,9 @@ +[pointer_contextmenu.py] + [test_control_click[\\ue009-ctrlKey\]] + expected: ERROR + + [test_control_click[\\ue051-ctrlKey\]] + expected: ERROR + + [test_release_control_click] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_dblclick.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_dblclick.py.ini new file mode 100644 index 00000000000..523d8d29edb --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_dblclick.py.ini @@ -0,0 +1,9 @@ +[pointer_dblclick.py] + [test_dblclick_at_coordinates[0\]] + expected: FAIL + + [test_dblclick_at_coordinates[200\]] + expected: FAIL + + [test_no_dblclick_when_mouse_moves] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_modifier_click.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_modifier_click.py.ini new file mode 100644 index 00000000000..ebb9ef4dcc0 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_modifier_click.py.ini @@ -0,0 +1,21 @@ +[pointer_modifier_click.py] + [test_modifier_click[\\ue00a-altKey\]] + expected: ERROR + + [test_modifier_click[\\ue052-altKey\]] + expected: ERROR + + [test_modifier_click[\\ue03d-metaKey\]] + expected: ERROR + + [test_modifier_click[\\ue053-metaKey\]] + expected: ERROR + + [test_modifier_click[\\ue008-shiftKey\]] + expected: ERROR + + [test_modifier_click[\\ue050-shiftKey\]] + expected: ERROR + + [test_many_modifiers_click] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_mouse.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_mouse.py.ini new file mode 100644 index 00000000000..4a163fe2fac --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_mouse.py.ini @@ -0,0 +1,64 @@ +[pointer_mouse.py] + expected: TIMEOUT + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: ERROR + + [test_pointer_down_closes_browsing_context] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_click_at_coordinates] + expected: FAIL + + [test_context_menu_at_coordinates] + expected: FAIL + + [test_middle_click] + expected: FAIL + + [test_click_element_center] + expected: FAIL + + [test_click_element_in_shadow_tree[outer-open\]] + expected: FAIL + + [test_click_element_in_shadow_tree[outer-closed\]] + expected: FAIL + + [test_click_element_in_shadow_tree[inner-open\]] + expected: FAIL + + [test_click_element_in_shadow_tree[inner-closed\]] + expected: FAIL + + [test_click_navigation] + expected: FAIL + + [test_move_to_position_in_viewport[x\]] + expected: FAIL + + [test_move_to_position_in_viewport[y\]] + expected: FAIL + + [test_move_to_fractional_position] + expected: FAIL + + [test_move_to_origin_position_within_frame[viewport\]] + expected: FAIL + + [test_move_to_origin_position_within_frame[pointer\]] + expected: FAIL + + [test_move_to_origin_position_within_frame[element\]] + expected: FAIL + + [test_invalid_element_origin] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_mouse_drag.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_mouse_drag.py.ini new file mode 100644 index 00000000000..8657edd79e8 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_mouse_drag.py.ini @@ -0,0 +1,63 @@ +[pointer_mouse_drag.py] + [test_drag_and_drop[20-0-0\]] + expected: ERROR + + [test_drag_and_drop[20-0-300\]] + expected: ERROR + + [test_drag_and_drop[20-0-800\]] + expected: ERROR + + [test_drag_and_drop[0-15-0\]] + expected: ERROR + + [test_drag_and_drop[0-15-300\]] + expected: ERROR + + [test_drag_and_drop[0-15-800\]] + expected: ERROR + + [test_drag_and_drop[10-15-0\]] + expected: ERROR + + [test_drag_and_drop[10-15-300\]] + expected: ERROR + + [test_drag_and_drop[10-15-800\]] + expected: ERROR + + [test_drag_and_drop[-20-0-0\]] + expected: ERROR + + [test_drag_and_drop[-20-0-300\]] + expected: ERROR + + [test_drag_and_drop[-20-0-800\]] + expected: ERROR + + [test_drag_and_drop[10--15-0\]] + expected: ERROR + + [test_drag_and_drop[10--15-300\]] + expected: ERROR + + [test_drag_and_drop[10--15-800\]] + expected: ERROR + + [test_drag_and_drop[-10--15-0\]] + expected: ERROR + + [test_drag_and_drop[-10--15-300\]] + expected: ERROR + + [test_drag_and_drop[-10--15-800\]] + expected: ERROR + + [test_drag_and_drop_with_draggable_element[0\]] + expected: ERROR + + [test_drag_and_drop_with_draggable_element[300\]] + expected: ERROR + + [test_drag_and_drop_with_draggable_element[800\]] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_origin.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_origin.py.ini new file mode 100644 index 00000000000..112a4f9ddf4 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_origin.py.ini @@ -0,0 +1,27 @@ +[pointer_origin.py] + [test_viewport_inside] + expected: ERROR + + [test_pointer_inside] + expected: ERROR + + [test_element_center_point] + expected: ERROR + + [test_element_center_point_with_offset] + expected: ERROR + + [test_element_in_view_center_point_partly_visible] + expected: ERROR + + [test_element_larger_than_viewport] + expected: ERROR + + [test_element_outside_of_view_port] + expected: ERROR + + [test_viewport_outside] + expected: ERROR + + [test_pointer_outside] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_pause_dblclick.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_pause_dblclick.py.ini new file mode 100644 index 00000000000..106650cb70e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_pause_dblclick.py.ini @@ -0,0 +1,6 @@ +[pointer_pause_dblclick.py] + [test_dblclick_with_pause_after_second_pointerdown] + expected: FAIL + + [test_no_dblclick] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_pen.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_pen.py.ini new file mode 100644 index 00000000000..a3d52579f7d --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_pen.py.ini @@ -0,0 +1,33 @@ +[pointer_pen.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_pointer_down_closes_browsing_context] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_pen_pointer_in_shadow_tree[outer-open\]] + expected: FAIL + + [test_pen_pointer_in_shadow_tree[outer-closed\]] + expected: FAIL + + [test_pen_pointer_in_shadow_tree[inner-open\]] + expected: FAIL + + [test_pen_pointer_in_shadow_tree[inner-closed\]] + expected: FAIL + + [test_pen_pointer_properties] + expected: FAIL + + [test_params_actions_origin_outside_viewport[element\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_touch.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_touch.py.ini new file mode 100644 index 00000000000..65101d138aa --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_touch.py.ini @@ -0,0 +1,42 @@ +[pointer_touch.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_pointer_down_closes_browsing_context] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_touch_pointer_in_shadow_tree[outer-open\]] + expected: FAIL + + [test_touch_pointer_in_shadow_tree[outer-closed\]] + expected: FAIL + + [test_touch_pointer_in_shadow_tree[inner-open\]] + expected: FAIL + + [test_touch_pointer_in_shadow_tree[inner-closed\]] + expected: FAIL + + [test_touch_pointer_properties] + expected: FAIL + + [test_touch_pointer_properties_angle_twist] + expected: FAIL + + [test_touch_pointer_properties_tilt_twist] + expected: FAIL + + [test_move_to_fractional_position] + expected: FAIL + + [test_params_actions_origin_outside_viewport[element\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_tripleclick.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_tripleclick.py.ini new file mode 100644 index 00000000000..7e0523a6116 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/pointer_tripleclick.py.ini @@ -0,0 +1,3 @@ +[pointer_tripleclick.py] + [test_tripleclick_at_coordinates] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/sequence.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/sequence.py.ini new file mode 100644 index 00000000000..54ee376545d --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/sequence.py.ini @@ -0,0 +1,3 @@ +[sequence.py] + [test_perform_no_actions_send_no_events] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/user_prompts.py.ini new file mode 100644 index 00000000000..ca5401f5012 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/user_prompts.py.ini @@ -0,0 +1,58 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: ERROR + + [test_accept[capabilities0-confirm-True\]] + expected: ERROR + + [test_accept[capabilities0-prompt-\]] + expected: ERROR + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: ERROR + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: ERROR + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: ERROR + + [test_dismiss[capabilities0-alert-None\]] + expected: ERROR + + [test_dismiss[capabilities0-confirm-False\]] + expected: ERROR + + [test_dismiss[capabilities0-prompt-None\]] + expected: ERROR + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: ERROR + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: ERROR + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: ERROR + + [test_ignore[capabilities0-alert\]] + expected: ERROR + + [test_ignore[capabilities0-confirm\]] + expected: ERROR + + [test_ignore[capabilities0-prompt\]] + expected: ERROR + + [test_default[alert-None\]] + expected: ERROR + + [test_default[confirm-False\]] + expected: ERROR + + [test_default[prompt-None\]] + expected: ERROR + + [test_dismissed_beforeunload] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/perform_actions/wheel.py.ini b/tests/wpt/meta/webdriver/tests/classic/perform_actions/wheel.py.ini new file mode 100644 index 00000000000..3f6abc70f3e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/perform_actions/wheel.py.ini @@ -0,0 +1,39 @@ +[wheel.py] + [test_null_response_value] + expected: FAIL + + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_params_actions_origin_outside_viewport[element\]] + expected: FAIL + + [test_params_actions_origin_outside_viewport[viewport\]] + expected: FAIL + + [test_scroll_not_scrollable] + expected: FAIL + + [test_scroll_scrollable_overflow] + expected: FAIL + + [test_scroll_iframe] + expected: FAIL + + [test_scroll_shadow_tree[outer-open\]] + expected: FAIL + + [test_scroll_shadow_tree[outer-closed\]] + expected: FAIL + + [test_scroll_shadow_tree[inner-open\]] + expected: FAIL + + [test_scroll_shadow_tree[inner-closed\]] + expected: FAIL + + [test_scroll_with_key_pressed] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/permissions/set.py.ini b/tests/wpt/meta/webdriver/tests/classic/permissions/set.py.ini new file mode 100644 index 00000000000..a97d40f6155 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/permissions/set.py.ini @@ -0,0 +1,9 @@ +[set.py] + [test_set_to_state[granted\]] + expected: FAIL + + [test_set_to_state[denied\]] + expected: FAIL + + [test_set_to_state[prompt\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/print/background.py.ini b/tests/wpt/meta/webdriver/tests/classic/print/background.py.ini new file mode 100644 index 00000000000..0d71e219071 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/print/background.py.ini @@ -0,0 +1,9 @@ +[background.py] + [test_background[None-iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQIW2P4DwQACfsD/Z8fLAAAAAAASUVORK5CYII=\]] + expected: FAIL + + [test_background[True-iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAADUlEQVQIW2NgYGD4DwABBAEAwS2OUAAAAABJRU5ErkJggg==\]] + expected: FAIL + + [test_background[False-iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAYAAAAfFcSJAAAAC0lEQVQIW2P4DwQACfsD/Z8fLAAAAAAASUVORK5CYII=\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/print/orientation.py.ini b/tests/wpt/meta/webdriver/tests/classic/print/orientation.py.ini new file mode 100644 index 00000000000..387ff60af8b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/print/orientation.py.ini @@ -0,0 +1,9 @@ +[orientation.py] + [test_orientation[default\]] + expected: FAIL + + [test_orientation[portrait\]] + expected: FAIL + + [test_orientation[landscape\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/print/printcmd.py.ini b/tests/wpt/meta/webdriver/tests/classic/print/printcmd.py.ini new file mode 100644 index 00000000000..5d21a234610 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/print/printcmd.py.ini @@ -0,0 +1,57 @@ +[printcmd.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_html_document] + expected: FAIL + + [test_large_html_document] + expected: FAIL + + [test_page_ranges_document[ranges0-expected0\]] + expected: FAIL + + [test_page_ranges_document[ranges1-expected1\]] + expected: FAIL + + [test_page_ranges_document[ranges2-expected2\]] + expected: FAIL + + [test_page_ranges_document[ranges3-expected3\]] + expected: FAIL + + [test_page_ranges_document[ranges4-expected4\]] + expected: FAIL + + [test_page_ranges_document[ranges5-expected5\]] + expected: FAIL + + [test_page_ranges_document[ranges6-expected6\]] + expected: FAIL + + [test_page_ranges_document[ranges7-expected7\]] + expected: FAIL + + [test_page_ranges_document[ranges8-expected8\]] + expected: FAIL + + [test_page_ranges_document[ranges9-expected9\]] + expected: FAIL + + [test_page_ranges_document[ranges10-expected10\]] + expected: FAIL + + [test_page_ranges_invalid[options9\]] + expected: FAIL + + [test_page_ranges_invalid[options10\]] + expected: FAIL + + [test_page_ranges_invalid[options11\]] + expected: FAIL + + [test_page_ranges_invalid[options12\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/print/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/print/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/print/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/refresh/refresh.py.ini b/tests/wpt/meta/webdriver/tests/classic/refresh/refresh.py.ini new file mode 100644 index 00000000000..08528d08784 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/refresh/refresh.py.ini @@ -0,0 +1,21 @@ +[refresh.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_seen_nodes[http\]] + expected: FAIL + + [test_seen_nodes[https\]] + expected: FAIL + + [test_seen_nodes[https coop\]] + expected: FAIL + + [test_history_pushstate] + expected: FAIL + + [test_refresh_switches_to_parent_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/refresh/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/refresh/user_prompts.py.ini new file mode 100644 index 00000000000..fcf10a0526c --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/refresh/user_prompts.py.ini @@ -0,0 +1,73 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert\]] + expected: FAIL + + [test_accept[capabilities0-beforeunload\]] + expected: FAIL + + [test_accept[capabilities0-confirm\]] + expected: FAIL + + [test_accept[capabilities0-prompt\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert\]] + expected: FAIL + + [test_dismiss[capabilities0-beforeunload\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-beforeunload-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-beforeunload\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[beforeunload-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/release_actions/release.py.ini b/tests/wpt/meta/webdriver/tests/classic/release_actions/release.py.ini new file mode 100644 index 00000000000..7c5e73584b6 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/release_actions/release.py.ini @@ -0,0 +1,6 @@ +[release.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/release_actions/sequence.py.ini b/tests/wpt/meta/webdriver/tests/classic/release_actions/sequence.py.ini new file mode 100644 index 00000000000..6ba3814b563 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/release_actions/sequence.py.ini @@ -0,0 +1,3 @@ +[sequence.py] + [test_release_char_sequence_sends_keyup_events_in_reverse] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/release_actions/sequence_tentative.py.ini b/tests/wpt/meta/webdriver/tests/classic/release_actions/sequence_tentative.py.ini new file mode 100644 index 00000000000..aed5f673813 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/release_actions/sequence_tentative.py.ini @@ -0,0 +1,6 @@ +[sequence_tentative.py] + [test_release_mouse_sequence_resets_dblclick_state[with release actions\]] + expected: FAIL + + [test_release_mouse_sequence_resets_dblclick_state[without release actions\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/send_alert_text/send.py.ini b/tests/wpt/meta/webdriver/tests/classic/send_alert_text/send.py.ini new file mode 100644 index 00000000000..fc3fe5245a3 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/send_alert_text/send.py.ini @@ -0,0 +1,3 @@ +[send.py] + disabled: https://github.com/servo/servo/issues/35734 + expected: TIMEOUT diff --git a/tests/wpt/meta/webdriver/tests/classic/set_timeouts/set.py.ini b/tests/wpt/meta/webdriver/tests/classic/set_timeouts/set.py.ini new file mode 100644 index 00000000000..bfc9d7723d9 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/set_timeouts/set.py.ini @@ -0,0 +1,2 @@ +[set.py] + expected: TIMEOUT diff --git a/tests/wpt/meta/webdriver/tests/classic/set_timeouts/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/set_timeouts/user_prompts.py.ini new file mode 100644 index 00000000000..913351aaa55 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/set_timeouts/user_prompts.py.ini @@ -0,0 +1,2 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734
\ No newline at end of file diff --git a/tests/wpt/meta/webdriver/tests/classic/set_window_rect/from_minimized_window.py.ini b/tests/wpt/meta/webdriver/tests/classic/set_window_rect/from_minimized_window.py.ini new file mode 100644 index 00000000000..5d3e1ccc1b2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/set_window_rect/from_minimized_window.py.ini @@ -0,0 +1,3 @@ +[from_minimized_window.py] + [test_restore_from_minimized] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/set_window_rect/set.py.ini b/tests/wpt/meta/webdriver/tests/classic/set_window_rect/set.py.ini new file mode 100644 index 00000000000..6b28c2efdf8 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/set_window_rect/set.py.ini @@ -0,0 +1,39 @@ +[set.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL + + [test_restore_from_fullscreen] + expected: FAIL + + [test_restore_from_maximized] + expected: FAIL + + [test_x_y_floats] + expected: FAIL + + [test_set_to_available_size] + expected: ERROR + + [test_set_smaller_than_minimum_browser_size] + expected: FAIL + + [test_x_y] + expected: FAIL + + [test_x_as_current] + expected: FAIL + + [test_y_as_current] + expected: FAIL + + [test_negative_x_y] + expected: ERROR + + [test_set_to_screen_size] + expected: ERROR + + [test_set_larger_than_screen_size] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/classic/set_window_rect/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/set_window_rect/user_prompts.py.ini new file mode 100644 index 00000000000..913351aaa55 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/set_window_rect/user_prompts.py.ini @@ -0,0 +1,2 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734
\ No newline at end of file diff --git a/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch.py.ini b/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch.py.ini new file mode 100644 index 00000000000..ee73fbf4ce8 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch.py.ini @@ -0,0 +1,21 @@ +[switch.py] + [test_no_top_browsing_context[None\]] + expected: FAIL + + [test_no_top_browsing_context[0\]] + expected: FAIL + + [test_no_browsing_context[0\]] + expected: FAIL + + [test_no_browsing_context[id2\]] + expected: FAIL + + [test_no_browsing_context_when_already_top_level] + expected: FAIL + + [test_frame_id_shadow_root] + expected: FAIL + + [test_frame_id_null] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch_number.py.ini b/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch_number.py.ini new file mode 100644 index 00000000000..408f2eb2568 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch_number.py.ini @@ -0,0 +1,15 @@ +[switch_number.py] + [test_frame_id_number_index_out_of_bounds[1\]] + expected: FAIL + + [test_frame_id_number_index_out_of_bounds[65535\]] + expected: FAIL + + [test_frame_id_number_index[0-foo\]] + expected: FAIL + + [test_frame_id_number_index[1-bar\]] + expected: FAIL + + [test_frame_id_number_index_nested] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch_webelement.py.ini b/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch_webelement.py.ini new file mode 100644 index 00000000000..9932ab9a5d5 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/switch_to_frame/switch_webelement.py.ini @@ -0,0 +1,12 @@ +[switch_webelement.py] + [test_frame_id_webelement_stale_element_reference[top_context\]] + expected: FAIL + + [test_frame_id_webelement_stale_element_reference[child_context\]] + expected: FAIL + + [test_frame_id_webelement_frame[0-foo\]] + expected: FAIL + + [test_frame_id_webelement_frame[1-bar\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/switch_to_parent_frame/switch.py.ini b/tests/wpt/meta/webdriver/tests/classic/switch_to_parent_frame/switch.py.ini new file mode 100644 index 00000000000..ffd3d06f212 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/switch_to_parent_frame/switch.py.ini @@ -0,0 +1,6 @@ +[switch.py] + [test_switch_from_iframe] + expected: FAIL + + [test_switch_from_top_level] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/switch_to_window/alerts.py.ini b/tests/wpt/meta/webdriver/tests/classic/switch_to_window/alerts.py.ini new file mode 100644 index 00000000000..3e6ad0c8af9 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/switch_to_window/alerts.py.ini @@ -0,0 +1,3 @@ +[alerts.py] + [test_retain_tab_modal_status] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/switch_to_window/switch.py.ini b/tests/wpt/meta/webdriver/tests/classic/switch_to_window/switch.py.ini new file mode 100644 index 00000000000..9b0ec38199b --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/switch_to_window/switch.py.ini @@ -0,0 +1,12 @@ +[switch.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_finds_exising_user_prompt_after_tab_switch[alert\]] + expected: FAIL + + [test_finds_exising_user_prompt_after_tab_switch[confirm\]] + expected: FAIL + + [test_finds_exising_user_prompt_after_tab_switch[prompt\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/iframe.py.ini b/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/iframe.py.ini new file mode 100644 index 00000000000..dd77eca9d72 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/iframe.py.ini @@ -0,0 +1,9 @@ +[iframe.py] + [test_frame_element] + expected: FAIL + + [test_source_origin[same_origin\]] + expected: FAIL + + [test_source_origin[cross_origin\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/screenshot.py.ini b/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/screenshot.py.ini new file mode 100644 index 00000000000..319e4bf848f --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/screenshot.py.ini @@ -0,0 +1,30 @@ +[screenshot.py] + [test_no_browsing_context] + expected: FAIL + + [test_no_such_element_with_invalid_value] + expected: FAIL + + [test_no_such_element_with_shadow_root] + expected: FAIL + + [test_no_such_element_from_other_window_handle[open\]] + expected: FAIL + + [test_no_such_element_from_other_window_handle[closed\]] + expected: FAIL + + [test_no_such_element_from_other_frame[open\]] + expected: FAIL + + [test_no_such_element_from_other_frame[closed\]] + expected: FAIL + + [test_stale_element_reference[top_context\]] + expected: FAIL + + [test_stale_element_reference[child_context\]] + expected: FAIL + + [test_format_and_dimensions] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/take_element_screenshot/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/take_screenshot/iframe.py.ini b/tests/wpt/meta/webdriver/tests/classic/take_screenshot/iframe.py.ini new file mode 100644 index 00000000000..62f7ab5e4da --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/take_screenshot/iframe.py.ini @@ -0,0 +1,3 @@ +[iframe.py] + [test_always_captures_top_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/take_screenshot/screenshot.py.ini b/tests/wpt/meta/webdriver/tests/classic/take_screenshot/screenshot.py.ini new file mode 100644 index 00000000000..f2fac7a7fa1 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/take_screenshot/screenshot.py.ini @@ -0,0 +1,6 @@ +[screenshot.py] + [test_no_top_browsing_context] + expected: FAIL + + [test_no_browsing_context] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/classic/take_screenshot/user_prompts.py.ini b/tests/wpt/meta/webdriver/tests/classic/take_screenshot/user_prompts.py.ini new file mode 100644 index 00000000000..53b6399fdd2 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/classic/take_screenshot/user_prompts.py.ini @@ -0,0 +1,55 @@ +[user_prompts.py] + disabled: https://github.com/servo/servo/issues/35734 + [test_accept[capabilities0-alert-None\]] + expected: FAIL + + [test_accept[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept[capabilities0-prompt-\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-confirm-True\]] + expected: FAIL + + [test_accept_and_notify[capabilities0-prompt-\]] + expected: FAIL + + [test_dismiss[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss[capabilities0-prompt-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-alert-None\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-confirm-False\]] + expected: FAIL + + [test_dismiss_and_notify[capabilities0-prompt-None\]] + expected: FAIL + + [test_ignore[capabilities0-alert\]] + expected: FAIL + + [test_ignore[capabilities0-confirm\]] + expected: FAIL + + [test_ignore[capabilities0-prompt\]] + expected: FAIL + + [test_default[alert-None\]] + expected: FAIL + + [test_default[confirm-False\]] + expected: FAIL + + [test_default[prompt-None\]] + expected: FAIL diff --git a/tests/wpt/meta/webdriver/tests/interop/beforeunload_prompt.py.ini b/tests/wpt/meta/webdriver/tests/interop/beforeunload_prompt.py.ini new file mode 100644 index 00000000000..8d9822802f0 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/interop/beforeunload_prompt.py.ini @@ -0,0 +1,60 @@ +[beforeunload_prompt.py] + [test_accept[capabilities0-False\]] + expected: ERROR + + [test_accept[capabilities0-True\]] + expected: ERROR + + [test_accept_and_notify[capabilities0-False\]] + expected: ERROR + + [test_accept_and_notify[capabilities0-True\]] + expected: ERROR + + [test_dismiss[capabilities0-False\]] + expected: ERROR + + [test_dismiss[capabilities0-True\]] + expected: ERROR + + [test_dismiss_and_notify[capabilities0-False\]] + expected: ERROR + + [test_dismiss_and_notify[capabilities0-True\]] + expected: ERROR + + [test_ignore[capabilities0-False\]] + expected: ERROR + + [test_ignore[capabilities0-True\]] + expected: ERROR + + [test_accept[False\]] + expected: ERROR + + [test_accept[True\]] + expected: ERROR + + [test_accept_and_notify[False\]] + expected: ERROR + + [test_accept_and_notify[True\]] + expected: ERROR + + [test_dismiss[False\]] + expected: ERROR + + [test_dismiss[True\]] + expected: ERROR + + [test_dismiss_and_notify[False\]] + expected: ERROR + + [test_dismiss_and_notify[True\]] + expected: ERROR + + [test_ignore[False\]] + expected: ERROR + + [test_ignore[True\]] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/interop/frames.py.ini b/tests/wpt/meta/webdriver/tests/interop/frames.py.ini new file mode 100644 index 00000000000..21819720ff1 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/interop/frames.py.ini @@ -0,0 +1,3 @@ +[frames.py] + [test_classic_switch_to_parent_no_browsing_context] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/interop/shared_id_node.py.ini b/tests/wpt/meta/webdriver/tests/interop/shared_id_node.py.ini new file mode 100644 index 00000000000..07c51098229 --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/interop/shared_id_node.py.ini @@ -0,0 +1,18 @@ +[shared_id_node.py] + [test_web_element_reference_created_in_classic] + expected: ERROR + + [test_web_element_reference_created_in_bidi] + expected: ERROR + + [test_shadow_root_reference_created_in_classic[open\]] + expected: ERROR + + [test_shadow_root_reference_created_in_classic[closed\]] + expected: ERROR + + [test_shadow_root_reference_created_in_bidi[open\]] + expected: ERROR + + [test_shadow_root_reference_created_in_bidi[closed\]] + expected: ERROR diff --git a/tests/wpt/meta/webdriver/tests/interop/shared_id_window.py.ini b/tests/wpt/meta/webdriver/tests/interop/shared_id_window.py.ini new file mode 100644 index 00000000000..7dc97d71d7e --- /dev/null +++ b/tests/wpt/meta/webdriver/tests/interop/shared_id_window.py.ini @@ -0,0 +1,15 @@ +[shared_id_window.py] + [test_top_level_context_id_equals_window_handle] + expected: ERROR + + [test_web_window_reference_created_in_classic] + expected: ERROR + + [test_web_frame_reference_created_in_classic] + expected: ERROR + + [test_web_window_reference_created_in_bidi] + expected: ERROR + + [test_web_frame_reference_created_in_bidi] + expected: ERROR diff --git a/tests/wpt/meta/workers/WorkerGlobalScope-close.html.ini b/tests/wpt/meta/workers/WorkerGlobalScope-close.html.ini deleted file mode 100644 index 24daae4c2e7..00000000000 --- a/tests/wpt/meta/workers/WorkerGlobalScope-close.html.ini +++ /dev/null @@ -1,3 +0,0 @@ -[WorkerGlobalScope-close.html] - [Test sending a message after closing.] - expected: FAIL diff --git a/tests/wpt/tests/css/css-grid/abspos/abspos-in-flexbox-in-grid-crash.html b/tests/wpt/tests/css/css-grid/abspos/abspos-in-flexbox-in-grid-crash.html new file mode 100644 index 00000000000..a2f71fb78e7 --- /dev/null +++ b/tests/wpt/tests/css/css-grid/abspos/abspos-in-flexbox-in-grid-crash.html @@ -0,0 +1,12 @@ +<!DOCTYPE html> +<link rel="help" href="https://github.com/servo/servo/issues/36696"> + +<div style="display: flex; position: relative"> + <div style="display:grid"> + <div> + <div style="display: flex"> + <div style="position: absolute"></div> + </div> + </div> + </div> +</div> diff --git a/tests/wpt/tests/css/css-tables/colspan-zero-crash.html b/tests/wpt/tests/css/css-tables/colspan-zero-crash.html new file mode 100644 index 00000000000..a50586a5bfa --- /dev/null +++ b/tests/wpt/tests/css/css-tables/colspan-zero-crash.html @@ -0,0 +1,10 @@ +<!DOCTYPE html> +<link rel="help" href="https://github.com/servo/servo/issues/36699"> +<link rel="author" href="mailto:fwang@igalia.com" title="Frédéric Wang"> +<span id="span"></span> +<script> + let th = document.createElement("th"); + span.replaceWith(th); + th.colSpan = 0; +</script> + diff --git a/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-002.html b/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-002.html new file mode 100644 index 00000000000..ff1d06dcc11 --- /dev/null +++ b/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-002.html @@ -0,0 +1,29 @@ +<!DOCTYPE html> +<title>CSS Test: Individual transform properties create stacking context</title> +<link rel="author" title="Oriol Brufau" href="obrufau@igalia.com"> +<link rel="help" href="https://www.w3.org/TR/css-transforms-2/#individual-transforms"> +<link rel="match" href="../../reference/ref-filled-green-100px-square.xht"> +<meta name="assert" content=" + Setting `rotate` to a value different than `none` establishes a stacking context. +"> + +<style> +.transform { + width: 100px; + height: 100px; + background: red; + rotate: 0deg; +} +.child { + width: 100px; + height: 100px; + background: green; + position: relative; + z-index: -1; +} +</style> + +<p>Test passes if there is a filled green square and <strong>no red</strong>.</p> +<div class="transform"> + <div class="child"></div> +</div> diff --git a/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-003.html b/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-003.html new file mode 100644 index 00000000000..6852722ed79 --- /dev/null +++ b/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-003.html @@ -0,0 +1,29 @@ +<!DOCTYPE html> +<title>CSS Test: Individual transform properties create stacking context</title> +<link rel="author" title="Oriol Brufau" href="obrufau@igalia.com"> +<link rel="help" href="https://www.w3.org/TR/css-transforms-2/#individual-transforms"> +<link rel="match" href="../../reference/ref-filled-green-100px-square.xht"> +<meta name="assert" content=" + Setting `scale` to a value different than `none` establishes a stacking context. +"> + +<style> +.transform { + width: 100px; + height: 100px; + background: red; + scale: 1; +} +.child { + width: 100px; + height: 100px; + background: green; + position: relative; + z-index: -1; +} +</style> + +<p>Test passes if there is a filled green square and <strong>no red</strong>.</p> +<div class="transform"> + <div class="child"></div> +</div> diff --git a/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-004.html b/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-004.html new file mode 100644 index 00000000000..6d7ec896736 --- /dev/null +++ b/tests/wpt/tests/css/css-transforms/individual-transform/stacking-context-004.html @@ -0,0 +1,29 @@ +<!DOCTYPE html> +<title>CSS Test: Individual transform properties create stacking context</title> +<link rel="author" title="Oriol Brufau" href="obrufau@igalia.com"> +<link rel="help" href="https://www.w3.org/TR/css-transforms-2/#individual-transforms"> +<link rel="match" href="../../reference/ref-filled-green-100px-square.xht"> +<meta name="assert" content=" + Setting `translate` to a value different than `none` establishes a stacking context. +"> + +<style> +.transform { + width: 100px; + height: 100px; + background: red; + translate: 0px; +} +.child { + width: 100px; + height: 100px; + background: green; + position: relative; + z-index: -1; +} +</style> + +<p>Test passes if there is a filled green square and <strong>no red</strong>.</p> +<div class="transform"> + <div class="child"></div> +</div> diff --git a/tests/wpt/tests/html/semantics/embedded-content/the-iframe-element/iframe-hit-test-during-load-event-crash.html b/tests/wpt/tests/html/semantics/embedded-content/the-iframe-element/iframe-hit-test-during-load-event-crash.html new file mode 100644 index 00000000000..f668fc51573 --- /dev/null +++ b/tests/wpt/tests/html/semantics/embedded-content/the-iframe-element/iframe-hit-test-during-load-event-crash.html @@ -0,0 +1,9 @@ +<!DOCTYPE html> +<div style="visibility: hidden;"> + <iframe id="iframe"></iframe> +</div> +<script> + window.addEventListener("load", _ => + iframe.contentDocument.elementFromPoint(0, 0) + ); +</script> diff --git a/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/col-span-limits.html b/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/col-span-limits.html index a4a425b9c1f..2a1ac80e65a 100644 --- a/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/col-span-limits.html +++ b/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/col-span-limits.html @@ -39,12 +39,21 @@ These two must look the same, each having 2 cells in one row: </table> <br> <table id=table3> - <col span=1001> + <col id="colspan-3" span=1001> <tr> <td colspan=1000><div class="square"></div></td> <td><div class="square"></div></td> </tr> </table> +<table> + <tr> + <td id="colspan-limit-test1" colspan=5></td> + <td id="colspan-limit-test2" colspan=0></td> + <td id="colspan-limit-test3" colspan=1000></td> + <td id="colspan-limit-test4" colspan=1001></td> + <td id="colspan-limit-test5" colspan=5555555></td> + </tr> +</table> </main> <script> @@ -56,4 +65,48 @@ test(() => { assert_equals(table2.offsetWidth, 51, "table2 width"); assert_equals(table3.offsetWidth, 51, "table3 width"); }, "col span of 1001 must be treated as 1000"); + +test(() => { + let td = document.createElement("td"); + td.colSpan = 5; + assert_equals(td.colSpan, 5); + + td.colSpan = 0; + assert_equals(td.colSpan, 1); + + td.colSpan = 1000; + assert_equals(td.colSpan, 1000); + + td.colSpan = 1001; + assert_equals(td.colSpan, 1000); + + td.colSpan = 555555; + assert_equals(td.colSpan, 1000); +}, "colspan must be clamped to [1, 1000] when set via script"); + +test(() => { + assert_equals(document.getElementById("colspan-limit-test1").colSpan, 5); + assert_equals(document.getElementById("colspan-limit-test2").colSpan, 1); + assert_equals(document.getElementById("colspan-limit-test3").colSpan, 1000); + assert_equals(document.getElementById("colspan-limit-test4").colSpan, 1000); + assert_equals(document.getElementById("colspan-limit-test5").colSpan, 1000); +}, "colspan must be clamped to [1, 1000] when parsing attributes"); + +test(() => { + let column = document.getElementById("colspan-3"); + column.span = 5; + assert_equals(column.span, 5); + + column.span = 0; + assert_equals(column.span, 1); + + column.span = 1000; + assert_equals(column.span, 1000); + + column.span = 1001; + assert_equals(column.span, 1000); + + column.span = 555555; + assert_equals(column.span, 1000); +}, "column span must be clamped to [1, 1000] when set via script"); </script> diff --git a/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/span-limits.html b/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/span-limits.html index cdfa61bbcdc..798639b3875 100644 --- a/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/span-limits.html +++ b/tests/wpt/tests/html/semantics/tabular-data/processing-model-1/span-limits.html @@ -29,6 +29,17 @@ <!-- We'll add another 65534 rows later --> </table> +<table> + <tr> + <td id="rowspan-limit-test1" rowspan=5></td> + <td id="rowspan-limit-test2" rowspan=0></td> + <td id="rowspan-limit-test3" rowspan=1000></td> + <td id="rowspan-limit-test4" rowspan=65534></td> + <td id="rowspan-limit-test5" rowspan=65535></td> + <td id="rowspan-limit-test6" rowspan=5555555></td> + </tr> +</table> + <script> var $ = document.querySelector.bind(document); @@ -63,4 +74,34 @@ test(() => { assert_equals($("#d1").getBoundingClientRect().bottom, $("#d2").getBoundingClientRect().bottom); }, "rowspan of 65535 must be treated as 65534"); + +test(() => { + let td = document.createElement("td"); + td.rowSpan = 5; + assert_equals(td.rowSpan, 5); + + td.rowSpan = 0; + assert_equals(td.rowSpan, 0); + + td.rowSpan = 1000; + assert_equals(td.rowSpan, 1000); + + td.rowSpan = 65534; + assert_equals(td.rowSpan, 65534); + + td.rowSpan = 65535; + assert_equals(td.rowSpan, 65534); + + td.rowSpan = 555555; + assert_equals(td.rowSpan, 65534); +}, "rowspan must be clamped to [0, 65534] when set via script"); + +test(() => { + assert_equals(document.getElementById("rowspan-limit-test1").rowSpan, 5); + assert_equals(document.getElementById("rowspan-limit-test2").rowSpan, 0); + assert_equals(document.getElementById("rowspan-limit-test3").rowSpan, 1000); + assert_equals(document.getElementById("rowspan-limit-test4").rowSpan, 65534); + assert_equals(document.getElementById("rowspan-limit-test5").rowSpan, 65534); + assert_equals(document.getElementById("rowspan-limit-test6").rowSpan, 65534); +}, "rowspan must be clamped to [0, 65534] when parsing attributes"); </script> |