[positional-methods.html]
  [Position check: Element.appendHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.appendHTML (Element)]
    expected: FAIL

  [Position check: Element.appendHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.appendHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Element.prependHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.prependHTML (Element)]
    expected: FAIL

  [Position check: Element.prependHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.prependHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Element.beforeHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.beforeHTML (Element)]
    expected: FAIL

  [Position check: Element.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Element.afterHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.afterHTML (Element)]
    expected: FAIL

  [Position check: Element.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Element.replaceWithHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.replaceWithHTML (Element)]
    expected: FAIL

  [Position check: Element.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Comment.beforeHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.beforeHTML (Element)]
    expected: FAIL

  [Position check: Comment.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Comment.afterHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.afterHTML (Element)]
    expected: FAIL

  [Position check: Comment.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Comment.replaceWithHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.replaceWithHTML (Element)]
    expected: FAIL

  [Position check: Comment.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Text.beforeHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.beforeHTML (Element)]
    expected: FAIL

  [Position check: Text.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Text.afterHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.afterHTML (Element)]
    expected: FAIL

  [Position check: Text.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Text.replaceWithHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.replaceWithHTML (Element)]
    expected: FAIL

  [Position check: Text.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: ProcessingInstruction.beforeHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.beforeHTML (Element)]
    expected: FAIL

  [Position check: ProcessingInstruction.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.beforeHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: ProcessingInstruction.afterHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.afterHTML (Element)]
    expected: FAIL

  [Position check: ProcessingInstruction.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.afterHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: ProcessingInstruction.replaceWithHTML (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTML (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTML (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.replaceWithHTML (Element)]
    expected: FAIL

  [Position check: ProcessingInstruction.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTMLUnsafe (Element) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTMLUnsafe (Element) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.replaceWithHTMLUnsafe (Element)]
    expected: FAIL

  [Position check: Element.appendHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.appendHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Element.appendHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.appendHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Element.prependHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.prependHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Element.prependHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.prependHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Element.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Element.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Element.afterHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.afterHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Element.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Element.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Element.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Comment.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Comment.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Comment.afterHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.afterHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Comment.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Comment.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Comment.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Text.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Text.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Text.afterHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.afterHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Text.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Text.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Position check: Text.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: ProcessingInstruction.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.beforeHTML (ShadowRoot)]
    expected: FAIL

  [Position check: ProcessingInstruction.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.beforeHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: ProcessingInstruction.afterHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.afterHTML (ShadowRoot)]
    expected: FAIL

  [Position check: ProcessingInstruction.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.afterHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: ProcessingInstruction.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTML (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTML (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.replaceWithHTML (ShadowRoot)]
    expected: FAIL

  [Position check: ProcessingInstruction.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTMLUnsafe (ShadowRoot) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.replaceWithHTMLUnsafe (ShadowRoot)]
    expected: FAIL

  [Position check: Element.appendHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.appendHTML (template.content)]
    expected: FAIL

  [Position check: Element.appendHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.appendHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.appendHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Element.prependHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.prependHTML (template.content)]
    expected: FAIL

  [Position check: Element.prependHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.prependHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.prependHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Element.beforeHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.beforeHTML (template.content)]
    expected: FAIL

  [Position check: Element.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.beforeHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Element.afterHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.afterHTML (template.content)]
    expected: FAIL

  [Position check: Element.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.afterHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Element.replaceWithHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.replaceWithHTML (template.content)]
    expected: FAIL

  [Position check: Element.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Element.replaceWithHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Element.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Comment.beforeHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.beforeHTML (template.content)]
    expected: FAIL

  [Position check: Comment.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.beforeHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Comment.afterHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.afterHTML (template.content)]
    expected: FAIL

  [Position check: Comment.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.afterHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Comment.replaceWithHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.replaceWithHTML (template.content)]
    expected: FAIL

  [Position check: Comment.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Comment.replaceWithHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Comment.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Text.beforeHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.beforeHTML (template.content)]
    expected: FAIL

  [Position check: Text.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.beforeHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Text.afterHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.afterHTML (template.content)]
    expected: FAIL

  [Position check: Text.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.afterHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: Text.replaceWithHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.replaceWithHTML (template.content)]
    expected: FAIL

  [Position check: Text.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: Text.replaceWithHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: Text.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: ProcessingInstruction.beforeHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.beforeHTML (template.content)]
    expected: FAIL

  [Position check: ProcessingInstruction.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.beforeHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.beforeHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: ProcessingInstruction.afterHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.afterHTML (template.content)]
    expected: FAIL

  [Position check: ProcessingInstruction.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.afterHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.afterHTMLUnsafe (template.content)]
    expected: FAIL

  [Position check: ProcessingInstruction.replaceWithHTML (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTML (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTML (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.replaceWithHTML (template.content)]
    expected: FAIL

  [Position check: ProcessingInstruction.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTMLUnsafe (template.content) (runScripts=true)]
    expected: FAIL

  [Only unsafe variants should run scripts: ProcessingInstruction.replaceWithHTMLUnsafe (template.content) (runScripts=false)]
    expected: FAIL

  [Sanitizer should remove forbidden elements: ProcessingInstruction.replaceWithHTMLUnsafe (template.content)]
    expected: FAIL

  [afterHTML throws HierarchyRequestError if parent is a Document (Comment node)]
    expected: FAIL

  [afterHTML is exposed via the NonDocumentTypeChildNode mixin]
    expected: FAIL

  [afterHTML throws HierarchyRequestError if parent is a DocumentFragment]
    expected: FAIL

  [afterHTML throws HierarchyRequestError if parent is an html element]
    expected: FAIL

  [afterHTML throws HierarchyRequestError if parent is a disconnected html element]
    expected: FAIL

  [afterHTML on Element without a parent returns undefined and does not throw]
    expected: FAIL

  [afterHTML on Comment without a parent returns undefined and does not throw]
    expected: FAIL

  [afterHTML on Text without a parent returns undefined and does not throw]
    expected: FAIL

  [afterHTML on ProcessingInstruction without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTML throws HierarchyRequestError if parent is a Document (Comment node)]
    expected: FAIL

  [beforeHTML is exposed via the NonDocumentTypeChildNode mixin]
    expected: FAIL

  [beforeHTML throws HierarchyRequestError if parent is a DocumentFragment]
    expected: FAIL

  [beforeHTML throws HierarchyRequestError if parent is an html element]
    expected: FAIL

  [beforeHTML throws HierarchyRequestError if parent is a disconnected html element]
    expected: FAIL

  [beforeHTML on Element without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTML on Comment without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTML on Text without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTML on ProcessingInstruction without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTML throws HierarchyRequestError if parent is a Document (Comment node)]
    expected: FAIL

  [replaceWithHTML is exposed via the NonDocumentTypeChildNode mixin]
    expected: FAIL

  [replaceWithHTML throws HierarchyRequestError if parent is a DocumentFragment]
    expected: FAIL

  [replaceWithHTML throws HierarchyRequestError if parent is an html element]
    expected: FAIL

  [replaceWithHTML throws HierarchyRequestError if parent is a disconnected html element]
    expected: FAIL

  [replaceWithHTML on Element without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTML on Comment without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTML on Text without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTML on ProcessingInstruction without a parent returns undefined and does not throw]
    expected: FAIL

  [appendHTML is exposed on Element and ShadowRoot only]
    expected: FAIL

  [appendHTML on an html element throws HierarchyRequestError]
    expected: FAIL

  [appendHTML on a disconnected html element throws HierarchyRequestError]
    expected: FAIL

  [prependHTML is exposed on Element and ShadowRoot only]
    expected: FAIL

  [prependHTML on an html element throws HierarchyRequestError]
    expected: FAIL

  [prependHTML on a disconnected html element throws HierarchyRequestError]
    expected: FAIL

  [appendHTML in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [appendHTML supports declarative shadow roots]
    expected: FAIL

  [appendHTML parses using parent Element (<tr>) as context]
    expected: FAIL

  [appendHTML drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [appendHTML parses using <template> host as context]
    expected: FAIL

  [appendHTML parses using ShadowRoot host as context]
    expected: FAIL

  [appendHTML on disconnected node with a parent inserts content]
    expected: FAIL

  [prependHTML in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [prependHTML supports declarative shadow roots]
    expected: FAIL

  [prependHTML parses using parent Element (<tr>) as context]
    expected: FAIL

  [prependHTML drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [prependHTML parses using <template> host as context]
    expected: FAIL

  [prependHTML parses using ShadowRoot host as context]
    expected: FAIL

  [prependHTML on disconnected node with a parent inserts content]
    expected: FAIL

  [beforeHTML in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [beforeHTML supports declarative shadow roots]
    expected: FAIL

  [beforeHTML parses using parent Element (<tr>) as context]
    expected: FAIL

  [beforeHTML drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [beforeHTML parses using <template> host as context]
    expected: FAIL

  [beforeHTML parses using ShadowRoot host as context]
    expected: FAIL

  [beforeHTML on disconnected node with a parent inserts content]
    expected: FAIL

  [afterHTML in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [afterHTML supports declarative shadow roots]
    expected: FAIL

  [afterHTML parses using parent Element (<tr>) as context]
    expected: FAIL

  [afterHTML drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [afterHTML parses using <template> host as context]
    expected: FAIL

  [afterHTML parses using ShadowRoot host as context]
    expected: FAIL

  [afterHTML on disconnected node with a parent inserts content]
    expected: FAIL

  [replaceWithHTML in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [replaceWithHTML supports declarative shadow roots]
    expected: FAIL

  [replaceWithHTML parses using parent Element (<tr>) as context]
    expected: FAIL

  [replaceWithHTML drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [replaceWithHTML parses using <template> host as context]
    expected: FAIL

  [replaceWithHTML parses using ShadowRoot host as context]
    expected: FAIL

  [replaceWithHTML on disconnected node with a parent inserts content]
    expected: FAIL

  [afterHTMLUnsafe throws HierarchyRequestError if parent is a Document (Comment node)]
    expected: FAIL

  [afterHTMLUnsafe is exposed via the NonDocumentTypeChildNode mixin]
    expected: FAIL

  [afterHTMLUnsafe throws HierarchyRequestError if parent is a DocumentFragment]
    expected: FAIL

  [afterHTMLUnsafe throws HierarchyRequestError if parent is an html element]
    expected: FAIL

  [afterHTMLUnsafe throws HierarchyRequestError if parent is a disconnected html element]
    expected: FAIL

  [afterHTMLUnsafe on Element without a parent returns undefined and does not throw]
    expected: FAIL

  [afterHTMLUnsafe on Comment without a parent returns undefined and does not throw]
    expected: FAIL

  [afterHTMLUnsafe on Text without a parent returns undefined and does not throw]
    expected: FAIL

  [afterHTMLUnsafe on ProcessingInstruction without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTMLUnsafe throws HierarchyRequestError if parent is a Document (Comment node)]
    expected: FAIL

  [beforeHTMLUnsafe is exposed via the NonDocumentTypeChildNode mixin]
    expected: FAIL

  [beforeHTMLUnsafe throws HierarchyRequestError if parent is a DocumentFragment]
    expected: FAIL

  [beforeHTMLUnsafe throws HierarchyRequestError if parent is an html element]
    expected: FAIL

  [beforeHTMLUnsafe throws HierarchyRequestError if parent is a disconnected html element]
    expected: FAIL

  [beforeHTMLUnsafe on Element without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTMLUnsafe on Comment without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTMLUnsafe on Text without a parent returns undefined and does not throw]
    expected: FAIL

  [beforeHTMLUnsafe on ProcessingInstruction without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTMLUnsafe throws HierarchyRequestError if parent is a Document (Comment node)]
    expected: FAIL

  [replaceWithHTMLUnsafe is exposed via the NonDocumentTypeChildNode mixin]
    expected: FAIL

  [replaceWithHTMLUnsafe throws HierarchyRequestError if parent is a DocumentFragment]
    expected: FAIL

  [replaceWithHTMLUnsafe throws HierarchyRequestError if parent is an html element]
    expected: FAIL

  [replaceWithHTMLUnsafe throws HierarchyRequestError if parent is a disconnected html element]
    expected: FAIL

  [replaceWithHTMLUnsafe on Element without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTMLUnsafe on Comment without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTMLUnsafe on Text without a parent returns undefined and does not throw]
    expected: FAIL

  [replaceWithHTMLUnsafe on ProcessingInstruction without a parent returns undefined and does not throw]
    expected: FAIL

  [appendHTMLUnsafe is exposed on Element and ShadowRoot only]
    expected: FAIL

  [appendHTMLUnsafe on an html element throws HierarchyRequestError]
    expected: FAIL

  [appendHTMLUnsafe on a disconnected html element throws HierarchyRequestError]
    expected: FAIL

  [prependHTMLUnsafe is exposed on Element and ShadowRoot only]
    expected: FAIL

  [prependHTMLUnsafe on an html element throws HierarchyRequestError]
    expected: FAIL

  [prependHTMLUnsafe on a disconnected html element throws HierarchyRequestError]
    expected: FAIL

  [appendHTMLUnsafe in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [appendHTMLUnsafe supports declarative shadow roots]
    expected: FAIL

  [appendHTMLUnsafe parses using parent Element (<tr>) as context]
    expected: FAIL

  [appendHTMLUnsafe drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [appendHTMLUnsafe parses using <template> host as context]
    expected: FAIL

  [appendHTMLUnsafe parses using ShadowRoot host as context]
    expected: FAIL

  [appendHTMLUnsafe on disconnected node with a parent inserts content]
    expected: FAIL

  [prependHTMLUnsafe in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [prependHTMLUnsafe supports declarative shadow roots]
    expected: FAIL

  [prependHTMLUnsafe parses using parent Element (<tr>) as context]
    expected: FAIL

  [prependHTMLUnsafe drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [prependHTMLUnsafe parses using <template> host as context]
    expected: FAIL

  [prependHTMLUnsafe parses using ShadowRoot host as context]
    expected: FAIL

  [prependHTMLUnsafe on disconnected node with a parent inserts content]
    expected: FAIL

  [beforeHTMLUnsafe in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [beforeHTMLUnsafe supports declarative shadow roots]
    expected: FAIL

  [beforeHTMLUnsafe parses using parent Element (<tr>) as context]
    expected: FAIL

  [beforeHTMLUnsafe drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [beforeHTMLUnsafe parses using <template> host as context]
    expected: FAIL

  [beforeHTMLUnsafe parses using ShadowRoot host as context]
    expected: FAIL

  [beforeHTMLUnsafe on disconnected node with a parent inserts content]
    expected: FAIL

  [afterHTMLUnsafe in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [afterHTMLUnsafe supports declarative shadow roots]
    expected: FAIL

  [afterHTMLUnsafe parses using parent Element (<tr>) as context]
    expected: FAIL

  [afterHTMLUnsafe drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [afterHTMLUnsafe parses using <template> host as context]
    expected: FAIL

  [afterHTMLUnsafe parses using ShadowRoot host as context]
    expected: FAIL

  [afterHTMLUnsafe on disconnected node with a parent inserts content]
    expected: FAIL

  [replaceWithHTMLUnsafe in an XML document uses the HTML parser and supports sanitization]
    expected: FAIL

  [replaceWithHTMLUnsafe supports declarative shadow roots]
    expected: FAIL

  [replaceWithHTMLUnsafe parses using parent Element (<tr>) as context]
    expected: FAIL

  [replaceWithHTMLUnsafe drops <td> when parsed using parent <div> as context]
    expected: FAIL

  [replaceWithHTMLUnsafe parses using <template> host as context]
    expected: FAIL

  [replaceWithHTMLUnsafe parses using ShadowRoot host as context]
    expected: FAIL

  [replaceWithHTMLUnsafe on disconnected node with a parent inserts content]
    expected: FAIL