--- a/accessible/base/CacheConstants.h
+++ b/accessible/base/CacheConstants.h
@@ -19,19 +19,17 @@ class CacheDomain {
   static constexpr uint64_t Text = ((uint64_t)0x1) << 4;
   static constexpr uint64_t DOMNodeID = ((uint64_t)0x1) << 5;
   static constexpr uint64_t State = ((uint64_t)0x1) << 6;
   static constexpr uint64_t GroupInfo = ((uint64_t)0x1) << 7;
   static constexpr uint64_t Actions = ((uint64_t)0x1) << 8;
   static constexpr uint64_t Style = ((uint64_t)0x1) << 9;
   static constexpr uint64_t TransformMatrix = ((uint64_t)0x1) << 10;
   static constexpr uint64_t ScrollPosition = ((uint64_t)0x1) << 11;
-  static constexpr uint64_t Table = ((uint64_t)0x1) << 11;
-  static constexpr uint64_t TextBounds = ((uint64_t)0x1) << 12;
-  // TODO: Combine TextBounds updates with Bounds updates
+  static constexpr uint64_t Table = ((uint64_t)0x1) << 12;
   static constexpr uint64_t All = ~((uint64_t)0x0);
 };
 
 enum class CacheUpdateType {
   /*
    * An initial cache push of a loaded document or inserted subtree.
    */
   Initial,

--- a/accessible/base/NotificationController.h
+++ b/accessible/base/NotificationController.h
@@ -170,16 +170,17 @@ class NotificationController final : pub
     // not visible.
     MOZ_ASSERT(aTextNode->GetParentNode(), "A text node is not in DOM");
     MOZ_ASSERT(aTextNode->GetPrimaryFrame(),
                "A text node doesn't have a frame");
     MOZ_ASSERT(aTextNode->GetPrimaryFrame()->StyleVisibility()->IsVisible(),
                "A text node is not visible");
 
     mTextHash.Insert(aTextNode);
+
     ScheduleProcessing();
   }
 
   /**
    * Pend accessible tree update for content insertion.
    */
   void ScheduleContentInsertion(LocalAccessible* aContainer,
                                 nsTArray<nsCOMPtr<nsIContent>>& aInsertions);

--- a/accessible/base/TextLeafRange.cpp
+++ b/accessible/base/TextLeafRange.cpp
@@ -12,16 +12,17 @@
 #include "mozilla/a11y/DocAccessibleParent.h"
 #include "mozilla/a11y/LocalAccessible.h"
 #include "mozilla/BinarySearch.h"
 #include "mozilla/Casting.h"
 #include "mozilla/intl/Segmenter.h"
 #include "mozilla/intl/WordBreaker.h"
 #include "mozilla/StaticPrefs_layout.h"
 #include "nsAccUtils.h"
+#include "nsBlockFrame.h"
 #include "nsContentUtils.h"
 #include "nsIAccessiblePivot.h"
 #include "nsILineIterator.h"
 #include "nsStyleStructInlines.h"
 #include "nsTArray.h"
 #include "nsTextFrame.h"
 #include "nsUnicodeProperties.h"
 #include "Pivot.h"
@@ -177,16 +178,32 @@ static bool IsLocalAccAtLineStart(LocalA
   prevFrame = prevFrame->LastContinuation();
   auto [prevBlock, prevLineFrame] = prevFrame->GetContainingBlockForLine(
       /* aLockScroll */ false);
   if (thisBlock != prevBlock) {
     // If the blocks are different, that means there's nothing before us on the
     // same line, so we're at the start.
     return true;
   }
+  if (nsBlockFrame* block = do_QueryFrame(thisBlock)) {
+    // If we have a block frame, it's faster for us to use
+    // BlockInFlowLineIterator because it uses the line cursor.
+    bool found = false;
+    block->SetupLineCursorForQuery();
+    nsBlockInFlowLineIterator prevIt(block, prevLineFrame, &found);
+    if (!found) {
+      // Error; play it safe.
+      return true;
+    }
+    found = false;
+    nsBlockInFlowLineIterator thisIt(block, thisLineFrame, &found);
+    // if the lines are different, that means there's nothing before us on the
+    // same line, so we're at the start.
+    return !found || prevIt.GetLine() != thisIt.GetLine();
+  }
   nsAutoLineIterator it = prevBlock->GetLineIterator();
   MOZ_ASSERT(it, "GetLineIterator impl in line-container blocks is infallible");
   int32_t prevLineNum = it->FindLineContaining(prevLineFrame);
   if (prevLineNum < 0) {
     // Error; play it safe.
     return true;
   }
   int32_t thisLineNum = it->FindLineContaining(thisLineFrame, prevLineNum);
@@ -1139,15 +1156,20 @@ LayoutDeviceIntRect TextLeafPoint::CharB
 
   if (!mAcc || !mAcc->IsRemote() || !mAcc->AsRemote() ||
       !mAcc->AsRemote()->mCachedFields) {
     return LayoutDeviceIntRect();
   }
 
   RemoteAccessible* acc = mAcc->AsRemote();
   if (Maybe<nsTArray<nsRect>> charBounds = acc->GetCachedCharData()) {
-    return acc->BoundsWithOffset(Some(charBounds->ElementAt(mOffset)));
+    if (mOffset < static_cast<int32_t>(charBounds->Length())) {
+      return acc->BoundsWithOffset(Some(charBounds->ElementAt(mOffset)));
+    }
+    // It is valid for a client to call this with an offset 1 after the last
+    // character because of the insertion point at the end of text boxes.
+    MOZ_ASSERT(mOffset == static_cast<int32_t>(charBounds->Length()));
   }
 
   return LayoutDeviceIntRect();
 }
 
 }  // namespace mozilla::a11y

--- a/accessible/generic/LocalAccessible.cpp
+++ b/accessible/generic/LocalAccessible.cpp
@@ -3202,41 +3202,16 @@ already_AddRefed<AccAttributes> LocalAcc
       if (!value.IsEmpty()) {
         fields->SetAttribute(nsGkAtoms::aria_valuetext, std::move(value));
       } else if (aUpdateType == CacheUpdateType::Update) {
         fields->SetAttribute(nsGkAtoms::aria_valuetext, DeleteEntry());
       }
     }
   }
 
-  nsIFrame* frame = GetFrame();
-  if ((aCacheDomain & CacheDomain::TextBounds) && IsTextLeaf()) {
-    if (frame && frame->IsTextFrame()) {
-      nsTArray<int32_t> charData;
-      nsIFrame* currTextFrame = frame;
-      while (currTextFrame) {
-        nsTArray<nsRect> charBounds;
-        currTextFrame->GetCharacterRectsInRange(
-            0, static_cast<nsTextFrame*>(currTextFrame)->GetContentLength(),
-            charBounds);
-        for (const nsRect& rect : charBounds) {
-          charData.AppendElement(rect.x);
-          charData.AppendElement(rect.y);
-          charData.AppendElement(rect.width);
-          charData.AppendElement(rect.height);
-        }
-        currTextFrame = currTextFrame->GetNextContinuation();
-      }
-
-      if (charData.Length()) {
-        fields->SetAttribute(nsGkAtoms::characterData, std::move(charData));
-      }
-    }
-  }
-
   bool boundsChanged = false;
   if (aCacheDomain & CacheDomain::Bounds) {
     nsRect newBoundsRect = ParentRelativeBounds();
 
     // 1. Layout might notify us of a possible bounds change when the bounds
     // haven't really changed. Therefore, we cache the last  bounds we sent
     // and don't send an update if they haven't changed.
     // 2. For an initial cache push, we ignore 1)  and always send the bounds.
@@ -3276,27 +3251,28 @@ already_AddRefed<AccAttributes> LocalAcc
       }
     }
     if (HyperTextAccessible* ht = AsHyperText()) {
       RefPtr<AccAttributes> attrs = ht->DefaultTextAttributes();
       fields->SetAttribute(nsGkAtoms::style, std::move(attrs));
     }
   }
 
+  nsIFrame* frame = GetFrame();
   if (aCacheDomain & (CacheDomain::Text | CacheDomain::Bounds) &&
       !HasChildren()) {
     // We cache line start offsets for both text and non-text leaf Accessibles
     // because non-text leaf Accessibles can still start a line.
     TextLeafPoint lineStart =
         TextLeafPoint(this, 0).FindNextLineStartSameLocalAcc(
             /* aIncludeOrigin */ true);
     int32_t lineStartOffset = lineStart ? lineStart.mOffset : -1;
-    // We push line starts in two cases:
+    // We push line starts and text bounds in two cases:
     // 1. Text or bounds changed, which means it's very likely that line starts
-    // changed too.
+    // and text bounds changed too.
     // 2. CacheDomain::Bounds was requested (indicating that the frame was
     // reflowed) but the bounds  didn't actually change. This can happen when
     // the spanned text is non-rectangular. For example, an Accessible might
     // cover two characters on one line and a single character on another line.
     // An insertion in a previous text node might cause it to shift such that it
     // now covers a single character on the first line and two characters on the
     // second line. Its bounding rect will be the same both before and after the
     // insertion. In this case, we use the first line start to determine whether
@@ -3311,16 +3287,38 @@ already_AddRefed<AccAttributes> LocalAcc
            lineStart = lineStart.FindNextLineStartSameLocalAcc(false)) {
         lineStarts.AppendElement(lineStart.mOffset);
       }
       if (!lineStarts.IsEmpty()) {
         fields->SetAttribute(nsGkAtoms::line, std::move(lineStarts));
       } else if (aUpdateType == CacheUpdateType::Update) {
         fields->SetAttribute(nsGkAtoms::line, DeleteEntry());
       }
+
+      if (frame && frame->IsTextFrame()) {
+        nsTArray<int32_t> charData;
+        nsIFrame* currTextFrame = frame;
+        while (currTextFrame) {
+          nsTArray<nsRect> charBounds;
+          currTextFrame->GetCharacterRectsInRange(
+              0, static_cast<nsTextFrame*>(currTextFrame)->GetContentLength(),
+              charBounds);
+          for (const nsRect& rect : charBounds) {
+            charData.AppendElement(rect.x);
+            charData.AppendElement(rect.y);
+            charData.AppendElement(rect.width);
+            charData.AppendElement(rect.height);
+          }
+          currTextFrame = currTextFrame->GetNextContinuation();
+        }
+
+        if (charData.Length()) {
+          fields->SetAttribute(nsGkAtoms::characterData, std::move(charData));
+        }
+      }
     }
   }
 
   if (aCacheDomain & CacheDomain::TransformMatrix) {
     if (frame && frame->IsTransformed()) {
       // We need to find a frame to make our transform relative to.
       // It's important this frame have a corresponding accessible,
       // because this transform is applied while walking the accessibility
@@ -3478,17 +3476,17 @@ already_AddRefed<AccAttributes> LocalAcc
           RefPtr<nsAtom> inputType = attr->GetAsAtom();
           if (inputType) {
             fields->SetAttribute(nsGkAtoms::textInputType, inputType);
           }
         }
       }
     }
 
