[fontname.html?1-1000]
  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" compare innerHTML]
    expected: FAIL

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" queryCommandValue("fontname") before]
    expected: FAIL

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo</span>{}<span>bar</span>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr><td>foo<td>b[a\]r<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "foo[\]bar" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=0 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandIndeterm("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz": execCommand("stylewithcss", false, "false") return value]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<span>foo[</span><span>\]bar</span>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>[bar\]</kbd>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody data-start=0 data-end=1><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "{<table><tr><td>foo<td>bar<td>baz</table>}" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table><tbody><tr data-start=1 data-end=2><td>foo<td>bar<td>baz</table>" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandIndeterm("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar<b>baz\]qoz</b>quz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandState("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<span>[foo</span> <span>bar\]</span>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>[bar\]</tt>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>bar</listing>baz\]": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" checks for modifications to non-editable content]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>b[a\]r</pre>baz" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<code>bar</code>baz\]" queryCommandValue("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "{<p><p> <p>foo</p>}" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo<p><br><p>bar\]" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo[bar<i>baz\]qoz</i>quz" queryCommandIndeterm("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<samp>b[a\]r</samp>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo[bar\]baz" queryCommandIndeterm("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<samp>[bar\]</samp>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandState("stylewithcss") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<kbd>bar</kbd>baz\]": execCommand("stylewithcss", false, "true") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<kbd>b[a\]r</kbd>baz" queryCommandState("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<i>foo[\]bar</i>": execCommand("fontname", false, "sans-serif") return value]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>[bar\]</listing>baz" queryCommandValue("fontname") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" queryCommandState("fontname") before]
    expected:
      if not e10s: PASS

  [[["fontname","sans-serif"\]\] "<b>foo[\]bar</b>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>b[a\]r</code>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<p>[foo</p><p> <span>bar</span> </p><p>baz\]</p>" compare innerHTML]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[a\]r</listing>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<pre>[bar\]</pre>baz" queryCommandValue("fontname") before]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>b[a\]r</tt>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "<p>[foo</p> <p>bar\]</p>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "<table data-start=0 data-end=1><tbody><tr><td>foo<td>bar<td>baz</table>" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<code>[bar\]</code>baz" queryCommandValue("stylewithcss") after]
    expected:
      if not e10s: PASS


[fontname.html?1001-2000]
  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<pre>bar</pre>baz\]" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<samp>bar</samp>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<samp>bar</samp>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<samp>bar</samp>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<samp>bar</samp>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<tt>bar</tt>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<tt>bar</tt>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<tt>bar</tt>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<tt>bar</tt>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>ba\]r</listing>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "[foo<listing>ba\]r</listing>baz" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>ba\]r</listing>baz" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "[foo<listing>ba\]r</listing>baz" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[ar</listing>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[ar</listing>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<listing>b[ar</listing>baz\]" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[ar</listing>baz\]" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[ar</listing>baz\]" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<listing>b[ar</listing>baz\]" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>}bar" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>}bar" queryCommandValue("fontname") before]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>}bar" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>}bar" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>}bar" queryCommandValue("fontname") before]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>}bar" queryCommandValue("fontname") after]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>b\]ar" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>b\]ar" queryCommandIndeterm("fontname") before]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>b\]ar" queryCommandValue("fontname") before]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>b\]ar" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>b\]ar" queryCommandIndeterm("fontname") before]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "foo<tt>{<br></tt>b\]ar" queryCommandValue("fontname") before]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "fo[o<listing>b\]ar</listing>" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","true"\],["fontname","sans-serif"\]\] "fo[o<listing>b\]ar</listing>" queryCommandIndeterm("fontname") after]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "fo[o<listing>b\]ar</listing>" compare innerHTML]
    expected: FAIL

  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "fo[o<listing>b\]ar</listing>" queryCommandIndeterm("fontname") after]
    expected: FAIL


[fontname.html?2001-last]
  [[["stylewithcss","false"\],["fontname","sans-serif"\]\] "fo[o<listing>b\]ar</listing>" queryCommandValue("fontname") after]
    expected: FAIL