-    if (nsIFrame* frame = GetFrame()) {
+    if (frame) {
       // Note our frame's current computed style so we can track style changes
       // later on.
       mOldComputedStyle = frame->Style();
       if (frame->IsTransformed()) {
         mStateFlags |= eOldFrameHasValidTransformStyle;
       } else {
         mStateFlags &= ~eOldFrameHasValidTransformStyle;
       }

--- a/accessible/tests/browser/e10s/browser_caching_text_bounds.js
+++ b/accessible/tests/browser/e10s/browser_caching_text_bounds.js
@@ -310,8 +310,47 @@ addAccessibleTask(
     await testTextNode(accDoc, browser, "d4");
     await testTextNode(accDoc, browser, "d5");
   },
   {
     topLevel: !isWinNoCache,
     iframe: !isWinNoCache,
   }
 );
+
+/**
+ * Test bounds after text mutations.
+ */
+addAccessibleTask(
+  `<p id="p">a</p>`,
+  async function(browser, docAcc) {
+    await testTextNode(docAcc, browser, "p");
+    const p = findAccessibleChildByID(docAcc, "p");
+    info("Appending a character to text leaf");
+    let textInserted = waitForEvent(EVENT_TEXT_INSERTED, p);
+    await invokeContentTask(browser, [], () => {
+      content.document.getElementById("p").firstChild.data = "ab";
+    });
+    await textInserted;
+    await testTextNode(docAcc, browser, "p");
+  },
+  {
+    chrome: true,
+    topLevel: !isWinNoCache,
+    iframe: !isWinNoCache,
+  }
+);
+
+/**
+ * Test character bounds on the insertion point at the end of a text box.
+ */
+addAccessibleTask(
+  `<input id="input" value="a">`,
+  async function(browser, docAcc) {
+    const input = findAccessibleChildByID(docAcc, "input");
+    testTextPos(input, 1, [0, 0], COORDTYPE_SCREEN_RELATIVE);
+  },
+  {
+    chrome: true,
+    topLevel: !isWinNoCache,
+    iframe: !isWinNoCache,
+  }
+);

--- a/dom/ipc/ContentParent.cpp
+++ b/dom/ipc/ContentParent.cpp
@@ -2996,18 +2996,21 @@ bool ContentParent::InitInternal(Process
   // Send the dynamic scalar definitions to the new process.
   TelemetryIPC::GetDynamicScalarDefinitions(xpcomInit.dynamicScalarDefs());
 
   for (auto const& [location, supported] : sCodecsSupported) {
     Unused << SendUpdateMediaCodecsSupported(location, supported);
   }
 
 #ifdef MOZ_WIDGET_ANDROID
-  Unused << SendDecoderSupportedMimeTypes(
-      AndroidDecoderModule::GetSupportedMimeTypes());
+  if (!(StaticPrefs::media_utility_process_enabled() &&
+        StaticPrefs::media_utility_android_media_codec_enabled())) {
+    Unused << SendDecoderSupportedMimeTypes(
+        AndroidDecoderModule::GetSupportedMimeTypes());
+  }
 #endif
 
   // Must send screen info before send initialData
   ScreenManager& screenManager = ScreenManager::GetSingleton();
   screenManager.CopyScreensToRemote(this);
 
   // Send the UA sheet shared memory buffer and the address it is mapped at.
   Maybe<SharedMemoryHandle> sharedUASheetHandle;

--- a/dom/media/platforms/PDMFactory.cpp
+++ b/dom/media/platforms/PDMFactory.cpp
@@ -563,16 +563,22 @@ void PDMFactory::CreateUtilityPDMs() {
 #ifdef MOZ_FFMPEG
   if (StaticPrefs::media_ffmpeg_enabled() &&
       StaticPrefs::media_utility_ffmpeg_enabled() &&
       !CreateAndStartupPDM<FFmpegRuntimeLinker>()) {
     mFailureFlags += GetFailureFlagBasedOnFFmpegStatus(
         FFmpegRuntimeLinker::LinkStatusCode());
   }
 #endif
+#ifdef MOZ_WIDGET_ANDROID
+  if (StaticPrefs::media_utility_android_media_codec_enabled()) {
+    StartupPDM(AndroidDecoderModule::Create(),
+               StaticPrefs::media_android_media_codec_preferred());
+  }
+#endif
   CreateAndStartupPDM<AgnosticDecoderModule>();
 }
 
 void PDMFactory::CreateContentPDMs() {
   if (StaticPrefs::media_gpu_process_decoder()) {
     CreateAndStartupPDM<RemoteDecoderModule>(RemoteDecodeIn::GpuProcess);
   }
 

new file mode 100644
--- /dev/null
+++ b/gfx/tests/crashtests/1771293.html
@@ -0,0 +1,10 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <style>
+        * {
+            backdrop-filter: opacity(0%) ! important;
+        }
+    </style>
+</head>
+</html>
\ No newline at end of file

new file mode 100644
--- /dev/null
+++ b/gfx/tests/crashtests/1771294.html
@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+    <style>
+        * {
+            backdrop-filter: invert(86%);
+            display: table-cell;
+            zoom: 721146529;
+            padding-top: 7rem;
+            transform: matrix3d(0, 16, 2147483648, -49, -128, 140, 207.9298442167209, 512.763543618518, 172.4361353002723, 179, -81, 58.01970174841815, 1.7384436475415694, 243, 214, 3) ! important;
+            inline-size: 7420vw;
+            margin: 20%;
+        }
+    </style>
+</head>
+</html>
\ No newline at end of file

--- a/gfx/tests/crashtests/crashtests.list
+++ b/gfx/tests/crashtests/crashtests.list
@@ -209,8 +209,10 @@ load 1704321-1.html
 load 1702638.html
 load 1730695.html
 load 1745775.html
 load 1757002.html
 load 1758127-1.html
 load 1762973-1.html
 pref(layout.css.backdrop-filter.enabled,true) load 1765667.html
 load 1768096-1.html
+pref(layout.css.backdrop-filter.enabled,true) load 1771294.html
+pref(layout.css.backdrop-filter.enabled,true) load 1771293.html

--- a/gfx/wr/webrender/src/batch.rs
+++ b/gfx/wr/webrender/src/batch.rs
@@ -2995,41 +2995,49 @@ impl BatchBuilder {
 
                 let map_prim_to_backdrop = SpaceMapper::new_with_target(
                     pic_info.surface_spatial_node_index,
                     prim_spatial_node_index,
                     WorldRect::max_rect(),
                     ctx.spatial_tree,
                 );
 
-                let top_left = map_prim_to_backdrop.map_point(prim_rect.top_left()).unwrap();
-                let top_right = map_prim_to_backdrop.map_point(prim_rect.top_right()).unwrap();
-                let bottom_left = map_prim_to_backdrop.map_point(prim_rect.bottom_left()).unwrap();
-                let bottom_right = map_prim_to_backdrop.map_point(prim_rect.bottom_right()).unwrap();
-
-                let top_left = calculate_screen_uv(top_left * pic_info.device_pixel_scale, backdrop_rect);
-                let top_right = calculate_screen_uv(top_right * pic_info.device_pixel_scale, backdrop_rect);
-                let bottom_left = calculate_screen_uv(bottom_left * pic_info.device_pixel_scale, backdrop_rect);
-                let bottom_right = calculate_screen_uv(bottom_right * pic_info.device_pixel_scale, backdrop_rect);
+                let points = [
+                    map_prim_to_backdrop.map_point(prim_rect.top_left()),
+                    map_prim_to_backdrop.map_point(prim_rect.top_right()),
+                    map_prim_to_backdrop.map_point(prim_rect.bottom_left()),
+                    map_prim_to_backdrop.map_point(prim_rect.bottom_right()),
+                ];
+
+                if points.iter().any(|p| p.is_none()) {
+                    return;
+                }
+
+                let uvs = [
+                    calculate_screen_uv(points[0].unwrap() * pic_info.device_pixel_scale, backdrop_rect),
+                    calculate_screen_uv(points[1].unwrap() * pic_info.device_pixel_scale, backdrop_rect),
+                    calculate_screen_uv(points[2].unwrap() * pic_info.device_pixel_scale, backdrop_rect),
+                    calculate_screen_uv(points[3].unwrap() * pic_info.device_pixel_scale, backdrop_rect),
+                ];
 
                 // TODO (gw): This is a hack that provides the GPU cache blocks for an
                 //            ImageSource. We should update the GPU cache interfaces to
                 //            allow pushing per-frame blocks via a request interface.
                 let gpu_blocks = &[
                     GpuBlockData::from([
                         target_rect.min.x as f32,
                         target_rect.min.y as f32,
                         target_rect.max.x as f32,
                         target_rect.max.y as f32,
                     ]),
                     GpuBlockData::from([0.0; 4]),
-                    GpuBlockData::from(top_left),
-                    GpuBlockData::from(top_right),
-                    GpuBlockData::from(bottom_left),
-                    GpuBlockData::from(bottom_right),
+                    GpuBlockData::from(uvs[0]),
+                    GpuBlockData::from(uvs[1]),
+                    GpuBlockData::from(uvs[2]),
+                    GpuBlockData::from(uvs[3]),
                 ];
                 let uv_rect_handle = gpu_cache.push_per_frame_blocks(gpu_blocks);
 
                 self.add_brush_instance_to_batches(
                     key,
                     batch_features,
                     bounding_rect,
                     z_id,

--- a/gfx/wr/webrender/src/frame_builder.rs
+++ b/gfx/wr/webrender/src/frame_builder.rs
@@ -440,16 +440,17 @@ impl FrameBuilder {
                     data_stores,
                     &mut scratch.primitive,
                     tile_caches,
                     &mut scene.prim_instances,
                 );
 
                 let pic = &mut scene.prim_store.pictures[pic_index.0];
                 pic.restore_context(
+                    *pic_index,
                     prim_list,
                     pic_context,
                     &scene.prim_instances,
                     &frame_context,
                     &mut frame_state,
                 );
             }
         }

--- a/gfx/wr/webrender/src/picture.rs
+++ b/gfx/wr/webrender/src/picture.rs
@@ -5786,29 +5786,31 @@ impl PicturePrimitive {
 
         let prim_list = mem::replace(&mut self.prim_list, PrimitiveList::empty());
 
         Some((context, state, prim_list))
     }
 
     pub fn restore_context(
         &mut self,
+        pic_index: PictureIndex,
         prim_list: PrimitiveList,
         context: PictureContext,
         prim_instances: &[PrimitiveInstance],
         frame_context: &FrameBuildingContext,
         frame_state: &mut FrameBuildingState,
     ) {
         // Pop any dirty regions this picture set
         for _ in 0 .. context.dirty_region_count {
             frame_state.pop_dirty_region();
         }
 
         if self.raster_config.is_some() {
             frame_state.surface_builder.pop_surface(
+                pic_index,
                 frame_state.rg_builder,
                 frame_state.cmd_buffers,
             );
         }
 
         if let Picture3DContext::In { root_data: Some(ref mut list), plane_splitter_index, .. } = self.context_3d {
             let splitter = &mut frame_state.plane_splitters[plane_splitter_index.0];
 

--- a/gfx/wr/webrender/src/prepare.rs
+++ b/gfx/wr/webrender/src/prepare.rs
@@ -159,16 +159,17 @@ fn prepare_prim_for_render(
                     scratch,
                     tile_caches,
                     prim_instances,
                 );
 
                 // Restore the dependencies (borrow check dance)
                 store.pictures[pic_context_for_children.pic_index.0]
                     .restore_context(
+                        pic_context_for_children.pic_index,
                         prim_list,
                         pic_context_for_children,
                         prim_instances,
                         frame_context,
                         frame_state,
                     );
             }
             None => {
@@ -800,27 +801,30 @@ fn prepare_interned_prim_for_render(
                 prim_instance.clear_visibility();
             }
         }
         PrimitiveInstanceKind::BackdropCapture { .. } => {
             // Register the owner picture of this backdrop primitive as the
             // target for resolve of the sub-graph
             frame_state.surface_builder.register_resolve_source();
         }
-        PrimitiveInstanceKind::BackdropRender { .. } => {
-            let sub_graph_output_id = frame_state
-                .surface_builder
-                .sub_graph_output_stack
-                .pop()
-                .expect("bug: no sub-graph output");
-
-            frame_state.surface_builder.add_child_render_task(
-                sub_graph_output_id,
-                frame_state.rg_builder,
-            );
+        PrimitiveInstanceKind::BackdropRender { pic_index, .. } => {
+            match frame_state.surface_builder.sub_graph_output_map.get(pic_index).cloned() {
+                Some(sub_graph_output_id) => {
+                    frame_state.surface_builder.add_child_render_task(
+                        sub_graph_output_id,
+                        frame_state.rg_builder,
+                    );
+                }
+                None => {
+                    // Backdrop capture was found not visible, didn't produce a sub-graph
+                    // so we can just skip drawing
+                    prim_instance.clear_visibility();
+                }
+            }
         }
     };
 }
 
 
 fn write_segment<F>(
     segment_instance_index: SegmentInstanceIndex,
     frame_state: &mut FrameBuildingState,

--- a/gfx/wr/webrender/src/surface.rs
+++ b/gfx/wr/webrender/src/surface.rs
@@ -1,17 +1,17 @@
 /* This Source Code Form is subject to the terms of the Mozilla Public
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
 use api::units::*;
 use crate::batch::{CommandBufferBuilderKind, CommandBufferList, CommandBufferBuilder, CommandBufferIndex};
 use crate::internal_types::FastHashMap;
 use crate::picture::{SurfaceInfo, SurfaceIndex, TileKey, SubSliceIndex};
-use crate::prim_store::{PrimitiveInstanceIndex};
+use crate::prim_store::{PrimitiveInstanceIndex, PictureIndex};
 use crate::render_task_graph::{RenderTaskId, RenderTaskGraphBuilder};
 use crate::spatial_tree::SpatialNodeIndex;
 use crate::render_target::ResolveOp;
 use crate::render_task::{RenderTask, RenderTaskKind, RenderTaskLocation};
 use crate::visibility::{VisibilityState, PrimitiveVisibility};
 
 /*
  Contains functionality to help building the render task graph from a series of off-screen
@@ -199,28 +199,28 @@ impl CommandBufferTargets {
 // will support building sub-graphs.
 pub struct SurfaceBuilder {
     // The currently set cmd buffer targets (updated during push/pop)
     current_cmd_buffers: CommandBufferTargets,
     // Stack of surfaces that are parents to the current targets
     builder_stack: Vec<CommandBufferBuilder>,
     // Dirty rect stack used to reject adding primitives
     dirty_rect_stack: Vec<Vec<PictureRect>>,
-    // A stack of the output render tasks from any sub-graphs that haven't
+    // A map of the output render tasks from any sub-graphs that haven't
     // been consumed by BackdropRender prims yet
-    pub sub_graph_output_stack: Vec<RenderTaskId>,
+    pub sub_graph_output_map: FastHashMap<PictureIndex, RenderTaskId>,
 }
 
 impl SurfaceBuilder {
     pub fn new() -> Self {
         SurfaceBuilder {
             current_cmd_buffers: CommandBufferTargets::Tiled { tiles: FastHashMap::default() },
             builder_stack: Vec::new(),
             dirty_rect_stack: Vec::new(),
-            sub_graph_output_stack: Vec::new(),
+            sub_graph_output_map: FastHashMap::default(),
         }
     }
 
     /// Register the current surface as the source of a resolve for the task sub-graph that
     /// is currently on the surface builder stack.
     pub fn register_resolve_source(
         &mut self,
     ) {
@@ -377,16 +377,17 @@ impl SurfaceBuilder {
             }
             VisibilityState::PassThrough | VisibilityState::Culled => {}
         }
     }
 
     // Finish adding primitives and child tasks to a surface and pop it off the stack
     pub fn pop_surface(
         &mut self,
+        pic_index: PictureIndex,
         rg_builder: &mut RenderTaskGraphBuilder,
         cmd_buffers: &mut CommandBufferList,
     ) {
         self.dirty_rect_stack.pop().unwrap();
 
         let builder = self.builder_stack.pop().unwrap();
 
         if builder.establishes_sub_graph {
@@ -396,17 +397,21 @@ impl SurfaceBuilder {
                     unreachable!("bug: sub-graphs can only be simple surfaces");
                 }
                 CommandBufferBuilderKind::Simple { render_task_id: child_render_task_id, root_task_id: child_root_task_id } => {
                     // Get info about the resolve operation to copy from parent surface or tiles to the picture cache task
                     let resolve_task_id = builder.resolve_source.expect("bug: no resolve set");
                     let mut src_task_ids = Vec::new();
 
                     // Make the output of the sub-graph a dependency of the new replacement tile task
-                    self.sub_graph_output_stack.push(child_root_task_id.unwrap_or(child_render_task_id));
+                    let _old = self.sub_graph_output_map.insert(
+                        pic_index,
+                        child_root_task_id.unwrap_or(child_render_task_id),
+                    );
+                    debug_assert!(_old.is_none());
 
                     // Set up dependencies for the sub-graph. The basic concepts below are the same, but for
                     // tiled surfaces are a little more complex as there are multiple tasks to set up.
                     //  (a) Set up new task(s) on parent surface that write to the same location
                     //  (b) Set up a resolve target to copy from parent surface tasks(s) to the resolve target
                     //  (c) Make the old parent surface tasks input dependencies of the resolve target
                     //  (d) Make the sub-graph output an input dependency of the new task(s).
 

--- a/ipc/glue/UtilityAudioDecoderParent.cpp
+++ b/ipc/glue/UtilityAudioDecoderParent.cpp
@@ -14,16 +14,21 @@
 #if defined(XP_WIN) && defined(MOZ_SANDBOX)
 #  include "WMF.h"
 #  include "WMFDecoderModule.h"
 #  include "WMFUtils.h"
 
 #  include "mozilla/sandboxTarget.h"
 #endif  // defined(XP_WIN) && defined(MOZ_SANDBOX)
 
+#ifdef MOZ_WIDGET_ANDROID
+#  include "mozilla/StaticPrefs_media.h"
+#  include "AndroidDecoderModule.h"
+#endif
+
 namespace mozilla::ipc {
 
 UtilityAudioDecoderParent::UtilityAudioDecoderParent() {
   nsDebugImpl::SetMultiprocessMode("Utility AudioDecoder");
   profiler_set_process_name(nsCString("Utility AudioDecoder"));
 }
 
 /* static */
@@ -52,16 +57,23 @@ void UtilityAudioDecoderParent::PreloadF
 
 void UtilityAudioDecoderParent::Start(
     Endpoint<PUtilityAudioDecoderParent>&& aEndpoint) {
   MOZ_ASSERT(NS_IsMainThread());
 
   DebugOnly<bool> ok = std::move(aEndpoint).Bind(this);
   MOZ_ASSERT(ok);
 
+#ifdef MOZ_WIDGET_ANDROID
+  if (StaticPrefs::media_utility_android_media_codec_enabled()) {
+    AndroidDecoderModule::SetSupportedMimeTypes(
+        AndroidDecoderModule::GetSupportedMimeTypes());
+  }
+#endif
+
   auto supported = PDMFactory::Supported();
   Unused << SendUpdateMediaCodecsSupported(std::move(supported));
 }
 
 mozilla::ipc::IPCResult
 UtilityAudioDecoderParent::RecvNewContentRemoteDecoderManager(
     Endpoint<PRemoteDecoderManagerParent>&& aEndpoint) {
   MOZ_ASSERT(NS_IsMainThread());

--- a/ipc/glue/test/browser/head.js
+++ b/ipc/glue/test/browser/head.js
@@ -1,33 +1,35 @@
 /* Any copyright is dedicated to the Public Domain.
  * http://creativecommons.org/publicdomain/zero/1.0/ */
 
 "use strict";
 
-const utilityProcessTest = Cc[
-  "@mozilla.org/utility-process-test;1"
-].createInstance(Ci.nsIUtilityProcessTest);
+const utilityProcessTest = () => {
+  return Cc["@mozilla.org/utility-process-test;1"].createInstance(
+    Ci.nsIUtilityProcessTest
+  );
+};
 
 const kGenericUtility = 0x0;
 
 async function startUtilityProcess() {
   info("Start a UtilityProcess");
-  return utilityProcessTest.startProcess();
+  return utilityProcessTest().startProcess();
 }
 
 async function cleanUtilityProcessShutdown(utilityPid) {
   info(`CleanShutdown Utility Process ${utilityPid}`);
   ok(utilityPid !== undefined, "Utility needs to be defined");
 
   const utilityProcessGone = TestUtils.topicObserved(
     "ipc:utility-shutdown",
     (subject, data) => parseInt(data, 10) === utilityPid
   );
-  await utilityProcessTest.stopProcess();
+  await utilityProcessTest().stopProcess();
 
   let [subject, data] = await utilityProcessGone;
   ok(
     subject instanceof Ci.nsIPropertyBag2,
     "Subject needs to be a nsIPropertyBag2 to clean up properly"
   );
   is(
     parseInt(data, 10),
@@ -39,61 +41,98 @@ async function cleanUtilityProcessShutdo
 }
 
 async function addMediaTab(src) {
   const tab = BrowserTestUtils.addTab(gBrowser, "about:blank", {
     forceNewProcess: true,
   });
   const browser = gBrowser.getBrowserForTab(tab);
   await BrowserTestUtils.browserLoaded(browser);
-  await SpecialPowers.spawn(browser, [src], async src => {
-    const ROOT = "https://example.com/browser/ipc/glue/test/browser";
-    let audio = content.document.createElement("audio");
-    audio.setAttribute("controls", "true");
-    audio.setAttribute("loop", true);
-    audio.src = `${ROOT}/${src}`;
-    content.document.body.appendChild(audio);
-  });
+  await SpecialPowers.spawn(browser, [src], createAudioElement);
   return tab;
 }
 
+async function play(tab, expectUtility, expectContent = false) {
+  let browser = tab.linkedBrowser;
+  return SpecialPowers.spawn(
+    browser,
+    [expectUtility, expectContent],
+    checkAudioDecoder
+  );
+}
+
 async function stop(tab) {
   let browser = tab.linkedBrowser;
   await SpecialPowers.spawn(browser, [], async function() {
     let audio = content.document.querySelector("audio");
     audio.pause();
   });
 }
 
-async function play(tab, expectUtility) {
-  let browser = tab.linkedBrowser;
-  return SpecialPowers.spawn(browser, [expectUtility], async expectUtility => {
-    let audio = content.document.querySelector("audio");
-    const checkPromise = new Promise((resolve, reject) => {
-      const timeUpdateHandler = async ev => {
-        const debugInfo = await SpecialPowers.wrap(audio).mozRequestDebugInfo();
-        const audioDecoderName = debugInfo.decoder.reader.audioDecoderName;
-        const isUtility = audioDecoderName.indexOf("(Utility remote)") > 0;
-        const isRDD = audioDecoderName.indexOf("(RDD remote)") > 0;
-        const isOk = expectUtility === true ? isUtility : isRDD;
+async function createAudioElement(src) {
+  const doc = typeof content !== "undefined" ? content.document : document;
+  const ROOT = "https://example.com/browser/ipc/glue/test/browser";
+  let audio = doc.createElement("audio");
+  audio.setAttribute("controls", "true");
+  audio.setAttribute("loop", true);
+  audio.src = `${ROOT}/${src}`;
+  doc.body.appendChild(audio);
+}
 
-        ok(isOk, `playback was from expected decoder ${audioDecoderName}`);
+async function checkAudioDecoder(expectUtility, expectContent = false) {
+  const doc = typeof content !== "undefined" ? content.document : document;
+  let audio = doc.querySelector("audio");
+  const checkPromise = new Promise((resolve, reject) => {
+    const timeUpdateHandler = async ev => {
+      const debugInfo = await SpecialPowers.wrap(audio).mozRequestDebugInfo();
+      const audioDecoderName = debugInfo.decoder.reader.audioDecoderName;
+      const isUtility = audioDecoderName.indexOf("(Utility remote)") > 0;
+      const isRDD = audioDecoderName.indexOf("(RDD remote)") > 0;
+      const isJavaRemote = audioDecoderName.indexOf("(remote)") > 0;
+      const isContent = !isUtility && !isRDD;
+      const isOk =
+        (expectUtility === true && isUtility && !isJavaRemote) ||
+        (expectUtility === false && isRDD && !isJavaRemote) ||
+        (expectContent === true && isContent);
+
+      ok(
+        isOk,
+        `playback ${audio.src} was from expected decoder ${audioDecoderName}`
+      );
 
-        if (isOk) {
-          resolve();
-        } else {
-          reject();
-        }
-      };
+      if (isOk) {
+        resolve();
+      } else {
+        reject();
+      }
+    };
 
-      audio.addEventListener("timeupdate", timeUpdateHandler, { once: true });
-    });
+    audio.addEventListener("timeupdate", timeUpdateHandler, { once: true });
+  });
 
-    ok(
-      await audio.play().then(
-        _ => true,
-        _ => false
-      ),
-      "audio started playing"
-    );
-    await checkPromise;
-  });
+  ok(
+    await audio.play().then(
+      _ => true,
+      _ => false
+    ),
+    "audio started playing"
+  );
+  return checkPromise;
 }
+
+async function runMochitestUtilityAudio(
+  src,
+  { expectUtility, expectContent = false } = {}
+) {
+  info(`Add media: ${src}`);
+  await createAudioElement(src);
+  let audio = document.querySelector("audio");
+  ok(audio, "Found an audio element created");
+
+  info(`Play media: ${src}`);
+  await checkAudioDecoder(expectUtility, expectContent);
+
+  info(`Pause media: ${src}`);
+  await audio.pause();
+
+  info(`Remove media: ${src}`);
+  document.body.removeChild(audio);
+}

new file mode 100644
--- /dev/null
+++ b/ipc/glue/test/browser/mochitest_audio_off.ini
@@ -0,0 +1,12 @@
+[DEFAULT]
+run-if = toolkit == 'android'
+support-files =
+  head.js
+  ../../../../dom/media/test/small-shot.ogg
+  ../../../../dom/media/test/small-shot.mp3
+  ../../../../dom/media/test/small-shot.m4a
+  ../../../../dom/media/test/small-shot.flac
+prefs =
+  media.utility-process.enabled=false
+
+[test_utility_audio_off.html]

new file mode 100644
--- /dev/null
+++ b/ipc/glue/test/browser/mochitest_audio_on.ini
@@ -0,0 +1,12 @@
+[DEFAULT]
+run-if = toolkit == 'android'
+support-files =
+  head.js
+  ../../../../dom/media/test/small-shot.ogg
+  ../../../../dom/media/test/small-shot.mp3
+  ../../../../dom/media/test/small-shot.m4a
+  ../../../../dom/media/test/small-shot.flac
+prefs =
+  media.utility-process.enabled=true
+
+[test_utility_audio_on.html]

--- a/ipc/glue/test/browser/moz.build
+++ b/ipc/glue/test/browser/moz.build
@@ -1,7 +1,8 @@
 # -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
 # vim: set filetype=python:
 # 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 http://mozilla.org/MPL/2.0/.
 
 BROWSER_CHROME_MANIFESTS += ["browser.ini"]
+MOCHITEST_MANIFESTS += ["mochitest_audio_off.ini", "mochitest_audio_on.ini"]

new file mode 100644
--- /dev/null
+++ b/ipc/glue/test/browser/test_utility_audio_off.html
@@ -0,0 +1,33 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Audio decoder not in Utility process</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script src="head.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<pre id="test">
+<script type="text/javascript">
+SimpleTest.waitForExplicitFinish();
+
+(async function() {
+  for (let src of [
+    "small-shot.ogg",
+    "small-shot.mp3",
+    "small-shot.m4a",
+    "small-shot.flac",
+  ]) {
+    try {
+      await runMochitestUtilityAudio(src, { expectUtility: false, expectContent: true });
+    } catch (ex) {
+      ok(false, "Failure");
+    }
+  }
+
+  SimpleTest.finish();
+})();
+</script>
+</pre>
+</body>
+</html>

new file mode 100644
--- /dev/null
+++ b/ipc/glue/test/browser/test_utility_audio_on.html
@@ -0,0 +1,43 @@
+<!DOCTYPE HTML>
+<html>
+<head>
+  <title>Audio decoder in Utility process</title>
+  <script src="/tests/SimpleTest/SimpleTest.js"></script>
+  <script src="head.js"></script>
+  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
+</head>
+<body>
+<pre id="test">
+<script type="text/javascript">
+SimpleTest.waitForExplicitFinish();
+
+(async function() {
+  for (let src of [
+    "small-shot.ogg",
+    "small-shot.mp3",
+    "small-shot.flac"
+  ]) {
+    try {
+      await runMochitestUtilityAudio(src, { expectUtility: true, expectContent: false });
+    } catch (ex) {
+      ok(false, "Failure");
+    }
+  }
+
+  // Remove all after Bug 1771196
+  for (let src of [
+    "small-shot.m4a",
+  ]) {
+    try {
+      await runMochitestUtilityAudio(src, { expectUtility: false, expectContent: true });
+    } catch (ex) {
+      ok(false, "Failure");
+    }
+  }
+
+  SimpleTest.finish();
+})();
+</script>
+</pre>
+</body>
+</html>

--- a/modules/libpref/init/StaticPrefList.yaml
+++ b/modules/libpref/init/StaticPrefList.yaml
@@ -8960,27 +8960,17 @@
   type: RelaxedAtomicBool
   value: true
   mirror: always
 #endif
 
 #ifdef MOZ_FFVPX
 - name: media.utility-ffvpx.enabled
   type: RelaxedAtomicBool
-#if defined(XP_WIN)
-  value: true
-#elif defined(XP_MACOSX)
-  value: true
-#elif defined(XP_LINUX) && !defined(ANDROID)
-  value: true
-#elif defined(XP_OPENBSD)
-  value: true
-#else
-  value: false
-#endif
+  value: true
   mirror: always
 #endif
 
 #ifdef MOZ_WMF
 - name: media.utility-wmf.enabled
   type: RelaxedAtomicBool
   value: true
   mirror: always
@@ -9010,16 +9000,23 @@
 
 #ifdef ANDROID
   # Enable the MediaCodec PlatformDecoderModule by default.
 -   name: media.android-media-codec.enabled
     type: RelaxedAtomicBool
     value: true
     mirror: always
 
+  # Bug 1771196
+  # Dont yet enable AndroidDecoderModule on Utility
+-   name: media.utility-android-media-codec.enabled
+    type: RelaxedAtomicBool
+    value: false
+    mirror: always
+
 -   name: media.android-media-codec.preferred
     type: RelaxedAtomicBool
     value: true
     mirror: always
 #endif  # ANDROID
 
 #ifdef MOZ_OMX
 -   name: media.omx.enabled

--- a/services/sync/modules/telemetry.js
+++ b/services/sync/modules/telemetry.js
@@ -112,16 +112,26 @@ function tryGetMonotonicTimestamp() {
 function timeDeltaFrom(monotonicStartTime) {
   let now = tryGetMonotonicTimestamp();
   if (monotonicStartTime !== -1 && now !== -1) {
     return Math.round(now - monotonicStartTime);
   }
   return -1;
 }
 
+const NS_ERROR_MODULE_BASE_OFFSET = 0x45;
+const NS_ERROR_MODULE_NETWORK = 6;
+
+// A reimplementation of NS_ERROR_GET_MODULE, which surprisingly doesn't seem
+// to exist anywhere in .js code in a way that can be reused.
+// This is taken from DownloadCore.jsm.
+function NS_ERROR_GET_MODULE(code) {
+  return ((code & 0x7fff0000) >> 16) - NS_ERROR_MODULE_BASE_OFFSET;
+}
+
 // Converts extra integer fields to strings, rounds floats to three
 // decimal places (nanosecond precision for timings), and removes profile
 // directory paths and URLs from potential error messages.
 function normalizeExtraTelemetryFields(extra) {
   let result = {};
   for (let key in extra) {
     let value = extra[key];
     let type = typeof value;
@@ -1139,16 +1149,29 @@ class SyncTelemetryImpl {
       return { name: "httperror", code: httpCode };
     }
 
     if (error.failureCode) {
       return { name: "othererror", error: error.failureCode };
     }
 
     if (error.result) {
+      // many "nsresult" errors are actually network errors - if they are
+      // associated with the "network" module we assume that's true.
+      // We also assume NS_ERROR_ABORT is such an error - for almost everything
+      // we care about, it acually is (eg, if the connection fails early enough
+      // or if we have a captive portal etc) - we don't lose anything by this
+      // assumption, it's just that the error will no longer be in the "nserror"
+      // category, so our analysis can still find them.
+      if (
+        error.result == Cr.NS_ERROR_ABORT ||
+        NS_ERROR_GET_MODULE(error.result) == NS_ERROR_MODULE_NETWORK
+      ) {
+        return { name: "httperror", code: error.result };
+      }
       return { name: "nserror", code: error.result };
     }
     // It's probably an Error object, but it also could be some
     // other object that may or may not override toString to do
     // something useful.
     let msg = String(error);
     if (msg.startsWith("[object")) {
       // Nothing useful in the default, check for a string "message" property.

--- a/services/sync/tests/unit/test_telemetry.js
+++ b/services/sync/tests/unit/test_telemetry.js
@@ -551,16 +551,37 @@ add_task(async function test_engine_fail
       ok(failureReason.error.includes("[profileDir]"), failureReason.error);
     });
   } finally {
     await cleanAndGo(engine, server);
     await Service.engineManager.unregister(engine);
   }
 });
 
+add_task(async function test_error_detections() {
+  let telem = get_sync_test_telemetry();
+
+  // Non-network NS_ERROR_ codes get their own category.
+  Assert.deepEqual(
+    telem.transformError(Components.Exception("", Cr.NS_ERROR_FAILURE)),
+    { name: "nserror", code: Cr.NS_ERROR_FAILURE }
+  );
+
+  // Some NS_ERROR_ code in the "network" module are treated as http errors.
+  Assert.deepEqual(
+    telem.transformError(Components.Exception("", Cr.NS_ERROR_UNKNOWN_HOST)),
+    { name: "httperror", code: Cr.NS_ERROR_UNKNOWN_HOST }
+  );
+  // Some NS_ERROR_ABORT is treated as network by our telemetry.
+  Assert.deepEqual(
+    telem.transformError(Components.Exception("", Cr.NS_ERROR_ABORT)),
+    { name: "httperror", code: Cr.NS_ERROR_ABORT }
+  );
+});
+
 add_task(async function test_clean_urls() {
   enableValidationPrefs();
 
   await Service.engineManager.register(SteamEngine);
   let engine = Service.engineManager.get("steam");
   engine.enabled = true;
   let server = await serverForFoo(engine);
   await SyncTestingInfrastructure(server);
@@ -717,17 +738,17 @@ add_task(async function test_nserror() {
     _(`test_nserror: Steam tracker contents: ${JSON.stringify(changes)}`);
     await sync_and_validate_telem(ping => {
       deepEqual(ping.status, {
         service: SYNC_FAILED_PARTIAL,
         sync: LOGIN_FAILED_NETWORK_ERROR,
       });
       let enginePing = ping.engines.find(e => e.name === "steam");
       deepEqual(enginePing.failureReason, {
-        name: "nserror",
+        name: "httperror",
         code: Cr.NS_ERROR_UNKNOWN_HOST,
       });
     });
   } finally {
     await cleanAndGo(engine, server);
     await Service.engineManager.unregister(engine);
   }
 });

--- a/testing/web-platform/meta/IndexedDB/idb-explicit-commit.any.js.ini
+++ b/testing/web-platform/meta/IndexedDB/idb-explicit-commit.any.js.ini
@@ -1,26 +1,26 @@
 [idb-explicit-commit.any.html]
   disabled:
     if win10_2004 and ccov: https://bugzilla.mozilla.org/show_bug.cgi?id=1733368
   expected:
+    if (os == "win") and (processor == "x86_64") and debug and not swgl: [ERROR, OK]
     if (os == "win") and (processor == "x86_64") and debug and swgl: ERROR
-    if (os == "win") and (processor == "x86_64") and debug and not swgl: [ERROR, OK]
     if (os == "win") and (processor == "x86_64") and not debug: [ERROR, TIMEOUT]
     if (os == "linux") and not fission and not debug: [OK, ERROR]
     if (os == "win") and (processor == "x86"): ERROR
     if (os == "linux") and fission: ERROR
     if os == "mac": [ERROR, OK]
   [Transactions that explicitly commit and have errors should abort.]
     expected:
+      if (os == "linux") and not fission and not debug: [PASS, FAIL]
       if (os == "win") and not debug and (processor == "x86"): FAIL
       if (os == "win") and not debug and (processor == "x86_64"): [FAIL, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, FAIL]
+      if (os == "linux") and fission: FAIL
       if (os == "win") and debug: [FAIL, PASS]
-      if (os == "linux") and fission: FAIL
       if os == "mac": [FAIL, PASS]
 
   [Transactions that handle all errors properly should behave as expected when an explicit commit is called in an onerror handler.]
     expected:
       if (os == "win") and not swgl and not debug and (processor == "x86_64"): [PASS, NOTRUN]
       if (os == "win") and swgl: [PASS, TIMEOUT]
 
   [Calling abort on a committed transaction throws and does not prevent persisting the data.]

--- a/testing/web-platform/meta/IndexedDB/structured-clone.any.js.ini
+++ b/testing/web-platform/meta/IndexedDB/structured-clone.any.js.ini
@@ -65,24 +65,24 @@
     expected: FAIL
 
   [ReferenceError: ReferenceError: ghi]
     expected: FAIL
 
 
 [structured-clone.any.html?101-last]
   expected:
+    if (os == "android") and debug and not swgl: [TIMEOUT, OK]
     if (os == "linux") and swgl and not fission: [TIMEOUT, OK]
-    if (os == "android") and debug and not swgl: [TIMEOUT, OK]
     if (os == "win") and not debug: [TIMEOUT, OK]
     TIMEOUT
   [Not serializable: Window: [object Window\]]
     expected:
+      if (os == "android") and debug and not swgl: [NOTRUN, PASS]
       if (os == "linux") and swgl and not fission: [NOTRUN, PASS]
-      if (os == "android") and debug and not swgl: [NOTRUN, PASS]
       if (os == "win") and not debug: [NOTRUN, PASS]
       NOTRUN
 
   [Not serializable: symbol: Symbol(desc)]
     expected:
       if (os == "linux") and swgl and not fission: [NOTRUN, FAIL]
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
       if (os == "win") and not debug: [NOTRUN, FAIL]
@@ -93,27 +93,27 @@
       if win10_2004 and ccov: [TIMEOUT, NOTRUN, FAIL]
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
       if (os == "linux") and swgl and not fission: [NOTRUN, FAIL]
       if (os == "win") and not debug: [NOTRUN, FAIL]
       NOTRUN
 
   [Not serializable: function: function() {}]
     expected:
+      if (os == "android") and debug and not swgl: [NOTRUN, PASS]
       if (os == "linux") and swgl and not fission: [NOTRUN, PASS]
-      if (os == "android") and debug and not swgl: [NOTRUN, PASS]
       if (os == "win") and not debug: [NOTRUN, PASS]
       NOTRUN
 
   [File: [object File\]]
     expected:
       if (os == "win") and ccov: [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and debug and not fission and swgl: [NOTRUN, PASS, TIMEOUT]
+      if (os == "android") and debug and not swgl: [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and not debug and fission: NOTRUN
-      if (os == "android") and debug and not swgl: [NOTRUN, PASS, TIMEOUT]
       if (os == "mac") and debug: NOTRUN
       if os == "win": [NOTRUN, PASS, TIMEOUT]
       [NOTRUN, TIMEOUT]
 
   [Not serializable: Event: [object Event\]]
     expected:
       if (os == "android") and debug and not swgl: [NOTRUN, PASS]
       if (os == "linux") and swgl and not fission: [NOTRUN, PASS]
@@ -144,56 +144,57 @@
 
   [URIError: URIError: ghi]
     expected: FAIL
 
 
 [structured-clone.any.worker.html?101-last]
   expected:
     if debug and (os == "linux") and not fission and not swgl: [TIMEOUT, OK]
-    if debug and (os == "win") and (processor == "x86_64"): [TIMEOUT, OK]
-    if debug and (os == "android") and not swgl: [TIMEOUT, OK]
     if not debug and (os == "linux") and not fission: [TIMEOUT, OK]
     if not debug and (os == "win") and (processor == "x86_64"): [TIMEOUT, OK]
+    if debug and (os == "android") and not swgl: [TIMEOUT, OK]
+    if debug and (os == "win") and (processor == "x86_64"): [TIMEOUT, OK]
     if debug and (os == "mac"): [TIMEOUT, OK]
     TIMEOUT
   [Not serializable: function: function() {}]
     expected:
       if debug and (os == "linux") and not fission and not swgl: [NOTRUN, PASS]
+      if not debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if not debug and (os == "linux") and not fission: [NOTRUN, PASS]
-      if not debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if debug and (os == "android") and not swgl: [NOTRUN, PASS]
       if debug and (os == "mac"): [NOTRUN, PASS]
       NOTRUN
 
   [Not serializable: MessageChannel: [object MessageChannel\]]
     expected:
       if debug and (os == "linux") and not fission and not swgl: [NOTRUN, PASS]
+      if debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if debug and (os == "android") and not swgl: [NOTRUN, PASS]
-      if debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
+      if not debug and (os == "linux") and not fission: [NOTRUN, PASS]
       if not debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
-      if not debug and (os == "linux") and not fission: [NOTRUN, PASS]
       if debug and (os == "mac"): [NOTRUN, PASS]
       NOTRUN
 
   [Not serializable: symbol: Symbol(desc)]
     expected:
       if debug and (os == "linux") and not fission and not swgl: [NOTRUN, FAIL]
       if not debug and (os == "win") and (processor == "x86_64"): [NOTRUN, FAIL]
       if not debug and (os == "linux") and not fission: [NOTRUN, FAIL]
+      if debug and (os == "android") and not swgl: [NOTRUN, FAIL]
       if debug and (os == "win") and (processor == "x86_64"): [NOTRUN, FAIL]
-      if debug and (os == "android") and not swgl: [NOTRUN, FAIL]
       if debug and (os == "mac"): [NOTRUN, FAIL]
       NOTRUN
 
   [File: [object File\]]
     expected:
       if (os == "linux") and debug and not fission and not swgl: [NOTRUN, PASS, TIMEOUT]
       if (os == "android") and debug and not swgl: [NOTRUN, PASS, TIMEOUT]
+      if (os == "android") and debug and swgl: [TIMEOUT, NOTRUN]
       if (os == "linux") and not debug and not fission: [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and not debug and fission: NOTRUN
       if (os == "win") and (processor == "x86") and not debug: NOTRUN
       if (os == "mac") and debug: [NOTRUN, PASS, TIMEOUT]
       if (os == "win") and (processor == "x86_64"): [NOTRUN, PASS, TIMEOUT]
       [NOTRUN, TIMEOUT]
 
   [Not serializable: Event: [object Event\]]
@@ -204,27 +205,28 @@
       if debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if debug and (os == "android") and not swgl: [NOTRUN, PASS]
       if debug and (os == "mac"): [NOTRUN, PASS]
       NOTRUN
 
   [Not serializable: DedicatedWorkerGlobalScope: [object DedicatedWorkerGlobalScope\]]
     expected:
       if debug and (os == "linux") and not fission and not swgl: [NOTRUN, PASS]
+      if not debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if not debug and (os == "linux") and not fission: [NOTRUN, PASS]
-      if not debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if debug and (os == "android") and not swgl: [NOTRUN, PASS]
       if debug and (os == "win") and (processor == "x86_64"): [NOTRUN, PASS]
       if debug and (os == "mac"): [NOTRUN, PASS]
       NOTRUN
 
   [Blob: [object Blob\]]
     expected:
       if (os == "win") and not debug and (processor == "x86"): TIMEOUT
       if (os == "linux") and not debug and fission: TIMEOUT
+      if (os == "android") and swgl: [PASS, TIMEOUT]
       [TIMEOUT, PASS]
 
   [TypeError: TypeError]
     expected: FAIL
 
   [TypeError: TypeError: ghi]
     expected: FAIL
 

--- a/testing/web-platform/meta/content-security-policy/gen/top.http-rp/script-src-self/worklet-audio-import-data.https.html.ini
+++ b/testing/web-platform/meta/content-security-policy/gen/top.http-rp/script-src-self/worklet-audio-import-data.https.html.ini
@@ -1,10 +1,9 @@
 [worklet-audio-import-data.https.html]
   [Content Security Policy: Expects blocked for worklet-audio-import-data to cross-https origin and keep-origin redirection from https context.: securitypolicyviolation]
     expected:
-      if (os == "android") and debug and swgl: [PASS, FAIL]
-      if (os == "android") and debug and not swgl: [FAIL, PASS]
       if (os == "android") and not debug: [PASS, FAIL]
+      if (os == "android") and debug: [PASS, FAIL]
 
   [Content Security Policy: Expects blocked for worklet-audio-import-data to cross-https origin and no-redirect redirection from https context.: securitypolicyviolation]
     expected:
       if (os == "android") and debug: [PASS, FAIL]

--- a/testing/web-platform/meta/content-security-policy/gen/top.http-rp/script-src-wildcard/worklet-audio-import-data.https.html.ini
+++ b/testing/web-platform/meta/content-security-policy/gen/top.http-rp/script-src-wildcard/worklet-audio-import-data.https.html.ini
@@ -1,6 +1,5 @@
 [worklet-audio-import-data.https.html]
   [Content Security Policy: Expects blocked for worklet-audio-import-data to cross-https origin and keep-origin redirection from https context.: securitypolicyviolation]
     expected:
-      if (os == "android") and not swgl and not debug: [PASS, FAIL]
-      if (os == "android") and not swgl and debug: [PASS, FAIL]
-      if (os == "android") and swgl: [PASS, FAIL]
+      if (os == "android") and debug: [PASS, FAIL]
+      if (os == "android") and not debug: [PASS, FAIL]

--- a/testing/web-platform/meta/content-security-policy/gen/top.meta/script-src-wildcard/worklet-audio-import-data.https.html.ini
+++ b/testing/web-platform/meta/content-security-policy/gen/top.meta/script-src-wildcard/worklet-audio-import-data.https.html.ini
@@ -1,5 +1,5 @@
 [worklet-audio-import-data.https.html]
   [Content Security Policy: Expects blocked for worklet-audio-import-data to cross-https origin and keep-origin redirection from https context.: securitypolicyviolation]
     expected:
-      if (os == "android") and not swgl: [PASS, FAIL]
-      if (os == "android") and swgl: [FAIL, PASS]
+      if (os == "android") and debug: [PASS, FAIL]
+      if (os == "android") and not debug: [PASS, FAIL]

--- a/testing/web-platform/meta/content-security-policy/inheritance/history-iframe.sub.html.ini
+++ b/testing/web-platform/meta/content-security-policy/inheritance/history-iframe.sub.html.ini
@@ -1,55 +1,54 @@
 [history-iframe.sub.html]
   expected:
     if os == "win": OK
     if os == "android": OK
     [OK, TIMEOUT]
   [History navigation in iframe: "about:blank" document is navigated back from history same-origin.]
     expected:
-      if (os == "linux") and debug and not fission and swgl: [PASS, FAIL, TIMEOUT]
-      if (os == "linux") and debug and not fission and not swgl: [PASS, FAIL, TIMEOUT]
-      if (os == "linux") and debug and fission: [PASS, FAIL, TIMEOUT]
-      if (os == "linux") and not debug: [PASS, FAIL, TIMEOUT]
+      if (os == "linux") and not fission and debug: [PASS, FAIL, TIMEOUT]
+      if (os == "linux") and not fission and not debug: [PASS, FAIL, TIMEOUT]
+      if (os == "linux") and fission: [PASS, FAIL, TIMEOUT]
       if (os == "win") and (processor == "x86"): [PASS, FAIL]
       if os == "mac": [PASS, TIMEOUT]
 
   [History navigation in iframe: "about:blank" document is navigated back from history cross-origin.]
     expected:
       if (os == "linux") and fission: [PASS, FAIL, TIMEOUT, NOTRUN]
       if (os == "linux") and not fission: [PASS, TIMEOUT, NOTRUN]
       if os == "mac": [PASS, TIMEOUT, NOTRUN]
 
   [History navigation in iframe: blob URL document is navigated back from history same-origin.]
     expected:
+      if os == "android": PASS
       if os == "win": PASS
-      if os == "android": PASS
       [PASS, NOTRUN]
 
   [History navigation in iframe: blob URL document is navigated back from history cross-origin.]
     expected:
+      if os == "win": PASS
       if os == "android": PASS
-      if os == "win": PASS
       [PASS, NOTRUN]
 
   [History navigation in iframe: data URL document is navigated back from history same-origin.]
     expected:
       if os == "win": PASS
       if os == "android": PASS
       [PASS, NOTRUN]
 
   [History navigation in iframe: data URL document is navigated back from history cross-origin.]
     expected:
       if os == "android": PASS
       if os == "win": PASS
       [PASS, NOTRUN]
 
   [History navigation in iframe: srcdoc iframe is navigated back from history same-origin.]
     expected:
+      if os == "android": PASS
       if os == "win": PASS
-      if os == "android": PASS
       [PASS, NOTRUN]
 
   [History navigation in iframe: srcdoc iframe is navigated back from history cross-origin.]
     expected:
+      if os == "win": PASS
       if os == "android": PASS
-      if os == "win": PASS
       [PASS, NOTRUN]

--- a/testing/web-platform/meta/content-security-policy/inheritance/history.sub.html.ini
+++ b/testing/web-platform/meta/content-security-policy/inheritance/history.sub.html.ini
@@ -1,16 +1,16 @@
 [history.sub.html]
   expected:
+    if (os == "mac") and not debug: [OK, TIMEOUT]
     if (os == "mac") and debug: [OK, TIMEOUT]
-    if (os == "mac") and not debug: [TIMEOUT, OK]
   [History navigation: "about:blank" document is navigated back from history same-origin.]
     expected:
       if (os == "android") and not debug: [FAIL, TIMEOUT]
-      if (os == "mac") and not debug: [TIMEOUT, FAIL]
       if (os == "mac") and debug: [FAIL, TIMEOUT]
+      if (os == "mac") and not debug: [FAIL, TIMEOUT]
       FAIL
 
   [History navigation: "about:blank" document is navigated back from history cross-origin.]
     expected:
-      if (os == "mac") and not debug: [TIMEOUT, FAIL]
+      if (os == "mac") and not debug: [FAIL, TIMEOUT]
       if (os == "mac") and debug: [FAIL, TIMEOUT]
       FAIL

--- a/testing/web-platform/meta/content-security-policy/inheritance/iframe-all-local-schemes-inherit-self.sub.html.ini
+++ b/testing/web-platform/meta/content-security-policy/inheritance/iframe-all-local-schemes-inherit-self.sub.html.ini
@@ -1,10 +1,12 @@
 [iframe-all-local-schemes-inherit-self.sub.html]
   expected:
-    if (os == "linux") and not fission and debug and not swgl: [TIMEOUT, OK]
-    if (os == "linux") and not fission and not debug: [TIMEOUT, OK]
+    if (os == "win") and not debug and (processor == "x86"): [TIMEOUT, OK]
+    if (os == "linux") and not fission and not swgl: [TIMEOUT, OK]
+    if (os == "android") and swgl: [TIMEOUT, OK]
     [OK, TIMEOUT]
   [<iframe>'s about:blank inherits policy.]
     expected:
-      if (os == "linux") and not fission and debug and not swgl: [TIMEOUT, PASS]
-      if (os == "linux") and not fission and not debug: [TIMEOUT, PASS]
+      if (os == "win") and not debug and (processor == "x86"): [TIMEOUT, PASS]
+      if (os == "linux") and not fission and not swgl: [TIMEOUT, PASS]
+      if (os == "android") and swgl: [TIMEOUT, PASS]
       [PASS, TIMEOUT]

--- a/testing/web-platform/meta/content-security-policy/navigate-to/href-location-blocked.sub.html.ini
+++ b/testing/web-platform/meta/content-security-policy/navigate-to/href-location-blocked.sub.html.ini
@@ -1,5 +1,6 @@
 [href-location-blocked.sub.html]
   [Violation report status OK.]
     expected:
-      if (os == "android") and debug: [PASS, FAIL]
-      if (os == "android") and not debug: [FAIL, PASS]
+      if (os == "android") and debug and swgl: [PASS, FAIL]
+      if (os == "android") and debug and not swgl: [PASS, FAIL]
+      if (os == "android") and not debug: [PASS, FAIL]

--- a/testing/web-platform/meta/content-security-policy/navigate-to/spv-only-sent-to-initiator.sub.html.ini
+++ b/testing/web-platform/meta/content-security-policy/navigate-to/spv-only-sent-to-initiator.sub.html.ini
@@ -1,11 +1,7 @@
 [spv-only-sent-to-initiator.sub.html]
-  expected:
-    if (os == "mac") and not debug: [TIMEOUT, OK]
-    [OK, TIMEOUT]
+  expected: [OK, TIMEOUT]
   [Test that no spv event is raised]
-    expected:
-      if (os == "mac") and not debug: [NOTRUN, FAIL]
-      [FAIL, NOTRUN]
+    expected: [FAIL, NOTRUN]
 
   [Violation report status OK.]
     expected: FAIL

--- a/testing/web-platform/meta/content-security-policy/worker-src/__dir__.ini
+++ b/testing/web-platform/meta/content-security-policy/worker-src/__dir__.ini
@@ -1,1 +1,1 @@
-lsan-allowed: [detail::ProxyRelease, mozilla::SupportsThreadSafeWeakPtr, mozilla::ipc::BackgroundChildImpl::AllocPRemoteWorkerChild]
+lsan-allowed: [NS_NewRunnableFunction, detail::ProxyRelease, mozilla::SupportsThreadSafeWeakPtr, mozilla::ipc::BackgroundChildImpl::AllocPRemoteWorkerChild]

--- a/testing/web-platform/meta/css/CSS2/positioning/relpos-percentage-top-in-scrollable.html.ini
+++ b/testing/web-platform/meta/css/CSS2/positioning/relpos-percentage-top-in-scrollable.html.ini
@@ -1,5 +1,5 @@
 [relpos-percentage-top-in-scrollable.html]
   [Top percentage resolved correctly for overflow contribution]
     expected:
+      if (os == "android") and debug: [FAIL, PASS]
       if (os == "android") and not debug: [PASS, FAIL]
-      if (os == "android") and debug: [FAIL, PASS]

--- a/testing/web-platform/meta/css/css-scroll-anchoring/fragment-scrolling-anchors.html.ini
+++ b/testing/web-platform/meta/css/css-scroll-anchoring/fragment-scrolling-anchors.html.ini
@@ -1,6 +1,6 @@
 [fragment-scrolling-anchors.html]
   [Verify scroll anchoring interaction with fragment scrolls]
     expected:
+      if (os == "mac") and not debug: [PASS, FAIL]
       if (os == "mac") and debug: [PASS, FAIL]
-      if (os == "mac") and not debug: [PASS, FAIL]
       FAIL

--- a/testing/web-platform/meta/css/css-scroll-snap/input/keyboard.html.ini
+++ b/testing/web-platform/meta/css/css-scroll-snap/input/keyboard.html.ini
@@ -1,39 +1,38 @@
 [keyboard.html]
   expected:
+    if (os == "win") and debug and not swgl: [TIMEOUT, OK, PASS]
     if (os == "linux") and not fission and not debug: [TIMEOUT, OK, PASS]
-    if (os == "win") and debug and not swgl: [TIMEOUT, OK, PASS]
     [TIMEOUT, PASS]
   [If there is no valid snap offset on the arrow key's direction other than the current offset, and the scroll-snap-type is proximity, go to the original intended offset]
     expected:
-      if (os == "android") and debug and not swgl: [TIMEOUT, NOTRUN, FAIL]
-      if (os == "win") and debug and (processor == "x86"): [TIMEOUT, FAIL, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86_64") and not debug and fission: [NOTRUN, TIMEOUT, FAIL]
+      if (os == "linux") and not swgl and (processor == "x86_64") and debug and not fission: [TIMEOUT, FAIL, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, TIMEOUT, FAIL]
       [NOTRUN, FAIL, TIMEOUT]
 
   [Snaps to top-right after pressing ArrowRight]
     expected:
       if os == "mac": [PASS, FAIL, NOTRUN]
 
   [Snaps to bottom-left after pressing ArrowDown]
     expected:
-      if (os == "linux") and not swgl and fission and not debug and (processor == "x86"): [PASS, FAIL]
-      if (os == "linux") and not swgl and fission and not debug and (processor == "x86_64"): [FAIL, PASS]
-      if (os == "linux") and not swgl and not fission and not debug: [PASS, FAIL]
-      if (os == "linux") and not swgl and not fission and debug: [PASS, FAIL]
-      if (os == "linux") and not swgl and fission and debug: [PASS, FAIL]
+      if (os == "linux") and not swgl and not debug and (processor == "x86_64") and fission: [FAIL, PASS]
+      if (os == "linux") and not swgl and not debug and (processor == "x86_64") and not fission: [PASS, FAIL]
+      if (os == "linux") and not swgl and debug and not fission: [PASS, FAIL]
+      if (os == "linux") and not swgl and debug and fission: [PASS, FAIL]
+      if (os == "linux") and not swgl and not debug and (processor == "x86"): [PASS, FAIL]
       if (os == "android") and not swgl: FAIL
 
   [If the original intended offset is valid as making a snap area cover the snapport, but there's a defined snap offset in between, use the defined snap offset.]
     expected:
-      if (os == "android") and debug and not swgl: [PASS, TIMEOUT]
-      if (os == "win") and debug and (processor == "x86"): [PASS, TIMEOUT]
+      if (os == "linux") and not swgl and (processor == "x86_64") and debug and not fission: [PASS, TIMEOUT]
       [TIMEOUT, PASS]
 
   [If there is no valid snap offset on the arrow key's direction other than the current offset, and the scroll-snap-type is mandatory, stay at the current offset.]
     expected:
-      if (os == "android") and debug and not swgl: [PASS, NOTRUN]
-      if (os == "win") and debug and (processor == "x86"): [PASS, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86_64") and debug and not fission: [PASS, NOTRUN]
       [NOTRUN, PASS]
 
   [Snaps to top-left after pressing ArrowUp]
     expected:
       if (os == "linux") and not debug: [PASS, FAIL]

--- a/testing/web-platform/meta/css/cssom-view/background-change-during-smooth-scroll.html.ini
+++ b/testing/web-platform/meta/css/cssom-view/background-change-during-smooth-scroll.html.ini
@@ -1,10 +1,12 @@
 [background-change-during-smooth-scroll.html]
   expected:
-    if (os == "linux") and debug and fission: [OK, TIMEOUT]
+    if (os == "linux") and debug and fission and swgl: [OK, TIMEOUT]
+    if (os == "linux") and debug and fission and not swgl: [TIMEOUT, OK]
+    if (os == "linux") and not debug: [OK, TIMEOUT]
     if (os == "mac") and not debug: [OK, TIMEOUT]
-    if (os == "linux") and not debug: [OK, TIMEOUT]
   [background change during smooth scroll]
     expected:
-      if (os == "linux") and debug and fission: [PASS, NOTRUN]
+      if (os == "linux") and debug and fission and swgl: [PASS, NOTRUN]
+      if (os == "linux") and debug and fission and not swgl: [NOTRUN, PASS]
+      if (os == "mac") and not debug: [PASS, NOTRUN]
       if (os == "linux") and not debug: [PASS, NOTRUN]
-      if (os == "mac") and not debug: [PASS, NOTRUN]

--- a/testing/web-platform/meta/css/cssom-view/scroll-behavior-main-frame-root.html.ini
+++ b/testing/web-platform/meta/css/cssom-view/scroll-behavior-main-frame-root.html.ini
@@ -1,14 +1,13 @@
 [scroll-behavior-main-frame-root.html]
   [Main frame with auto scroll-behavior ; scroll() with smooth behavior]
     expected:
-      if (os == "linux") and not debug and (processor == "x86"): [FAIL, PASS]
+      if (os == "win") and (processor == "x86") and debug: [FAIL, PASS]
       if (os == "mac") and debug: [FAIL, PASS]
-      if (os == "win") and swgl: [FAIL, PASS]
       [PASS, FAIL]
 
   [Main frame with auto scroll-behavior ; scrollBy() with smooth behavior]
     expected:
       if swgl and not fission: [PASS, FAIL]
 
   [Main frame with auto scroll-behavior ; scrollTo() with smooth behavior]
     expected:

--- a/testing/web-platform/meta/css/cssom-view/scroll-behavior-main-frame-window.html.ini
+++ b/testing/web-platform/meta/css/cssom-view/scroll-behavior-main-frame-window.html.ini
@@ -4,23 +4,19 @@
       if fission: https://bugzilla.mozilla.org/show_bug.cgi?id=1712639
     expected:
       if not fission and swgl and (os == "android"): PASS
       if not fission and not swgl: PASS
       [PASS, FAIL]
 
   [Main frame with auto scroll-behavior ; scroll() with smooth behavior]
     expected:
-      if fission and (os == "linux") and not debug and (processor == "x86_64"): [FAIL, PASS]
-      if fission and (os == "linux") and not debug and (processor == "x86"): [FAIL, PASS]
-      if fission and (os == "mac") and not debug: [FAIL, PASS]
-      if fission and (os == "mac") and debug: [FAIL, PASS]
-      if fission and (os == "linux") and debug: [PASS, FAIL]
-      if fission and (os == "win") and swgl: [FAIL, PASS]
-      if fission and (os == "win") and not swgl: [PASS, FAIL]
+      if fission and debug and (os == "win") and (processor == "x86_64") and swgl: [FAIL, PASS]
+      if not fission: PASS
+      [PASS, FAIL]
 
   [Main frame with smooth scroll-behavior ; scrollBy() with default behavior]
     expected:
       if (os == "win") and debug and not swgl: [PASS, FAIL]
 
   [Main frame with auto scroll-behavior ; scrollBy() with smooth behavior]
     expected:
       if (os == "win") and debug and not swgl: [PASS, FAIL]

--- a/testing/web-platform/meta/css/selectors/focus-visible-009.html.ini
+++ b/testing/web-platform/meta/css/selectors/focus-visible-009.html.ini
@@ -1,6 +1,7 @@
 [focus-visible-009.html]
   [Autofocus should match :focus-visible]
     expected:
+      if (os == "linux") and not fission and not debug: [PASS, FAIL]
       if (os == "win") and not debug: [PASS, FAIL]
+      if (os == "mac") and not debug: [PASS, FAIL]
       if (os == "android") and not debug: [PASS, FAIL]
-      if (os == "mac") and not debug: [PASS, FAIL]

--- a/testing/web-platform/meta/dom/events/scrolling/scrollend-event-for-user-scroll.html.ini
+++ b/testing/web-platform/meta/dom/events/scrolling/scrollend-event-for-user-scroll.html.ini
@@ -11,26 +11,26 @@
       NOTRUN
 
   [Tests that the target_div gets scrollend event when click scrollbar on target.]
     expected:
       if (os == "linux") and not debug and (processor == "x86_64") and fission: [FAIL, NOTRUN, TIMEOUT]
       if (os == "linux") and not debug and (processor == "x86_64") and not fission: [FAIL, NOTRUN, TIMEOUT]
       if (os == "linux") and not debug and (processor == "x86"): [NOTRUN, FAIL, TIMEOUT]
       if (os == "linux") and debug: [FAIL, TIMEOUT, NOTRUN]
+      if os == "mac": [NOTRUN, FAIL]
       if os == "win": [NOTRUN, FAIL, TIMEOUT]
-      if os == "mac": [NOTRUN, FAIL]
       [FAIL, NOTRUN]
 
   [Tests that the target_div gets scrollend event when drag the thumb of target.]
     expected:
-      if (os == "linux") and (processor == "x86"): [NOTRUN, TIMEOUT]
+      if (os == "linux") and not debug and (processor == "x86"): [NOTRUN, TIMEOUT]
+      if os == "mac": [NOTRUN, FAIL, TIMEOUT]
       if os == "win": [NOTRUN, TIMEOUT]
       if os == "android": [FAIL, TIMEOUT, NOTRUN]
-      if os == "mac": [NOTRUN, FAIL, TIMEOUT]
       [TIMEOUT, NOTRUN]
 
   [Tests that the target_div gets scrollend event when dragging scroll on target.]
     expected:
-      if (os == "linux") and (processor == "x86"): [TIMEOUT, FAIL]
+      if (os == "linux") and not debug and (processor == "x86"): [TIMEOUT, FAIL]
+      if os == "win": [TIMEOUT, FAIL]
       if os == "mac": [TIMEOUT, FAIL]
-      if os == "win": [TIMEOUT, FAIL]
       [FAIL, TIMEOUT]

--- a/testing/web-platform/meta/event-timing/interactionid-press-key-no-effect.html.ini
+++ b/testing/web-platform/meta/event-timing/interactionid-press-key-no-effect.html.ini
@@ -1,14 +1,16 @@
 [interactionid-press-key-no-effect.html]
   expected:
+    if (os == "linux") and not debug and (processor == "x86_64") and fission: [TIMEOUT, OK]
     if (os == "linux") and not debug and (processor == "x86_64") and not fission: [TIMEOUT, OK]
-    if (os == "linux") and not debug and (processor == "x86_64") and fission: [TIMEOUT, OK]
+    if (os == "mac") and debug: [TIMEOUT, OK]
+    if (os == "linux") and debug: TIMEOUT
     if (os == "win") and not debug: OK
-    if (os == "linux") and debug: TIMEOUT
     [OK, TIMEOUT]
   [Event Timing: compare event timing interactionId for key press with no effect.]
     expected:
       if (os == "linux") and not debug and (processor == "x86_64") and not fission: [TIMEOUT, FAIL]
       if (os == "linux") and not debug and (processor == "x86_64") and fission: [TIMEOUT, FAIL]
-      if (os == "win") and not debug: FAIL
+      if (os == "mac") and debug: [TIMEOUT, FAIL]
       if (os == "linux") and debug: TIMEOUT
+      if (os == "win") and not debug: FAIL
       [FAIL, TIMEOUT]

--- a/testing/web-platform/meta/fetch/api/response/response-cancel-stream.any.js.ini
+++ b/testing/web-platform/meta/fetch/api/response/response-cancel-stream.any.js.ini
@@ -1,38 +1,34 @@
 [response-cancel-stream.any.sharedworker.html]
   expected:
     if os == "mac": [OK, ERROR, TIMEOUT]
   [Cancelling a closed Response stream]
     expected:
-      if (os == "mac") and not debug: [PASS, FAIL, TIMEOUT]
-      if (os == "mac") and debug: [FAIL, PASS, TIMEOUT]
+      if os == "mac": [PASS, FAIL, TIMEOUT]
 
 
 [response-cancel-stream.any.html]
   expected:
-    if (os == "mac") and debug: [OK, ERROR, TIMEOUT]
-    if (os == "mac") and not debug: [OK, TIMEOUT, ERROR]
+    if os == "mac": [OK, ERROR, TIMEOUT]
     if os == "win": [OK, ERROR]
   [Cancelling a closed Response stream]
     expected:
-      if (os == "mac") and not debug: [PASS, TIMEOUT, FAIL]
-      if (os == "mac") and debug: [PASS, FAIL, TIMEOUT]
+      if os == "mac": [PASS, FAIL, TIMEOUT]
 
 
 [response-cancel-stream.any.serviceworker.html]
   expected:
-    if os == "mac": [OK, TIMEOUT]
+    if (os == "mac") and debug: [OK, TIMEOUT]
+    if (os == "mac") and not debug: [OK, TIMEOUT]
   [Cancelling a closed Response stream]
     expected:
       if (os == "mac") and debug: [PASS, FAIL, TIMEOUT]
-      if (os == "mac") and not debug: [PASS, FAIL, TIMEOUT]
+      if (os == "mac") and not debug: [PASS, TIMEOUT, FAIL]
 
 
 [response-cancel-stream.any.worker.html]
   expected:
     if (os == "win") and not debug: [OK, ERROR]
-    if (os == "mac") and debug: [OK, ERROR, TIMEOUT]
-    if (os == "mac") and not debug: [OK, TIMEOUT, ERROR]
+    if os == "mac": [OK, ERROR, TIMEOUT]
   [Cancelling a closed Response stream]
     expected:
-      if (os == "mac") and not debug: [PASS, TIMEOUT, FAIL]
-      if (os == "mac") and debug: [PASS, FAIL, TIMEOUT]
+      if os == "mac": [PASS, FAIL, TIMEOUT]

--- a/testing/web-platform/meta/fetch/api/response/response-clone-iframe.window.js.ini
+++ b/testing/web-platform/meta/fetch/api/response/response-clone-iframe.window.js.ini
@@ -1,6 +1,6 @@
 [response-clone-iframe.window.html]
   expected:
-    if (os == "win") and not debug and (processor == "x86"): [ERROR, OK]
+    if (os == "win") and not debug and (processor == "x86"): [OK, ERROR]
     if (os == "win") and not debug and (processor == "x86_64"): [OK, ERROR]
     if (os == "win") and debug: [OK, ERROR]
     if os == "mac": [OK, ERROR]

--- a/testing/web-platform/meta/fetch/http-cache/304-update.any.js.ini
+++ b/testing/web-platform/meta/fetch/http-cache/304-update.any.js.ini
@@ -1,29 +1,31 @@
 [304-update.any.html]
   [HTTP cache updates stored headers from a Last-Modified 304]
-    expected:
-      if swgl and (os == "linux") and fission: [FAIL, PASS]
-      [PASS, FAIL]
+    expected: [PASS, FAIL]
 
 
 [304-update.any.worker.html]
   [HTTP cache updates stored headers from a Last-Modified 304]
     expected:
-      if (os == "linux") and (processor == "x86_64") and debug and not fission and swgl: [PASS, FAIL]
-      if (os == "linux") and (processor == "x86_64") and debug and fission and not swgl: [PASS, FAIL]
-      if (os == "linux") and (processor == "x86_64") and not debug and fission: [PASS, FAIL]
-      if (os == "win") and not debug: [PASS, FAIL]
-      if (os == "linux") and (processor == "x86"): [PASS, FAIL]
+      if (os == "linux") and debug and not fission and not swgl: PASS
+      if (os == "linux") and debug and fission and swgl: PASS
+      if (os == "android") and debug and swgl: PASS
+      if (os == "win") and debug: PASS
+      if os == "mac": PASS
+      [PASS, FAIL]
 
 
 [304-update.any.serviceworker.html]
   expected:
     if processor == "x86": [OK, TIMEOUT]
   [HTTP cache updates stored headers from a Last-Modified 304]
     expected: [PASS, FAIL]
 
   [Content-* header]
     expected:
       if processor == "x86": [PASS, TIMEOUT]
 
 
 [304-update.any.sharedworker.html]
+  [HTTP cache updates stored headers from a Last-Modified 304]
+    expected:
+      if (processor == "x86") and (os == "linux"): [PASS, FAIL]

--- a/testing/web-platform/meta/fetch/metadata/generated/audioworklet.https.sub.html.ini
+++ b/testing/web-platform/meta/fetch/metadata/generated/audioworklet.https.sub.html.ini
@@ -1,100 +1,100 @@
 [audioworklet.https.sub.html]
   expected:
-    if (os == "linux") and (processor == "x86_64") and debug and not fission and swgl: [OK, ERROR, TIMEOUT]
-    if (os == "linux") and (processor == "x86_64") and debug and not fission and not swgl: [TIMEOUT, OK, ERROR]
-    if (os == "linux") and (processor == "x86_64") and debug and fission: [TIMEOUT, ERROR]
-    if (os == "linux") and (processor == "x86_64") and not debug and not fission: [TIMEOUT, ERROR]
-    if (os == "linux") and (processor == "x86_64") and not debug and fission: [TIMEOUT, ERROR]
-    if (os == "linux") and (processor == "x86"): [ERROR, TIMEOUT]
+    if (os == "linux") and not debug and fission and (processor == "x86_64"): [TIMEOUT, ERROR]
+    if (os == "linux") and not debug and fission and (processor == "x86"): [ERROR, TIMEOUT]
+    if (os == "linux") and debug and not fission and not swgl: [TIMEOUT, OK, ERROR]
+    if (os == "linux") and debug and not fission and swgl: [TIMEOUT, OK, ERROR]
+    if (os == "linux") and not debug and not fission: [TIMEOUT, ERROR]
+    if (os == "linux") and debug and fission: [TIMEOUT, ERROR]
   [sec-fetch-site - Same-Origin -> Same-Site -> Same-Origin redirect]
     expected:
-      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT]
-      if (os == "linux") and not fission and debug: [PASS, TIMEOUT]
-      if (os == "linux") and fission: [PASS, TIMEOUT]
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, TIMEOUT]
+      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, TIMEOUT]
+      if (os == "linux") and not debug and (processor == "x86"): [PASS, TIMEOUT]
+      if (os == "linux") and debug: [PASS, TIMEOUT]
 
   [sec-fetch-site - Cross-Site -> Same Origin]
     expected:
-      if (os == "linux") and (processor == "x86_64") and not debug and not fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and not debug and fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and debug: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and debug: [PASS, NOTRUN]
 
   [sec-fetch-site - Cross-Site -> Same-Site]
     expected:
-      if (os == "linux") and (processor == "x86_64") and not debug and not fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and not debug and fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and debug: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and debug: [PASS, NOTRUN]
 
   [sec-fetch-site - Cross-Site -> Cross-Site]
     expected:
-      if (os == "linux") and (processor == "x86_64") and not debug and fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and not debug and not fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and debug: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and debug: [PASS, NOTRUN]
 
   [sec-fetch-site - Same-Origin -> Same Origin]
     expected:
       if (os == "linux") and not debug and fission and (processor == "x86"): [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and not debug and fission and (processor == "x86_64"): [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and not debug and not fission: [PASS, NOTRUN]
       if (os == "linux") and debug: [PASS, NOTRUN]
 
   [sec-fetch-site - Same-Origin -> Same-Site]
     expected:
-      if (os == "linux") and (processor == "x86_64") and not debug and fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and not debug and not fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and debug: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and debug: [PASS, NOTRUN]
 
   [sec-fetch-site - Same-Origin -> Cross-Site]
     expected:
-      if (os == "linux") and (processor == "x86_64") and not debug and not fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and not debug and fission: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86_64") and debug: [PASS, NOTRUN]
-      if (os == "linux") and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
+      if (os == "linux") and not debug and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and debug: [PASS, NOTRUN]
 
   [sec-fetch-site - Same-Site -> Same Origin]
     expected:
-      if (os == "linux") and fission and (processor == "x86_64") and debug: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and fission and (processor == "x86_64") and not debug: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and fission and not debug and (processor == "x86"): [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, NOTRUN]
       if (os == "linux") and not fission and not debug: [PASS, NOTRUN]
-      if (os == "linux") and fission and (processor == "x86"): [NOTRUN, PASS, TIMEOUT]
+      if (os == "linux") and fission and debug: [PASS, TIMEOUT, NOTRUN]
 
   [sec-fetch-site - Same-Site -> Same-Site]
     expected:
+      if (os == "linux") and not debug and fission and (processor == "x86"): [NOTRUN, TIMEOUT]
       if (os == "linux") and not debug and fission and (processor == "x86_64"): [NOTRUN, TIMEOUT]
-      if (os == "linux") and not debug and fission and (processor == "x86"): [NOTRUN, TIMEOUT]
-      if (os == "linux") and debug and not fission and swgl: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and debug and not fission and not swgl: [TIMEOUT, PASS, NOTRUN]
+      if (os == "linux") and debug and fission: [TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and not fission: [TIMEOUT, PASS, NOTRUN]
       if (os == "linux") and not debug and not fission: [TIMEOUT, NOTRUN]
-      if (os == "linux") and debug and fission: [TIMEOUT, NOTRUN]
 
   [sec-fetch-site - Same-Site -> Cross-Site]
     expected:
-      if (os == "linux") and debug and not fission and swgl: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and not fission and swgl: [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and debug and not fission and not swgl: [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and debug and fission: NOTRUN
       if (os == "linux") and not debug: NOTRUN
 
   [sec-fetch-mode]
     expected:
-      if (os == "linux") and debug and not fission and swgl: [PASS, NOTRUN]
       if (os == "linux") and debug and not fission and not swgl: [NOTRUN, PASS, TIMEOUT]
+      if (os == "linux") and debug and not fission and swgl: [NOTRUN, PASS]
       if (os == "linux") and debug and fission: NOTRUN
       if (os == "linux") and not debug: NOTRUN
 
   [sec-fetch-dest]
     expected:
-      if (os == "linux") and debug and not fission and swgl: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and debug and not fission and not swgl: [NOTRUN, PASS, TIMEOUT]
+      if (os == "linux") and debug and not fission and swgl: [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and debug and fission: NOTRUN
       if (os == "linux") and not debug: NOTRUN
 
   [sec-fetch-user]
     expected:
-      if (os == "linux") and debug and not fission and swgl: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and not fission and swgl: [NOTRUN, PASS, TIMEOUT]
       if (os == "linux") and debug and not fission and not swgl: [NOTRUN, PASS]
       if (os == "linux") and debug and fission: NOTRUN
       if (os == "linux") and not debug: NOTRUN

--- a/testing/web-platform/meta/fetch/metadata/generated/fetch-via-serviceworker.https.sub.html.ini
+++ b/testing/web-platform/meta/fetch/metadata/generated/fetch-via-serviceworker.https.sub.html.ini
@@ -1,53 +1,55 @@
 [fetch-via-serviceworker.https.sub.html]
   expected:
+    if (os == "linux") and fission and not debug and (processor == "x86_64"): [OK, TIMEOUT]
     if (os == "linux") and fission and not debug and (processor == "x86"): [OK, TIMEOUT]
-    if (os == "linux") and fission and not debug and (processor == "x86_64"): [OK, TIMEOUT]
     if (os == "linux") and fission and debug: [OK, TIMEOUT]
   [sec-fetch-mode - init: mode=no-cors - respondWith]
     expected:
       if (os == "linux") and fission: [PASS, TIMEOUT, NOTRUN]
 
   [sec-fetch-mode - init: mode=no-cors - fallback]
     expected:
       if (os == "linux") and fission: [PASS, TIMEOUT, NOTRUN]
 
   [sec-fetch-mode - init: mode=same-origin - respondWith]
     expected:
+      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission and debug: [PASS, NOTRUN]
-      if (os == "linux") and fission and not debug: [PASS, TIMEOUT, NOTRUN]
 
   [sec-fetch-mode - init: mode=same-origin - fallback]
     expected:
-      if (os == "linux") and fission and not debug: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, NOTRUN, TIMEOUT]
+      if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission and debug: [PASS, NOTRUN]
 
   [sec-fetch-dest - no init - respondWith]
     expected:
+      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission and debug: [PASS, NOTRUN]
 
   [sec-fetch-dest - no init - fallback]
     expected:
+      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission and debug: [PASS, TIMEOUT, NOTRUN]
 
   [sec-fetch-user - no init - respondWith]
     expected:
       if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and fission and debug: [PASS, NOTRUN]
 
   [sec-fetch-user - no init - fallback]
     expected:
+      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission and debug: [PASS, TIMEOUT, NOTRUN]
 
   [sec-fetch-mode - init: mode=cors - fallback]
     expected: [PASS, TIMEOUT, NOTRUN]
 
   [sec-fetch-site - Same-Site -> Same-Site, init: mode=no-cors - respondWith]
     expected: [PASS, TIMEOUT, NOTRUN]
 

--- a/testing/web-platform/meta/fetch/metadata/window-open.https.sub.html.ini
+++ b/testing/web-platform/meta/fetch/metadata/window-open.https.sub.html.ini
@@ -1,13 +1,15 @@
 [window-open.https.sub.html]
   expected:
-    if (os == "win") and not swgl and not debug and (processor == "x86_64"): [ERROR, OK]
-    if (os == "linux") and (processor == "x86"): [ERROR, OK]
-    if (os == "mac") and not debug: [ERROR, OK]
+    if (os == "linux") and swgl and fission: [ERROR, OK]
+    if (os == "linux") and not swgl and (processor == "x86"): [ERROR, OK]
+    if (os == "win") and not debug and (processor == "x86"): [ERROR, OK]
+    if (os == "win") and not debug and (processor == "x86_64"): [ERROR, OK]
+    if os == "mac": [ERROR, OK]
     [OK, ERROR]
   [Cross-site window, forced, reloaded]
     expected: [PASS, FAIL]
 
   [Same-site window, forced, reloaded]
     expected:
       if (os == "win") and debug and (processor == "x86_64"): PASS
       [PASS, FAIL]

--- a/testing/web-platform/meta/fetch/private-network-access/service-worker-background-fetch.https.window.js.ini
+++ b/testing/web-platform/meta/fetch/private-network-access/service-worker-background-fetch.https.window.js.ini
@@ -1,58 +1,63 @@
 [service-worker-background-fetch.https.window.html]
   expected:
-    if (os == "linux") and not swgl and (processor == "x86"): [OK, TIMEOUT]
-    if (os == "linux") and not swgl and (processor == "x86_64"): [OK, TIMEOUT]
+    if (os == "linux") and swgl and fission: [OK, TIMEOUT]
     if (os == "android") and debug and not swgl: [OK, TIMEOUT]
+    if (os == "linux") and not swgl: [OK, TIMEOUT]
   [local to local: success.]
     expected: FAIL
 
   [private to local: success.]
     expected: FAIL
 
   [private to private: success.]
     expected:
-      if (os == "linux") and debug and not fission and not swgl: [FAIL, TIMEOUT]
+      if not swgl and debug and (os == "linux") and not fission: [FAIL, TIMEOUT]
+      if swgl and (os == "linux") and fission: [FAIL, TIMEOUT]
       FAIL
 
   [public to local: success.]
     expected:
-      if (os == "linux") and debug and not fission and not swgl: [FAIL, NOTRUN]
+      if not swgl and debug and (os == "linux") and not fission: [FAIL, NOTRUN]
+      if swgl and (os == "linux") and fission: [FAIL, NOTRUN]
       FAIL
 
   [public to private: success.]
     expected:
-      if (os == "linux") and not fission and debug and not swgl: [FAIL, NOTRUN]
-      if (os == "linux") and fission and debug and not swgl: [FAIL, TIMEOUT]
-      if (os == "linux") and not fission and not debug: [FAIL, TIMEOUT]
+      if (os == "linux") and not swgl and not fission and debug: [FAIL, NOTRUN]
+      if (os == "linux") and not swgl and not fission and not debug: [FAIL, TIMEOUT]
+      if (os == "linux") and not swgl and fission and debug: [FAIL, TIMEOUT]
       if (os == "android") and debug and not swgl: [FAIL, TIMEOUT]
+      if (os == "linux") and swgl and fission: [FAIL, NOTRUN]
       FAIL
 
   [public to public: success.]
     expected:
-      if (os == "linux") and fission and debug and not swgl: [FAIL, NOTRUN]
+      if (os == "linux") and not swgl and fission and debug: [FAIL, NOTRUN]
+      if (os == "linux") and not swgl and not fission: [FAIL, NOTRUN]
+      if (os == "linux") and swgl and fission: [FAIL, NOTRUN]
       if (os == "android") and debug and not swgl: [FAIL, NOTRUN]
-      if (os == "linux") and not fission and not swgl: [FAIL, NOTRUN]
       FAIL
 
   [treat-as-public to local: success.]
     expected:
-      if (os == "linux") and fission and not debug and (processor == "x86"): [FAIL, TIMEOUT, NOTRUN]
-      if (os == "linux") and fission and not debug and (processor == "x86_64"): [FAIL, TIMEOUT]
-      if (os == "linux") and fission and debug and not swgl: [FAIL, TIMEOUT, NOTRUN]
+      if (os == "linux") and not swgl and fission and not debug and (processor == "x86"): [FAIL, TIMEOUT, NOTRUN]
+      if (os == "linux") and not swgl and fission and not debug and (processor == "x86_64"): [FAIL, TIMEOUT]
+      if (os == "linux") and not swgl and fission and debug: [FAIL, TIMEOUT, NOTRUN]
+      if (os == "linux") and swgl and fission: [FAIL, NOTRUN]
+      if (os == "linux") and not swgl and not fission: [FAIL, NOTRUN]
       if (os == "android") and debug and not swgl: [FAIL, NOTRUN]
-      if (os == "linux") and not fission and not swgl: [FAIL, NOTRUN]
       FAIL
 
   [treat-as-public to private: success.]
     expected:
-      if (os == "linux") and not swgl and (processor == "x86_64"): [FAIL, NOTRUN]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and swgl and fission: [FAIL, NOTRUN]
       if (os == "android") and debug and not swgl: [FAIL, NOTRUN]
+      if (os == "linux") and not swgl: [FAIL, NOTRUN]
       FAIL
 
   [treat-as-public to public: success.]
     expected:
+      if (os == "linux") and swgl and fission: [FAIL, NOTRUN]
       if (os == "android") and debug and not swgl: [FAIL, NOTRUN]
-      if (os == "linux") and not swgl and (processor == "x86_64"): [FAIL, NOTRUN]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and not swgl: [FAIL, NOTRUN]
       FAIL

--- a/testing/web-platform/meta/fetch/private-network-access/service-worker-fetch.https.window.js.ini
+++ b/testing/web-platform/meta/fetch/private-network-access/service-worker-fetch.https.window.js.ini
@@ -1,100 +1,114 @@
 [service-worker-fetch.https.window.html]
   expected:
+    if (os == "android") and debug and not swgl: [TIMEOUT, OK]
     if (os == "linux") and not swgl and (processor == "x86_64"): [TIMEOUT, OK]
-    if (os == "linux") and not swgl and (processor == "x86"): [OK, TIMEOUT]
-    if (os == "android") and debug and not swgl: [TIMEOUT, OK]
+    if (os == "linux") and not swgl and (processor == "x86"): [TIMEOUT, OK]
+    if (os == "linux") and swgl and fission: [TIMEOUT, OK]
     TIMEOUT
   [private to local: failed preflight.]
     expected:
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, TIMEOUT]
+      if (os == "linux") and swgl and fission: [TIMEOUT, FAIL]
+      if (os == "linux") and not swgl and (processor == "x86"): [TIMEOUT, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [TIMEOUT, FAIL]
       if (os == "android") and debug and not swgl: [TIMEOUT, FAIL, NOTRUN]
       TIMEOUT
 
   [private to local: success.]
     expected:
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
+      if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
-      if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
       NOTRUN
 
   [public to local: failed preflight.]
     expected:
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
-      if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       NOTRUN
 
   [public to local: success.]
     expected:
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
       NOTRUN
 
   [public to private: failed preflight.]
     expected:
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
       NOTRUN
 
   [public to private: success.]
     expected:
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
       NOTRUN
 
   [treat-as-public to local: failed preflight.]
     expected:
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
       NOTRUN
 
   [treat-as-public to local: success.]
     expected:
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       NOTRUN
 
   [treat-as-public to private: failed preflight.]
     expected:
+      if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
-      if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
       NOTRUN
 
   [treat-as-public to private: success.]
     expected:
       if (os == "android") and debug and not swgl: [NOTRUN, FAIL]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, FAIL]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, FAIL]
-      if (os == "linux") and not swgl and (processor == "x86"): [FAIL, NOTRUN]
+      if (os == "linux") and swgl and fission: [NOTRUN, FAIL]
       NOTRUN
 
   [private to private: success.]
     expected:
       if (os == "android") and debug and not swgl: [NOTRUN, PASS]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, PASS]
-      if (os == "linux") and not swgl and (processor == "x86"): [PASS, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and swgl and fission: [NOTRUN, PASS]
       NOTRUN
 
   [treat-as-public to public: success.]
     expected:
       if (os == "android") and debug and not swgl: [NOTRUN, PASS]
+      if (os == "linux") and swgl and fission: [NOTRUN, PASS]
       if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, PASS]
-      if (os == "linux") and not swgl and (processor == "x86"): [PASS, NOTRUN]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, PASS]
       NOTRUN
 
   [public to public: success.]
     expected:
+      if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, PASS]
+      if (os == "linux") and not swgl and (processor == "x86"): [NOTRUN, PASS]
+      if (os == "linux") and swgl and fission: [NOTRUN, PASS]
       if (os == "android") and debug and not swgl: [NOTRUN, PASS]
-      if (os == "linux") and not swgl and (processor == "x86"): [PASS, NOTRUN]
-      if (os == "linux") and not swgl and (processor == "x86_64"): [NOTRUN, PASS]
       NOTRUN
 
   [local to local: success.]
     expected:
       if (os == "android") and debug and not swgl: [PASS, TIMEOUT]

--- a/testing/web-platform/meta/focus/focus-already-focused-iframe-deep-different-site.html.ini
+++ b/testing/web-platform/meta/focus/focus-already-focused-iframe-deep-different-site.html.ini
@@ -1,5 +1,5 @@
 [focus-already-focused-iframe-deep-different-site.html]
   expected:
-    if (os == "win") and not debug and (processor == "x86"): [OK, TIMEOUT]
-    if (os == "win") and not debug and (processor == "x86_64"): [OK, TIMEOUT]
-    if os == "mac": [OK, TIMEOUT]
+    if (os == "mac") and not debug: [OK, TIMEOUT]
+    if (os == "mac") and debug: [OK, TIMEOUT]
+    if (os == "win") and not debug: [OK, TIMEOUT]

--- a/testing/web-platform/meta/focus/focus-already-focused-iframe-different-site.html.ini
+++ b/testing/web-platform/meta/focus/focus-already-focused-iframe-different-site.html.ini
@@ -1,8 +1,5 @@
 [focus-already-focused-iframe-different-site.html]
   expected:
-    if (os == "win") and not debug and (processor == "x86"): [TIMEOUT, OK]
-    if (os == "win") and not debug and (processor == "x86_64"): [OK, TIMEOUT]
-    if (os == "win") and debug: [OK, TIMEOUT]
-    if (os == "mac") and debug: [OK, TIMEOUT]
-    if (os == "mac") and not debug: [OK, TIMEOUT]
-    if (os == "linux") and not fission: [OK, TIMEOUT]
+    if (os == "linux") and fission: OK
+    if os == "android": OK
+    [OK, TIMEOUT]

--- a/testing/web-platform/meta/forced-colors-mode/forced-colors-mode-43.html.ini
+++ b/testing/web-platform/meta/forced-colors-mode/forced-colors-mode-43.html.ini
@@ -1,4 +1,5 @@
 [forced-colors-mode-43.html]
   expected:
+    if (os == "win") and not debug and (processor == "x86"): [FAIL, PASS]
     if os == "android": PASS
     [PASS, FAIL]

--- a/testing/web-platform/meta/forced-colors-mode/forced-colors-mode-45.html.ini
+++ b/testing/web-platform/meta/forced-colors-mode/forced-colors-mode-45.html.ini
@@ -1,4 +1,2 @@
 [forced-colors-mode-45.html]
-  expected:
-    if (processor == "x86") and debug: [FAIL, PASS]
-    [PASS, FAIL]
+  expected: [PASS, FAIL]

--- a/testing/web-platform/meta/html/anonymous-iframe/embedding.tentative.https.window.js.ini
+++ b/testing/web-platform/meta/html/anonymous-iframe/embedding.tentative.https.window.js.ini
@@ -1,9 +1,11 @@
 [embedding.tentative.https.window.html?3-4]
+  expected:
+    if (os == "android") and not debug: [OK, TIMEOUT]
   [COEP:require-corp parent embeds same-origin anonymous iframe]
     expected: FAIL
 
   [COEP:require-corp parent embeds cross-origin anonymous iframe]
     expected: FAIL
 
 
 [embedding.tentative.https.window.html?5-6]
@@ -12,16 +14,20 @@
   [COOP:same-origin + COEP:require-corp embeds same-origin anonymous iframe]
     expected: FAIL
 
   [COOP:same-origin + COEP:require-corp embeds cross-origin anonymous iframe]
     expected: FAIL
 
 
 [embedding.tentative.https.window.html?1-2]
+  [Parent embeds same-origin anonymous iframe]
+    expected:
+      if (os == "linux") and not fission and not debug: [PASS, FAIL]
+
 
 [embedding.tentative.https.window.html?9-10]
   [COOP:same-origin + COEP:credentialless embeds same-origin anonymous iframe]
     expected:
       if (os == "linux") and debug and fission and not swgl: [PASS, FAIL]
 
 
 [embedding.tentative.https.window.html?13-last]

--- a/testing/web-platform/meta/html/browsers/browsing-the-web/back-forward-cache/eligibility/broadcast-channel.html.ini
+++ b/testing/web-platform/meta/html/browsers/browsing-the-web/back-forward-cache/eligibility/broadcast-channel.html.ini
@@ -1,22 +1,22 @@
 [broadcast-channel.html]
   expected:
     if (os == "win") and not debug and ccov: OK
-    if (os == "linux") and (processor == "x86_64") and not debug and not fission: [OK, TIMEOUT]
-    if (os == "linux") and (processor == "x86_64") and not debug and fission: [OK, TIMEOUT]
-    if (os == "linux") and (processor == "x86_64") and debug: [OK, TIMEOUT]
+    if (os == "linux") and not debug and (processor == "x86_64") and fission: [OK, TIMEOUT]
+    if (os == "linux") and not debug and (processor == "x86_64") and not fission: [OK, TIMEOUT]
+    if (os == "linux") and not debug and (processor == "x86"): [TIMEOUT, OK]
+    if (os == "linux") and debug: [OK, TIMEOUT]
     if (os == "win") and not debug: TIMEOUT
     if (os == "mac") and not debug: TIMEOUT
-    if (os == "linux") and (processor == "x86"): [TIMEOUT, OK]
   [Eligibility (BroadcastChannel closed in the pagehide event)]
     expected:
       if (os == "win") and not debug and ccov: PASS
-      if (os == "linux") and (processor == "x86_64") and not debug and not fission: [PASS, TIMEOUT]
-      if (os == "linux") and (processor == "x86_64") and not debug and fission: [PASS, TIMEOUT]
-      if (os == "linux") and (processor == "x86_64") and debug: [PASS, TIMEOUT]
-      if (os == "linux") and (processor == "x86"): [TIMEOUT, PASS]
+      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, TIMEOUT]
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, TIMEOUT]
+      if (os == "linux") and not debug and (processor == "x86"): [TIMEOUT, PASS]
+      if (os == "win") and not debug: TIMEOUT
       if (os == "mac") and not debug: [TIMEOUT, NOTRUN]
-      if (os == "win") and not debug: TIMEOUT
+      if (os == "linux") and debug: [PASS, TIMEOUT]
 
   [Eligibility (BroadcastChannel)]
     expected:
       if (os == "mac") and not debug: [PASS, TIMEOUT]

--- a/testing/web-platform/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/initial-content-replacement.html.ini
+++ b/testing/web-platform/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/initial-content-replacement.html.ini
@@ -1,34 +1,35 @@
 [initial-content-replacement.html]
   [Content synchronously added to <iframe> with no src won't get replaced]
     expected:
       if (os == "linux") and debug: [FAIL, PASS]
       FAIL
 
   [Content synchronously added to <iframe> with src='' won't get replaced]
     expected:
+      if (os == "linux") and debug and not fission: [FAIL, PASS]
       if (os == "win") and not debug and (processor == "x86_64"): [FAIL, PASS]
-      if (os == "linux") and not fission and debug: [FAIL, PASS]
       FAIL
 
   [Content synchronously added to <iframe> with src='about:blank' won't get replaced]
     expected:
       if (os == "win") and not debug and (processor == "x86_64"): [FAIL, PASS]
       FAIL
 
   [Content synchronously added to <iframe> with src='about:blank#foo' won't get replaced]
     expected:
-      if fission and (processor == "x86_64") and (os == "win") and not debug: [FAIL, PASS]
-      if fission and (processor == "x86_64") and (os == "linux") and debug: [FAIL, PASS]
+      if (os == "linux") and debug and fission and swgl: [FAIL, PASS]
+      if (os == "linux") and debug and fission and not swgl: [FAIL, PASS]
+      if (os == "win") and not debug and (processor == "x86_64"): [FAIL, PASS]
       FAIL
 
   [Content synchronously added to <iframe> with src='about:blank?foo' won't get replaced]
     expected:
-      if (os == "linux") and not fission and debug and not swgl: [FAIL, PASS]
+      if (os == "linux") and debug and not fission and not swgl: [FAIL, PASS]
       if (os == "win") and not debug and (processor == "x86_64"): [FAIL, PASS]
       FAIL
 
   [Content synchronously added to window.open('about:blank')-ed document won't get replaced]
     expected:
       if (os == "linux") and not fission and not swgl: [FAIL, PASS]
       FAIL
 

--- a/testing/web-platform/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/load-pageshow-events-window-open.html.ini
+++ b/testing/web-platform/meta/html/browsers/browsing-the-web/navigating-across-documents/initial-empty-document/load-pageshow-events-window-open.html.ini
@@ -1,11 +1,10 @@
 [load-pageshow-events-window-open.html]
   [load event does not fire on window.open('about:blank')]
     expected:
+      if (os == "linux") and fission and not debug and (processor == "x86"): [FAIL, PASS]
       if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, FAIL]
-      if (os == "linux") and fission and not debug and (processor == "x86"): [FAIL, PASS]
-      if (os == "linux") and not fission and debug and not swgl: [PASS, FAIL]
-      if (os == "linux") and not fission and debug and swgl: [FAIL, PASS]
       if (os == "linux") and fission and debug: [FAIL, PASS]
+      if (os == "linux") and not fission and debug: [PASS, FAIL]
       if (os == "linux") and not fission and not debug: [FAIL, PASS]
       if (os == "win") and swgl: [FAIL, PASS]
       FAIL

--- a/testing/web-platform/meta/html/browsers/browsing-the-web/overlapping-navigations-and-traversals/tentative/cross-document-nav-same-document-traversal.html.ini
+++ b/testing/web-platform/meta/html/browsers/browsing-the-web/overlapping-navigations-and-traversals/tentative/cross-document-nav-same-document-traversal.html.ini
@@ -1,6 +1,7 @@
 [cross-document-nav-same-document-traversal.html]
   [cross-document navigations are stopped by same-document back()]
     expected:
+      if (os == "linux") and debug and not swgl and not fission: [PASS, FAIL]
       if (os == "mac") and not debug: FAIL
       if (os == "win") and not debug: FAIL
       [FAIL, PASS]

--- a/testing/web-platform/meta/html/browsers/history/the-history-interface/005.html.ini
+++ b/testing/web-platform/meta/html/browsers/history/the-history-interface/005.html.ini
@@ -1,17 +1,17 @@
 [005.html]
   [<body onpopstate="..."> should register a listener for the popstate event]
     bug:
       if fission and (os == "linux"): https://bugzilla.mozilla.org/show_bug.cgi?id=1668853
       if fission and (os == "win") and debug: https://bugzilla.mozilla.org/show_bug.cgi?id=1668853
     expected:
+      if fission and not debug and (os == "linux") and (processor == "x86_64"): [PASS, FAIL]
       if fission and not debug and (os == "linux") and (processor == "x86"): [PASS, FAIL]
-      if fission and not debug and (os == "linux") and (processor == "x86_64"): [PASS, FAIL]
       if fission and debug: [PASS, FAIL]
 
   [window.onpopstate should register a listener for the popstate event]
     bug:
       if fission and debug: https://bugzilla.mozilla.org/show_bug.cgi?id=1692852
     expected:
+      if fission and (os == "mac") and debug: [PASS, FAIL]
       if fission and (os == "win") and debug: [PASS, FAIL]
-      if fission and (os == "mac") and debug: [PASS, FAIL]
       if fission and (os == "linux"): [PASS, FAIL]

--- a/testing/web-platform/meta/html/browsers/history/the-history-interface/traverse-during-unload.html.ini
+++ b/testing/web-platform/meta/html/browsers/history/the-history-interface/traverse-during-unload.html.ini
@@ -1,8 +1,9 @@
 [traverse-during-unload.html]
   [Traversing the history during unload]
     expected:
-      if (os == "linux") and fission and (processor == "x86"): [FAIL, PASS]
-      if (os == "linux") and fission and (processor == "x86_64"): [PASS, FAIL]
+      if (os == "linux") and fission and not debug and (processor == "x86_64"): [PASS, FAIL]
+      if (os == "linux") and fission and not debug and (processor == "x86"): [PASS, FAIL]
+      if (os == "linux") and fission and debug: [PASS, FAIL]
+      if os == "win": PASS
       if os == "mac": PASS
-      if os == "win": PASS
       FAIL

--- a/testing/web-platform/meta/html/browsers/the-window-object/open-close/open-features-is-popup-condition.html.ini
+++ b/testing/web-platform/meta/html/browsers/the-window-object/open-close/open-features-is-popup-condition.html.ini
@@ -1,25 +1,27 @@
 [open-features-is-popup-condition.html?single-2]
   expected:
-    if (os == "linux") and fission and (processor == "x86"): [OK, CRASH]
-    if (os == "linux") and not fission: [OK, TIMEOUT]
+    if (os == "linux") and not fission and debug: [OK, TIMEOUT]
+    if (os == "linux") and not fission and not debug: [OK, TIMEOUT]
+    if (os == "linux") and fission and (processor == "x86"): [CRASH, OK]
   ["personalbar=true" should set BarProp visibility to false]
     expected:
       if (os == "linux") and not fission: [PASS, TIMEOUT]
 
   ["personalbar=no" should set BarProp visibility to false]
     expected:
-      if (os == "linux") and not fission: [PASS, TIMEOUT]
+      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT]
+      if (os == "linux") and not fission and debug: [PASS, TIMEOUT]
 
 
 [open-features-is-popup-condition.html?single-1]
   expected:
     if (os == "linux") and (processor == "x86_64") and not fission and not debug: [OK, TIMEOUT]
-    if (os == "linux") and (processor == "x86"): [CRASH, OK]
+    if (os == "linux") and (processor == "x86"): [OK, CRASH]
   ["resizable=no" should set BarProp visibility to false]
     expected:
       if (os == "linux") and not fission and not debug: [PASS, TIMEOUT]
 
 
 [open-features-is-popup-condition.html?combination]
 
 [open-features-is-popup-condition.html?position]

--- a/testing/web-platform/meta/html/browsers/the-window-object/open-close/open-features-tokenization-noreferrer.html.ini
+++ b/testing/web-platform/meta/html/browsers/the-window-object/open-close/open-features-tokenization-noreferrer.html.ini
@@ -1,5 +1,5 @@
 [open-features-tokenization-noreferrer.html]
   expected:
-    if (os == "android") and debug and swgl: [OK, TIMEOUT, CRASH]
-    if (os == "android") and debug and not swgl: [TIMEOUT, OK, CRASH]
+    if (os == "android") and debug and not swgl: [OK, TIMEOUT, CRASH]
+    if (os == "android") and debug and swgl: [TIMEOUT, OK, CRASH]
     if (os == "android") and not debug: [OK, CRASH, TIMEOUT]

--- a/testing/web-platform/meta/html/browsers/the-window-object/open-close/open-features-tokenization-screenx-screeny.html.ini
+++ b/testing/web-platform/meta/html/browsers/the-window-object/open-close/open-features-tokenization-screenx-screeny.html.ini
@@ -1,13 +1,13 @@
 [open-features-tokenization-screenx-screeny.html]
   expected:
-    if (os == "android") and debug and swgl: [TIMEOUT, OK, CRASH]
-    if (os == "android") and debug and not swgl: [OK, TIMEOUT, CRASH]
-    if (os == "android") and not debug: [OK, TIMEOUT, CRASH]
+    if (os == "android") and not swgl and debug: [OK, TIMEOUT, CRASH]
+    if (os == "android") and not swgl and not debug: [OK, CRASH, TIMEOUT]
+    if (os == "android") and swgl: [OK, TIMEOUT, CRASH]
   ["screenx=141" should set left position of opened window]
     expected:
       if os == "android": FAIL
 
   [" screenx = 141" should set left position of opened window]
     expected:
       if os == "android": FAIL
 

--- a/testing/web-platform/meta/html/browsers/the-window-object/window-open-popup-behavior.html.ini
+++ b/testing/web-platform/meta/html/browsers/the-window-object/window-open-popup-behavior.html.ini
@@ -1,40 +1,39 @@
 [window-open-popup-behavior.html]
   expected:
-    if (os == "linux") and not debug and (processor == "x86_64") and fission: [TIMEOUT, OK]
-    if (os == "linux") and not debug and (processor == "x86_64") and not fission: [OK, TIMEOUT]
-    if (os == "linux") and not debug and (processor == "x86"): [OK, TIMEOUT]
-    if (os == "linux") and debug: [OK, TIMEOUT]
+    if (os == "linux") and not fission and debug: [OK, TIMEOUT]
+    if (os == "linux") and not fission and not debug: [OK, TIMEOUT]
+    if (os == "linux") and fission: [OK, TIMEOUT]
   [location=yes,toolbar=yes,status=yes (expect popup)]
     expected:
+      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission: [PASS, TIMEOUT, NOTRUN]
 
   [location=yes,toolbar=yes,status=yes,noopener (expect tab)]
     expected:
       if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [location=yes,toolbar=yes,status=yes,noreferrer (expect tab)]
     expected:
+      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [location=yes,toolbar=yes,status=yes,popup (expect popup)]
     expected:
+      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission: [PASS, TIMEOUT, NOTRUN]
 
   [location=yes,toolbar=yes,status=yes,noopener,noreferrer,popup (expect tab)]
     expected:
       if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
@@ -51,158 +50,151 @@
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [location=yes,toolbar=yes,menubar=yes,noreferrer (expect tab)]
     expected:
-      if (os == "linux") and fission and not debug and (processor == "x86_64"): [FAIL, TIMEOUT, PASS, NOTRUN]
-      if (os == "linux") and fission and not debug and (processor == "x86"): [FAIL, PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and fission and debug: [FAIL, PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and not fission: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not debug and not fission: [PASS, NOTRUN, TIMEOUT]
+      if (os == "linux") and not debug and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [location=yes,toolbar=yes,menubar=yes,popup (expect popup)]
     expected:
-      if (os == "linux") and not debug and (processor == "x86_64") and fission: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and not debug and (processor == "x86"): [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not debug and not fission: [PASS, NOTRUN, TIMEOUT]
+      if (os == "linux") and not debug and fission: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and debug: [PASS, TIMEOUT, NOTRUN]
 
   [location=yes,toolbar=yes,menubar=yes,noopener,noreferrer,popup (expect tab)]
     expected:
-      if (os == "linux") and fission and not debug and (processor == "x86_64"): [NOTRUN, FAIL, PASS, TIMEOUT]
-      if (os == "linux") and fission and not debug and (processor == "x86"): [FAIL, PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and fission and debug: [FAIL, PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not debug and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not debug and not fission: [PASS, NOTRUN, TIMEOUT]
+      if (os == "linux") and debug and not fission: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [location=yes,toolbar=yes,menubar=yes,resizable=yes,scrollbars=yes,status=yes (expect tab)]
     expected:
-      if (os == "linux") and not debug and (processor == "x86_64") and fission: [NOTRUN, PASS, TIMEOUT]
-      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN, TIMEOUT]
-      if (os == "linux") and not debug and (processor == "x86"): [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not debug and fission: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not debug and not fission: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and debug: [PASS, TIMEOUT, NOTRUN]
 
   [location=yes,toolbar=yes,menubar=yes,resizable=yes,scrollbars=yes,status=yes,noopener (expect tab)]
     expected:
-      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
-      if (os == "linux") and not debug and (processor == "x86_64") and fission: [NOTRUN, PASS]
-      if (os == "linux") and not debug and (processor == "x86"): [PASS, NOTRUN]
-      if (os == "linux") and debug: [PASS, NOTRUN]
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN]
+      if (os == "linux") and not fission and debug: [PASS, NOTRUN]
+      if (os == "linux") and fission: [PASS, NOTRUN]
 
   [location=yes,toolbar=yes,menubar=yes,resizable=yes,scrollbars=yes,status=yes,noreferrer (expect tab)]
     expected:
-      if (os == "linux") and not debug and (processor == "x86_64") and fission: [NOTRUN, PASS]
-      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
-      if (os == "linux") and not debug and (processor == "x86"): [PASS, NOTRUN]
-      if (os == "linux") and debug: [PASS, NOTRUN]
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN]
+      if (os == "linux") and not fission and debug: [PASS, NOTRUN]
+      if (os == "linux") and fission: [PASS, NOTRUN]
 
   [location=yes,toolbar=yes,menubar=yes,resizable=yes,scrollbars=yes,status=yes,popup (expect popup)]
     expected:
-      if (os == "linux") and not debug and (processor == "x86_64") and fission: [NOTRUN, PASS]
-      if (os == "linux") and not debug and (processor == "x86_64") and not fission: [PASS, NOTRUN]
-      if (os == "linux") and not debug and (processor == "x86"): [PASS, NOTRUN]
-      if (os == "linux") and debug: [PASS, NOTRUN]
+      if (os == "linux") and not fission and debug: [PASS, NOTRUN]
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN]
+      if (os == "linux") and fission: [PASS, NOTRUN]
 
   [location=yes,toolbar=yes,menubar=yes,resizable=yes,scrollbars=yes,status=yes,noopener,noreferrer,popup (expect tab)]
     expected:
-      if (os == "linux") and fission and not debug and (processor == "x86"): [FAIL, PASS, NOTRUN]
-      if (os == "linux") and fission and not debug and (processor == "x86_64"): [NOTRUN, FAIL, PASS]
-      if (os == "linux") and fission and debug: [FAIL, PASS, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, FAIL, TIMEOUT]
-      if (os == "linux") and not fission and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and not fission: [PASS, FAIL, TIMEOUT, NOTRUN]
+      if (os == "linux") and debug and fission: [FAIL, PASS, NOTRUN]
+      if (os == "linux") and not debug and not fission: [PASS, NOTRUN, FAIL, TIMEOUT]
+      if (os == "linux") and not debug and fission: [FAIL, PASS, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [toolbar=yes,menubar=yes,resizable=yes,noopener (expect tab)]
     expected:
+      if not fission and (os == "linux") and not debug: [PASS, TIMEOUT]
       if not fission and (os == "linux") and debug: PASS
-      if not fission and (os == "linux") and not debug: [PASS, TIMEOUT]
       if not fission and (os == "android"): PASS
       FAIL
 
   [toolbar=yes,menubar=yes,resizable=yes,noopener,noreferrer,popup (expect tab)]
     expected:
       if (os == "linux") and not fission: [PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [resizable=yes,scrollbars=yes,status=yes,noreferrer (expect tab)]
     expected:
       if not fission: PASS
       FAIL
 
   [location=yes,menubar=yes,scrollbars=yes,noreferrer (expect tab)]
     expected:
-      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and fission: [FAIL, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [toolbar=yes,resizable=yes,status=yes,noopener (expect tab)]
     expected:
       if not fission: PASS
       FAIL
 
   [resizable=yes,scrollbars=yes,status=yes,noopener,noreferrer,popup (expect tab)]
     expected:
       if not fission: PASS
       FAIL
 
   [location=yes,scrollbars=yes,status=yes,noreferrer (expect tab)]
     expected:
-      if (os == "linux") and not fission: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [location=yes,scrollbars=yes,status=yes,popup (expect popup)]
     expected:
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT, NOTRUN]
 
   [location=yes,menubar=yes,scrollbars=yes (expect popup)]
     expected:
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT, NOTRUN]
 
   [location=yes,scrollbars=yes,status=yes,noopener,noreferrer,popup (expect tab)]
     expected:
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [toolbar=yes,resizable=yes,status=yes,noreferrer (expect tab)]
     expected:
       if not fission: PASS
       FAIL
 
   [,noopener,noreferrer,popup (expect tab)]
     expected:
       if not fission: PASS
       FAIL
 
   [location=yes,menubar=yes,scrollbars=yes,popup (expect popup)]
     expected:
-      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and fission: [PASS, TIMEOUT, NOTRUN]
 
   [location=yes,menubar=yes,scrollbars=yes,noopener,noreferrer,popup (expect tab)]
     expected:
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, FAIL, TIMEOUT]
       if (os == "linux") and not fission and debug: [PASS, FAIL, TIMEOUT, NOTRUN]
-      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, FAIL, TIMEOUT]
       if (os == "linux") and fission: [FAIL, PASS, TIMEOUT, NOTRUN]
       if os == "android": PASS
       FAIL
 
   [toolbar=yes,menubar=yes,resizable=yes,noreferrer (expect tab)]
     expected:
       if not fission and (os == "linux") and debug: PASS
       if not fission and (os == "linux") and not debug: [PASS, NOTRUN]
@@ -227,18 +219,18 @@
 
   [menubar=yes,resizable=yes,scrollbars=yes,noopener (expect tab)]
     expected:
       if not fission: PASS
       FAIL
 
   [location=yes,menubar=yes,scrollbars=yes,noopener (expect tab)]
     expected:
-      if (os == "linux") and not fission and not debug: [PASS, TIMEOUT, NOTRUN]
       if (os == "linux") and not fission and debug: [PASS, TIMEOUT, NOTRUN]
+      if (os == "linux") and not fission and not debug: [PASS, NOTRUN, TIMEOUT]
       if (os == "linux") and fission: [FAIL, TIMEOUT]
       if os == "android": PASS
       FAIL
 
   [menubar=yes,resizable=yes,scrollbars=yes,noreferrer (expect tab)]
     expected:
       if not fission: PASS
       FAIL

--- a/testing/web-platform/meta/html/browsers/windows/iframe-cross-origin-print.sub.html.ini
+++ b/testing/web-platform/meta/html/browsers/windows/iframe-cross-origin-print.sub.html.ini
@@ -1,9 +1,9 @@
 [iframe-cross-origin-print.sub.html]
   expected:
     if fission and (os == "win") and ccov and fission: [PASS, FAIL]
-    if (os == "linux") and fission and debug and not swgl: [ERROR, PASS, FAIL]
+    if (os == "linux") and fission and debug and not swgl: [PASS, FAIL, ERROR]
     if (os == "linux") and fission and debug and swgl: [PASS, FAIL, ERROR]
+    if (os == "linux") and fission and not debug: [PASS, FAIL, ERROR]
+    if (os == "win") and not debug and (processor == "x86"): [PASS, FAIL]
     if (os == "win") and not debug and (processor == "x86_64"): [PASS, FAIL, CRASH]
-    if (os == "win") and not debug and (processor == "x86"): [PASS, FAIL]
-    if (os == "linux") and fission and not debug: [PASS, FAIL, ERROR]
     if (os == "win") and debug: [PASS, FAIL]

--- a/testing/web-platform/meta/html/canvas/element/drawing-text-to-the-canvas/2d.text.draw.fontface.notinpage.html.ini
+++ b/testing/web-platform/meta/html/canvas/element/drawing-text-to-the-canvas/2d.text.draw.fontface.notinpage.html.ini
@@ -1,6 +1,6 @@
 [2d.text.draw.fontface.notinpage.html]
   [@font-face fonts should work even if they are not used in the page]
     expected:
-      if (os == "linux") and debug and not fission and swgl: [FAIL, PASS]
+      if (os == "linux") and debug and not fission: [FAIL, PASS]
       if os == "android": [FAIL, PASS]
       [PASS, FAIL]

--- a/testing/web-platform/meta/html/canvas/offscreen/drawing-images-to-the-canvas/2d.drawImage.animated.poster.html.ini
+++ b/testing/web-platform/meta/html/canvas/offscreen/drawing-images-to-the-canvas/2d.drawImage.animated.poster.html.ini
@@ -1,10 +1,9 @@
 [2d.drawImage.animated.poster.html]
   disabled:
     if (os == "mac") and (os_version == "10.15"): https://bugzilla.mozilla.org/show_bug.cgi?id=1753364
     if win10_2004 and debug: https://bugzilla.mozilla.org/show_bug.cgi?id=1753364
   expected:
-    if (os == "linux") and not swgl and fission and debug: [ERROR, OK]
-    if (os == "linux") and not swgl and not fission: [ERROR, OK]
+    if (os == "linux") and debug and fission and swgl: [ERROR, OK]
     if (os == "android") and not debug: OK
     if (os == "win") and (processor == "x86_64"): OK
     [OK, ERROR]

--- a/testing/web-platform/meta/html/canvas/offscreen/fill-and-stroke-styles/2d.pattern.paint.repeat.basic.html.ini
+++ b/testing/web-platform/meta/html/canvas/offscreen/fill-and-stroke-styles/2d.pattern.paint.repeat.basic.html.ini
@@ -1,9 +1,10 @@
 [2d.pattern.paint.repeat.basic.html]
   disabled:
     if (os == "mac") and (os_version == "10.15"): https://bugzilla.mozilla.org/show_bug.cgi?id=1753270
     if win10_2004: https://bugzilla.mozilla.org/show_bug.cgi?id=1753270
   expected:
-    if (os == "linux") and fission and debug and swgl: [ERROR, OK]
-    if (os == "linux") and fission and debug and not swgl: [ERROR, OK]
+    if (os == "linux") and not swgl and not debug and fission and (processor == "x86"): [OK, ERROR]
+    if (os == "linux") and not swgl and not debug and not fission: [OK, ERROR]
     if (os == "android") and not debug: OK
-    [OK, ERROR]
+    if (os == "android") and debug: [OK, ERROR]
+    [ERROR, OK]

--- a/testing/web-platform/meta/html/canvas/offscreen/fill-and-stroke-styles/2d.pattern.paint.repeat.outside.html.ini
+++ b/testing/web-platform/meta/html/canvas/offscreen/fill-and-stroke-styles/2d.pattern.paint.repeat.outside.html.ini
@@ -1,8 +1,8 @@
 [2d.pattern.paint.repeat.outside.html]
   disabled:
     if (os == "mac") and (os_version == "10.15"): https://bugzilla.mozilla.org/show_bug.cgi?id=1753270
     if win10_2004: https://bugzilla.mozilla.org/show_bug.cgi?id=1753270
   expected:
-    if debug and fission and swgl: [ERROR, OK]
-    if not debug and (os == "android"): OK
+    if (os == "android") and debug and swgl: [ERROR, OK]
+    if (os == "android") and not debug: OK
     [OK, ERROR]

--- a/testing/web-platform/meta/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext.html.ini
+++ b/testing/web-platform/meta/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.getcontext.html.ini
@@ -1,13 +1,15 @@
 [offscreencanvas.getcontext.html]
+  expected:
+    if (os == "linux") and not debug and fission: [OK, CRASH]
   [Test that getContext with supported string returns correct results]
     expected:
+      if (os == "linux") and (processor == "x86"): FAIL
       if os == "win": FAIL
-      if (processor == "x86") and (os == "linux"): FAIL
 
   [Test that webglcontext.canvas should return the original OffscreenCanvas]
     expected:
       if (processor == "x86") and (os == "linux"): FAIL
 
   [Test that getContext twice with different context type returns null the second time]
     expected:
       if (processor == "x86") and (os == "linux"): FAIL

--- a/testing/web-platform/meta/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.resize.html.ini
+++ b/testing/web-platform/meta/html/canvas/offscreen/manual/the-offscreen-canvas/offscreencanvas.resize.html.ini
@@ -4,17 +4,21 @@
 
   [Verify that resizing an OffscreenCanvas with a 2d context propagates the new size to its placeholder canvas asynchronously.]
     expected:
       if os == "android": PASS
       FAIL
 
   [Verify that resizing an OffscreenCanvas with a webgl context propagates the new size to its placeholder canvas asynchronously.]
     expected:
-      if (processor == "x86") and (os == "linux"): FAIL
+      if (os == "linux") and (processor == "x86_64") and not fission and not debug: [PASS, FAIL]
+      if (os == "linux") and (processor == "x86"): FAIL
+      if (os == "android") and not debug: [PASS, FAIL]
+
+  [Verify that drawImage uses the size of the frame as the intinsic size of a placeholder canvas.]
+    expected:
+      if not debug and (os == "linux") and fission: [PASS, FAIL]
+      if not debug and (os == "linux") and not fission: [PASS, FAIL]
+      if not debug and (os == "android"): [PASS, FAIL]
 
   [Verify that writing to the width and height attributes of an OffscreenCanvas works when there is a webgl context attached.]
     expected:
       if (processor == "x86") and (os == "linux"): FAIL
-
-  [Verify that drawImage uses the size of the frame as the intinsic size of a placeholder canvas.]
-    expected:
-      if (os == "linux") and not debug and fission and (processor == "x86_64"): [PASS, FAIL]

--- a/testing/web-platform/meta/html/cross-origin-opener-policy/iframe-popup-same-origin-to-same-origin.https.html.ini
+++ b/testing/web-platform/meta/html/cross-origin-opener-policy/iframe-popup-same-origin-to-same-origin.https.html.ini
@@ -1,79 +1,79 @@
 [iframe-popup-same-origin-to-same-origin.https.html]
   prefs: [network.cookie.cookieBehavior:4]
   expected:
     if (os == "win") and debug and (processor == "x86_64") and not swgl: [OK, TIMEOUT]
     if (os == "linux") and debug and fission and not swgl: [OK, TIMEOUT]
+    if (os == "android") and debug: [OK, TIMEOUT, CRASH]
     if (os == "android") and not debug: [OK, TIMEOUT]
-    if (os == "android") and debug: [OK, TIMEOUT, CRASH]
     if os == "mac": [OK, TIMEOUT]
   [same-origin with CROSS_ORIGIN iframe opening popup via form_POST a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
-      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with CROSS_ORIGIN iframe opening popup via window_open a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
-      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_SITE iframe opening popup via anchor a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_SITE iframe opening popup via form_GET a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
-      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_SITE iframe opening popup via form_POST a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
-      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with CROSS_ORIGIN iframe opening popup via anchor a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_ORIGIN iframe opening popup via window_open a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_ORIGIN iframe opening popup via form_GET a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
-      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_ORIGIN iframe opening popup via anchor a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
-      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with CROSS_ORIGIN iframe opening popup via form_GET a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_SITE iframe opening popup via window_open a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
-      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_ORIGIN iframe opening popup via form_POST a CROSS_ORIGIN with COOP: "same-origin"]
     expected:
+      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
-      if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]

--- a/testing/web-platform/meta/html/cross-origin-opener-policy/iframe-popup-same-origin-to-unsafe-none.https.html.ini
+++ b/testing/web-platform/meta/html/cross-origin-opener-policy/iframe-popup-same-origin-to-unsafe-none.https.html.ini
@@ -1,29 +1,29 @@
 [iframe-popup-same-origin-to-unsafe-none.https.html]
   prefs: [network.cookie.cookieBehavior:4]
   expected:
     if (os == "win") and debug and (processor == "x86_64") and swgl: OK
+    if (os == "android") and not swgl and debug: [OK, TIMEOUT, CRASH]
     if (os == "android") and not swgl and not debug: [OK, TIMEOUT, CRASH]
-    if (os == "android") and not swgl and debug: [OK, TIMEOUT, CRASH]
+    if (os == "win") and debug and (processor == "x86"): OK
     if (os == "linux") and fission and swgl: OK
-    if (os == "win") and debug and (processor == "x86"): OK
+    if (os == "win") and not debug: OK
     if (os == "linux") and not fission: OK
-    if (os == "win") and not debug: OK
     [OK, TIMEOUT]
   [same-origin with SAME_SITE iframe opening popup via window_open a CROSS_ORIGIN with COOP: ""]
     expected:
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_SITE iframe opening popup via anchor a CROSS_ORIGIN with COOP: ""]
     expected:
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
-      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with CROSS_ORIGIN iframe opening popup via window_open a CROSS_ORIGIN with COOP: ""]
     expected:
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
@@ -48,30 +48,30 @@
   [same-origin with CROSS_ORIGIN iframe opening popup via anchor a CROSS_ORIGIN with COOP: ""]
     expected:
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_ORIGIN iframe opening popup via anchor a CROSS_ORIGIN with COOP: ""]
     expected:
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
-      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with CROSS_ORIGIN iframe opening popup via form_GET a CROSS_ORIGIN with COOP: ""]
     expected:
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_SITE iframe opening popup via form_GET a CROSS_ORIGIN with COOP: ""]
     expected:
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
-      if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 
   [same-origin with SAME_ORIGIN iframe opening popup via form_POST a CROSS_ORIGIN with COOP: ""]
     expected:
       if (os == "win") and debug and (processor == "x86_64") and not swgl: [PASS, TIMEOUT]
       if (os == "linux") and debug and fission and not swgl: [PASS, TIMEOUT]
       if os == "mac": [PASS, TIMEOUT]
 

--- a/testing/web-platform/meta/html/cross-origin-opener-policy/popup-coop-by-sw.https.html.ini
+++ b/testing/web-platform/meta/html/cross-origin-opener-policy/popup-coop-by-sw.https.html.ini
@@ -1,11 +1,11 @@
 [popup-coop-by-sw.https.html?1-4]
   expected:
-    if debug and (os == "linux") and not fission and swgl: [CRASH, TIMEOUT]
+    if debug and (os == "linux") and not fission and swgl: [TIMEOUT, CRASH]
     if debug and (os == "linux") and not fission and not swgl: [TIMEOUT, CRASH]
     if debug and (os == "linux") and fission: [CRASH, TIMEOUT]
     if debug and (os == "win") and (processor == "x86"): [TIMEOUT, CRASH]
     if debug and (os == "win") and (processor == "x86_64"): [CRASH, TIMEOUT]
     TIMEOUT
   [opener:basic, openee:basic, sw:basic]
     expected: TIMEOUT
 
@@ -16,21 +16,20 @@
     expected: NOTRUN
 
   [opener:basic, openee:coi, sw:coi]
     expected: NOTRUN
 
 
 [popup-coop-by-sw.https.html?5-last]
   expected:
-    if debug and (os == "linux") and not fission and not swgl: [TIMEOUT, CRASH]
-    if debug and (os == "linux") and not fission and swgl: [TIMEOUT, CRASH]
+    if debug and (os == "linux") and fission: [CRASH, TIMEOUT]
+    if debug and (os == "linux") and not fission: [TIMEOUT, CRASH]
     if debug and (os == "win") and (processor == "x86"): [TIMEOUT, CRASH]
     if debug and (os == "win") and (processor == "x86_64"): [CRASH, TIMEOUT]
-    if debug and (os == "linux") and fission: [CRASH, TIMEOUT]
     TIMEOUT
   [opener:coi, openee:basic, sw:basic]
     expected: TIMEOUT
 
   [opener:coi, openee:basic, sw:coi]
     expected: NOTRUN
 
   [opener:coi, openee:coi, sw:basic]

--- a/testing/web-platform/meta/html/cross-origin-opener-policy/resource-popup.https.html.ini
+++ b/testing/web-platform/meta/html/cross-origin-opener-policy/resource-popup.https.html.ini
@@ -1,24 +1,27 @@
 [resource-popup.https.html]
   expected:
-    if fission and debug and (os == "linux") and swgl: [TIMEOUT, OK]
+    if (os == "mac") and debug: [TIMEOUT, OK]
     [OK, TIMEOUT]
   [/common/dummy.xml - parent COOP: ""; child COOP: "same-origin"]
     expected:
-      if (os == "android") and debug: [FAIL, PASS, TIMEOUT]
-      if (os == "android") and not debug: [FAIL, PASS, TIMEOUT]
+      if os == "android": [FAIL, PASS, TIMEOUT]
       [PASS, FAIL, TIMEOUT]
 
   [/images/red.png - parent COOP: ""; child COOP: "same-origin"]
-    expected: [PASS, FAIL, TIMEOUT]
+    expected:
+      if (os == "android") and debug and not swgl: [FAIL, PASS, TIMEOUT]
+      [PASS, FAIL, TIMEOUT]
 
   [/media/2x2-green.mp4 - parent COOP: ""; child COOP: "same-origin"]
     expected:
-      if fission and debug and (os == "linux") and swgl: [TIMEOUT, PASS]
+      if (os == "mac") and debug: [TIMEOUT, PASS]
       [PASS, TIMEOUT]
 
   [/common/text-plain.txt - parent COOP: ""; child COOP: "same-origin"]
-    expected: [PASS, FAIL, TIMEOUT]
+    expected:
+      if (os == "android") and debug and not swgl: [FAIL, PASS, TIMEOUT]
+      [PASS, FAIL, TIMEOUT]
 
   [/common/text-plain.txt - parent COOP: "same-origin"; child COOP: "same-origin"]
     expected:
       if (os == "linux") and not fission: [PASS, FAIL]

--- a/testing/web-platform/meta/html/infrastructure/safe-passing-of-structured-data/shared-array-buffers/blob-data.https.html.ini
+++ b/testing/web-platform/meta/html/infrastructure/safe-passing-of-structured-data/shared-array-buffers/blob-data.https.html.ini
@@ -1,6 +1,8 @@
 implementation-status: backlog
 bug: https://bugzilla.mozilla.org/show_bug.cgi?id=1613912
 [blob-data.https.html]
-  expected: [OK, TIMEOUT]
+  expected:
+    if os == "linux": [TIMEOUT, OK]
+    [OK, TIMEOUT]
   [data worker: self.crossOriginIsolated]
     expected: FAIL

--- a/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/utf-16be.html.ini
+++ b/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/utf-16be.html.ini
@@ -40,29 +40,33 @@
 [utf-16be.html?include=svg]
 
 [utf-16be.html?include=submit]
 
 [utf-16be.html?include=xhr]
 
 [utf-16be.html?include=workers]
   expected:
-    if (os == "linux") and debug and not swgl and not fission: [TIMEOUT, OK]
+    if (os == "linux") and not swgl and not fission and debug: [TIMEOUT, OK]
+    if (os == "linux") and swgl and fission: [TIMEOUT, OK]
+    if (os == "mac") and debug: [TIMEOUT, OK]
     [OK, TIMEOUT]
   [SharedWorker() in a shared worker]
     expected: FAIL
 
   [importScripts() in a shared worker]
     expected:
       if os == "mac": [FAIL, TIMEOUT]
       FAIL
 
   [SharedWorker constructor]
     expected:
-      if (os == "linux") and debug and not swgl and not fission: [TIMEOUT, PASS]
+      if (os == "linux") and not swgl and not fission and debug: [TIMEOUT, PASS]
+      if (os == "linux") and swgl and fission: [TIMEOUT, PASS]
+      if (os == "mac") and debug: [TIMEOUT, PASS]
       [PASS, TIMEOUT]
 
   [SharedWorker() in a dedicated worker]
     expected: FAIL
 
   [Worker() in a shared worker]
     expected:
       if os == "win": [PASS, TIMEOUT]

--- a/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/utf-16le.html.ini
+++ b/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/utf-16le.html.ini
@@ -38,29 +38,29 @@
 [utf-16le.html?include=xml]
 
 [utf-16le.html?include=base-href]
 
 [utf-16le.html?include=css]
 
 [utf-16le.html?include=workers]
   expected:
-    if (os == "win") and swgl: [TIMEOUT, OK]
+    if (os == "linux") and debug and not fission and not swgl: [TIMEOUT, OK]
     [OK, TIMEOUT]
   [SharedWorker() in a shared worker]
     expected: FAIL
 
   [importScripts() in a shared worker]
     expected:
       if os == "mac": [FAIL, TIMEOUT]
       FAIL
 
   [SharedWorker constructor]
     expected:
-      if (os == "win") and swgl: [TIMEOUT, PASS]
+      if (os == "linux") and debug and not fission and not swgl: [TIMEOUT, PASS]
       [PASS, TIMEOUT]
 
   [SharedWorker() in a dedicated worker]
     expected: FAIL
 
   [Worker() in a shared worker]
     expected:
       if os == "linux": [PASS, TIMEOUT]

--- a/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/utf-8.html.ini
+++ b/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/utf-8.html.ini
@@ -28,33 +28,31 @@
 
 [utf-8.html?include=xmldocument]
   [XMLDocument#load()]
     expected: FAIL
 
 
 [utf-8.html?include=workers]
   expected:
-    if swgl and (os == "linux") and not fission: [TIMEOUT, OK]
-    if not swgl and (os == "android") and debug: [TIMEOUT, OK]
-    if swgl and (os == "win"): [TIMEOUT, OK]
+    if (os == "linux") and fission and not swgl and (processor == "x86_64"): [TIMEOUT, OK]
+    if (os == "linux") and fission and not swgl and (processor == "x86"): [TIMEOUT, OK]
     [OK, TIMEOUT]
   [SharedWorker() in a shared worker]
     expected: FAIL
 
   [importScripts() in a shared worker]
     expected:
       if (os == "linux") and fission: FAIL
       [FAIL, TIMEOUT]
 
   [SharedWorker constructor]
     expected:
-      if not swgl and (os == "android") and debug: [TIMEOUT, PASS]
-      if swgl and (os == "linux") and not fission: [TIMEOUT, PASS]
-      if swgl and (os == "win"): [TIMEOUT, PASS]
+      if (os == "linux") and fission and not swgl and (processor == "x86"): [TIMEOUT, PASS]
+      if (os == "linux") and fission and not swgl and (processor == "x86_64"): [TIMEOUT, PASS]
       [PASS, TIMEOUT]
 
   [SharedWorker() in a dedicated worker]
     expected: FAIL
 
 
 [utf-8.html?include=websocket]
 

--- a/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/windows-1251.html.ini
+++ b/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/windows-1251.html.ini
@@ -282,31 +282,31 @@
 
 [windows-1251.html?include=xhr]
   [XMLHttpRequest#open()]
     expected: FAIL
 
 
 [windows-1251.html?include=workers]
   expected:
-    if (os == "linux") and not swgl and (processor == "x86_64") and debug and fission: [TIMEOUT, OK]
-    if (os == "linux") and swgl and not fission: [TIMEOUT, OK]
+    if (os == "linux") and (processor == "x86_64") and debug and fission and not swgl: [TIMEOUT, OK]
+    if (os == "linux") and (processor == "x86_64") and debug and not fission and swgl: [TIMEOUT, OK]
     [OK, TIMEOUT]
   [SharedWorker() in a shared worker]
     expected: FAIL
 
   [importScripts() in a shared worker]
     expected:
       if os == "win": [FAIL, TIMEOUT]
       FAIL
 
   [SharedWorker constructor]
     expected:
-      if (os == "linux") and not swgl and (processor == "x86_64") and debug and fission: [TIMEOUT, PASS]
-      if (os == "linux") and swgl and not fission: [TIMEOUT, PASS]
+      if (os == "linux") and (processor == "x86_64") and debug and fission and not swgl: [TIMEOUT, PASS]
+      if (os == "linux") and (processor == "x86_64") and debug and not fission and swgl: [TIMEOUT, PASS]
       [PASS, TIMEOUT]
 
   [SharedWorker() in a dedicated worker]
     expected: FAIL
 
   [Worker() in a shared worker]
     expected:
       if (os == "android") and debug: PASS
@@ -333,18 +333,18 @@
     expected: TIMEOUT
 
   [Parsing cache manifest (FALLBACK)]
     expected: TIMEOUT
 
 
 [windows-1251.html?include=loading]
   expected:
+    if (os == "linux") and not fission and debug: [OK, ERROR]
     if (os == "linux") and not fission and not debug: [OK, ERROR, CRASH]
-    if (os == "linux") and not fission and debug: [OK, ERROR]
   [loading video <audio><source>]
     expected: FAIL
 
   [loading image <input src>]
     expected: FAIL
 
   [loading image <object data>]
     expected: FAIL

--- a/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/windows-1252.html.ini
+++ b/testing/web-platform/meta/html/infrastructure/urls/resolving-urls/query-encoding/windows-1252.html.ini
@@ -109,28 +109,34 @@
 
   [EventSource#url]
     expected: FAIL
 
 
 [windows-1252.html?include=css]
 
 [windows-1252.html?include=workers]
-  expected: [OK, TIMEOUT]
+  expected:
+    if (os == "linux") and not debug and (processor == "x86_64") and fission: [TIMEOUT, OK]
+    if (os == "linux") and debug and not fission and not swgl: [TIMEOUT, OK]
+    [OK, TIMEOUT]
   [SharedWorker() in a shared worker]
     expected: FAIL
 
   [importScripts() in a shared worker]
     expected:
       if os == "android": FAIL
       if os == "mac": FAIL
       [FAIL, TIMEOUT]
 
   [SharedWorker constructor]
-    expected: [PASS, TIMEOUT]
+    expected:
+      if (os == "linux") and not debug and (processor == "x86_64") and fission: [TIMEOUT, PASS]
+      if (os == "linux") and debug and not fission and not swgl: [TIMEOUT, PASS]
+      [PASS, TIMEOUT]
 
   [SharedWorker() in a dedicated worker]
     expected: FAIL
 
   [Worker() in a shared worker]
     expected:
       if os == "win": [PASS, TIMEOUT]
 

--- a/testing/web-platform/meta/html/interaction/focus/document-level-focus-apis/document-has-system-focus.html.ini
+++ b/testing/web-platform/meta/html/interaction/focus/document-level-focus-apis/document-has-system-focus.html.ini
@@ -1,16 +1,18 @@
 [document-has-system-focus.html]
   expected:
-    if (os == "linux") and fission and (processor == "x86_64") and not swgl and debug: [TIMEOUT, OK]
-    if (os == "linux") and fission and (processor == "x86_64") and not swgl and not debug: [TIMEOUT, OK]
-    if (os == "win") and debug and not swgl: [TIMEOUT, OK]
+    if (os == "linux") and fission and not swgl and (processor == "x86_64") and not debug: [TIMEOUT, OK]
+    if (os == "linux") and fission and not swgl and (processor == "x86_64") and debug: [TIMEOUT, OK]
+    if (os == "win") and debug and (processor == "x86_64") and not swgl: [TIMEOUT, OK]
+    if (os == "win") and debug and (processor == "x86"): [TIMEOUT, OK]
+    if os == "mac": [TIMEOUT, OK]
     if os == "android": OK
-    if os == "mac": [TIMEOUT, OK]
     [OK, TIMEOUT]
   [Top-level document receives blur/focus events and loses system focus during opening/closing of a popup]
     expected:
-      if (os == "linux") and fission and (processor == "x86_64") and not swgl and not debug: [TIMEOUT, PASS]
-      if (os == "linux") and fission and (processor == "x86_64") and not swgl and debug: [TIMEOUT, PASS]
-      if (os == "win") and debug and not swgl: [TIMEOUT, PASS]
+      if (os == "linux") and fission and not swgl and (processor == "x86_64") and not debug: [TIMEOUT, PASS]
+      if (os == "linux") and fission and not swgl and (processor == "x86_64") and debug: [TIMEOUT, PASS]
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [TIMEOUT, PASS]
+      if (os == "win") and debug and (processor == "x86"): [TIMEOUT, PASS]
       if os == "mac": [TIMEOUT, PASS]
       if os == "android": PASS
       [PASS, TIMEOUT]

--- a/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/document-with-fragment-empty.html.ini
+++ b/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/document-with-fragment-empty.html.ini
@@ -1,6 +1,8 @@
 [document-with-fragment-empty.html]
   [Autofocus elements in iframed documents with empty fragments should work.]
     expected:
-      if (os == "win") and (processor == "x86") and not debug: [PASS, FAIL]
+      if (os == "win") and debug and (processor == "x86_64") and swgl: [PASS, FAIL]
+      if (os == "win") and debug and (processor == "x86_64") and not swgl: [FAIL, PASS]
+      if (os == "win") and not debug: [PASS, FAIL]
+      if (os == "android") and not debug: [PASS, FAIL]
       if (os == "mac") and not debug: [PASS, FAIL]
-      if (os == "win") and (processor == "x86_64"): [PASS, FAIL]

--- a/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/document-with-fragment-nonexistent.html.ini
+++ b/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/document-with-fragment-nonexistent.html.ini
@@ -1,7 +1,9 @@
 [document-with-fragment-nonexistent.html]
   [Autofocus elements in iframed documents with non-existent fragments should work.]
     expected:
-      if (os == "win") and not debug and (processor == "x86"): [PASS, FAIL]
-      if (os == "win") and not debug and (processor == "x86_64"): [PASS, FAIL]
-      if (os == "win") and debug: [PASS, FAIL]
-      if os == "mac": [PASS, FAIL]
+      if (os == "win") and (processor == "x86") and debug: [FAIL, PASS]
+      if (os == "win") and (processor == "x86") and not debug: [PASS, FAIL]
+      if (os == "win") and (processor == "x86_64"): [PASS, FAIL]
+      if (os == "mac") and debug: [PASS, FAIL]
+      if (os == "mac") and not debug: [PASS, FAIL]
+      if (os == "android") and not debug: [PASS, FAIL]

--- a/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/document-with-fragment-top.html.ini
+++ b/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/document-with-fragment-top.html.ini
@@ -1,7 +1,5 @@
 [document-with-fragment-top.html]
   [Autofocus elements in iframed documents with "top" fragments should work.]
     expected:
-      if (os == "win") and not debug and (processor == "x86_64"): [PASS, FAIL]
-      if (os == "win") and not debug and (processor == "x86"): [PASS, FAIL]
-      if (os == "win") and debug: [PASS, FAIL]
       if (os == "mac") and not debug: [PASS, FAIL]
+      if os == "win": [PASS, FAIL]

--- a/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/focusable-area-in-top-document.html.ini
+++ b/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/focusable-area-in-top-document.html.ini
@@ -1,3 +1,6 @@
 [focusable-area-in-top-document.html]
   [If topDocument's focused area is not topDocument, autofocus is not processed.]
-    expected: [PASS, FAIL]
+    expected:
+      if fission and not swgl and (processor == "x86") and (os == "linux"): [FAIL, PASS]
+      if fission and swgl and (os == "win"): [FAIL, PASS]
+      [PASS, FAIL]

--- a/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/queue-non-focusable.html.ini
+++ b/testing/web-platform/meta/html/interaction/focus/the-autofocus-attribute/queue-non-focusable.html.ini
@@ -1,8 +1,9 @@
 [queue-non-focusable.html]
   [If the first autofocus element is not focusable, but becomes focusable before a frame, it should be focused.]
     expected:
-      if debug and (os == "win") and (processor == "x86_64") and swgl: PASS
+      if debug and (os == "win") and swgl: PASS
+      if not debug and (os == "mac"): [FAIL, PASS]
       if debug and (os == "mac"): PASS
+      if debug and (os == "android"): PASS
       if debug and (os == "linux"): PASS
-      if debug and (os == "android"): PASS
       [PASS, FAIL]

--- a/testing/web-platform/meta/html/semantics/embedded-content/media-elements/audio_loop_base.html.ini
+++ b/testing/web-platform/meta/html/semantics/embedded-content/media-elements/audio_loop_base.html.ini
@@ -1,2 +1,7 @@
 [audio_loop_base.html]
   max-asserts: 45
+  expected:
+    if (os == "mac") and not debug: [OK, TIMEOUT]
+  [Check if audio.loop is set to true that expecting the seeking event is fired more than once]
+    expected:
+      if (os == "mac") and not debug: [PASS, NOTRUN]

--- a/testing/web-platform/meta/html/semantics/embedded-content/media-elements/track/track-element/track-element-src-change-error.html.ini
+++ b/testing/web-platform/meta/html/semantics/embedded-content/media-elements/track/track-element/track-element-src-change-error.html.ini
@@ -1,9 +1,8 @@
 [track-element-src-change-error.html]
   disabled:
     if os == "mac": https://bugzilla.mozilla.org/show_bug.cgi?id=1591638
   [HTMLTrackElement 'src' attribute mutations]
     expected:
-      if (os == "win") and debug and (processor == "x86_64") and not swgl: [FAIL, PASS]
-      if (os == "win") and debug and (processor == "x86_64") and swgl: [PASS, FAIL]
-      if (os == "win") and debug and (processor == "x86"): [PASS, FAIL]
-      if (os == "win") and not debug: [PASS, FAIL]
+      if (os == "win") and (processor == "x86") and not debug: [PASS, FAIL]
+      if (os == "win") and (processor == "x86") and debug: [FAIL, PASS]
+      if (os == "win") and (processor == "x86_64"): [PASS, FAIL]

--- a/testing/web-platform/meta/html/semantics/embedded-content/media-elements/track/track-element/track-mode-not-changed-by-new-track.html.ini
+++ b/testing/web-platform/meta/html/semantics/embedded-content/media-elements/track/track-element/track-mode-not-changed-by-new-track.html.ini
@@ -1,6 +1,7 @@
 [track-mode-not-changed-by-new-track.html]
   [A track appended after the initial track configuration does not change other tracks]
     expected:
       if fission and (os == "win") and swgl: [PASS, FAIL]
       if fission and (os == "mac") and debug: [PASS, FAIL]
+      if not fission and swgl and (os == "linux"): [PASS, FAIL]
       if fission and (os == "linux"): [PASS, FAIL]

--- a/testing/web-platform/meta/html/semantics/embedded-content/the-img-element/image-loading-lazy-base-url-2.html.ini
+++ b/testing/web-platform/meta/html/semantics/embedded-content/the-img-element/image-loading-lazy-base-url-2.html.ini
@@ -1,9 +1,8 @@
 [image-loading-lazy-base-url-2.html]
   expected:
-    if (os == "linux") and debug and not fission and swgl: [OK, ERROR]
-    if (os == "linux") and debug and not fission and not swgl: [OK, ERROR]
-    if (os == "linux") and debug and fission: [OK, ERROR]
+    if (os == "linux") and not fission and debug: [OK, ERROR]
+    if (os == "linux") and not fission and not debug: [OK, ERROR]
+    if (os == "linux") and fission: [OK, ERROR]
     if (os == "mac") and not debug: [OK, ERROR]
-    if (os == "linux") and not debug: [OK, ERROR]
   [When a loading=lazy image is loaded, it loads relative to the document's base URL computed at parse-time.]
     expected: FAIL

--- a/testing/web-platform/meta/html/semantics/embedded-content/the-img-element/image-loading-lazy-base-url.html.ini
+++ b/testing/web-platform/meta/html/semantics/embedded-content/the-img-element/image-loading-lazy-base-url.html.ini
@@ -1,8 +1,7 @@
 [image-loading-lazy-base-url.html]
   expected:
+    if (os == "linux") and (processor == "x86_64") and not debug and not fission: [OK, ERROR]
     if (os == "linux") and (processor == "x86_64") and debug and fission: [OK, ERROR]
-    if (os == "linux") and (processor == "x86_64") and not debug and not fission: [OK, ERROR]
-    if (os == "linux") and (processor == "x86"): [OK, ERROR]
     if os == "mac": [OK, ERROR]
   [When a loading=lazy image is loaded, it loads relative to the document's base URL computed at parse-time.]
     expected: FAIL

--- a/testing/web-platform/meta/html/semantics/forms/input-change-event-properties.html.ini
+++ b/testing/web-platform/meta/html/semantics/forms/input-change-event-properties.html.ini
@@ -1,12 +1,12 @@
 [input-change-event-properties.html]
   expected:
     if os == "android": [OK, ERROR]
   [<select> pressing down arrow]
     expected:
+      if (os == "android") and not debug: [PASS, FAIL]
       if (os == "android") and debug: [PASS, FAIL]
-      if (os == "android") and not debug: [PASS, FAIL]
       if os == "mac": FAIL
 
   [<textarea></textarea> typing]
     expected:
       if os == "android": [PASS, FAIL]

--- a/testing/web-platform/meta/html/semantics/popups/popup-invoking-attribute.tentative.html.ini
+++ b/testing/web-platform/meta/html/semantics/popups/popup-invoking-attribute.tentative.html.ini
@@ -1,249 +1,3519 @@
 [popup-invoking-attribute.tentative.html]
-  [Clicking a togglepopup button opens a closed popup]
-    expected: FAIL
-
-  [Clicking a togglepopup button closes an open popup]
-    expected: FAIL
-
-  [Test <button></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2" hidepopup="popup-1"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2" hidepopup="popup-2"></button> with popup=popup]
-    expected: FAIL
-
-  [Test <button></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2" hidepopup="popup-1"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2" hidepopup="popup-2"></button> with popup=hint]
-    expected: FAIL
-
-  [Test <button></button> with popup=async]
-    expected: FAIL
-
-  [Test <button hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button showpopup="popup-1" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button showpopup="popup-2" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-1" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-1" showpopup="popup-2" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-1" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2" hidepopup="popup-1"></button> with popup=async]
-    expected: FAIL
-
-  [Test <button togglepopup="popup-2" showpopup="popup-2" hidepopup="popup-2"></button> with popup=async]
-    expected: FAIL
+  [Test <button type="button">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=0, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=2, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="checkbox"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="radio"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="range"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="file"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="color"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="date"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="datetime-local"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="month"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="time"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="week"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type="number"">, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type=text> with right arrow invocation, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <input type=text> focus only, t=1, s=1, h=1, with popup=popup]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=0, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=2, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="checkbox"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="radio"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="range"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="file"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="color"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="date"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="datetime-local"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="month"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="time"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="week"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type="number"">, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type=text> with right arrow invocation, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <input type=text> focus only, t=1, s=1, h=1, with popup=hint]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="button">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="reset">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="submit">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <button type="">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="button"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="reset"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="submit"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="image"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="text"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="email"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="password"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="search"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="tel"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=0, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=1, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=0, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=1, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=0, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="url"">, t=2, s=2, h=2, with popup=async]
+    expected: FAIL
+
+  [Test <input type="checkbox"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="radio"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="range"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="file"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="color"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="date"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="datetime-local"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="month"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="time"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="week"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type="number"">, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type=text> with right arrow invocation, t=1, s=1, h=1, with popup=async]
+    expected: FAIL
+
+  [Test <input type=text> focus only, t=1, s=1, h=1, with popup=async]
+    expected: FAIL