Quelle test_bug422403-1.html Sprache: HTML

products/Sources/formale Sprachen/C/Firefox/dom/base/test/test_bug422403-1.html

<!DOCTYPE HTML>
<html>

<head>
  <title>Test for XHTML serializer</title>
  <script src="/tests/SimpleTest/SimpleTest.js"></script>
  <link rel="stylesheet" type="text/css" href="/tests/SimpleTest/test.css" />
</head>
<body>
<a target="_blank" href="https://bugzilla.mozilla.org/show_bug.cgi?id=422043">Mozilla Bug </a>
<p id="display"></p>
<div id="content" style="display: none">
</div>

<iframe id="testframe" src="file_xhtmlserializer_1.xhtml"></iframe>
<pre id="test">
<script class="testbody" type="text/javascript">

function loadFileContent(aFile, aCharset) {
    //if(aAsIso == undefined) aAsIso = false;
    if(aCharset == undefined)
        aCharset = 'UTF-8';

    var baseUri = SpecialPowers.Cc['@mozilla.org/network/standard-url-mutator;1']
                                  .createInstance(SpecialPowers.Ci.nsIURIMutator)
                                  .setSpec(window.location.href)
                                  .finalize();

    var ios = SpecialPowers.Cc['@mozilla.org/network/io-service;1']
            .getService(SpecialPowers.Ci.nsIIOService);
    var chann = ios.newChannel(aFile,
                               aCharset,
                               baseUri,
                               null,      // aLoadingNode
                               SpecialPowers.Services.scriptSecurityManager.getSystemPrincipal(),
                               null,      // aTriggeringPrincipal
                               SpecialPowers.Ci.nsILoadInfo.SEC_ALLOW_CROSS_ORIGIN_SEC_CONTEXT_IS_NULL,
                               SpecialPowers.Ci.nsIContentPolicy.TYPE_OTHER);

    var cis = SpecialPowers.Ci.nsIConverterInputStream;

    var inputStream = SpecialPowers.Cc["@mozilla.org/intl/converter-input-stream;1"]
                       .createInstance(cis);
    inputStream.init(chann.open(), aCharset, 1024, cis.DEFAULT_REPLACEMENT_CHARACTER);
    var str = {}, content = '';
    while (inputStream.readString(4096, str) != 0) {
        content += str.value;
    }
    return content;
}

function testHtmlSerializer_1 () {
  const de = SpecialPowers.Ci.nsIDocumentEncoder
  var encoder = SpecialPowers.Cu.createDocumentEncoder("application/xhtml+xml");

  var doc = SpecialPowers.wrap($("testframe")).contentDocument;
  var out, expected;

  // in the following tests, we must use the OutputLFLineBreak flag, to avoid
  // to have the default line break of the platform in the result, so the test
  // can pass on all platform

  //------------ no flags
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak);
  encoder.setCharset("UTF-8");
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_noflag.xhtml");
  is(out, expected, "test no flags");

  //------------- unsupported flags
  // since the following flags are not supported, we should
  // have a result like the one without flag
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputPreformatted);
  out = encoder.encodeToString();
  is(out, expected, "test OutputPreformatted");

  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputFormatFlowed);
  out = encoder.encodeToString();
  is(out, expected, "test OutputFormatFlowed");

  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputNoScriptContent);
  out = encoder.encodeToString();
  is(out, expected, "test OutputNoScriptContent");

  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputNoFramesContent);
  out = encoder.encodeToString();
  is(out, expected, "test OutputNoFramesContent");

  //------------ OutputWrap
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputWrap);
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_wrap.xhtml");
  is(out, expected, "test OutputWrap");

  //------------ OutputFormatted
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputFormatted);
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_format.xhtml");
  is(out, expected, "test OutputFormatted");

  //------------ OutputRaw
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputRaw);
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_raw.xhtml");
  is(out, expected, "test OutputRaw");

  //------------ OutputBodyOnly
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputBodyOnly);
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_bodyonly.xhtml");
  is(out, expected, "test OutputBodyOnly");

  //------------ OutputAbsoluteLinks
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputAbsoluteLinks);
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_links.xhtml").trim('\n');
  is(out, expected, "test OutputAbsoluteLinks");

  //------------ OutputLFLineBreak
  encoder.init(doc, "application/xhtml+xml",de.OutputLFLineBreak);
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_linebreak.xhtml");
  is(out, expected, "test OutputLFLineBreak");

  //------------ OutputCRLineBreak
  encoder.init(doc, "application/xhtml+xml",de.OutputCRLineBreak);
  out = encoder.encodeToString();
  expected = expected.replace(/\n/mg, "\r");
  is(out, expected, "test OutputCRLineBreak");

  //------------ OutputLFLineBreak + OutputCRLineBreak
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputCRLineBreak);
  out = encoder.encodeToString();
  expected = expected.replace(/\r/mg, "\r\n");
  is(out, expected, "test OutputLFLineBreak + OutputCRLineBreak");

  //------------ OutputNoFormattingInPre
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputNoFormattingInPre);
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_noformatpre.xhtml");
  is(out, expected, "test OutputNoFormattingInPre");

  // ------------- nested body elements
  var body2 = doc.createElement('body');
  var p = doc.createElement('p');
  p.appendChild(doc.createTextNode("this is an other body element"));
  body2.appendChild(p);
  var body = doc.getElementsByTagName('body')[0];
  body.appendChild(body2);

  is(doc.getElementsByTagName('body').length, 2); // to be sure we have two body elements

  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak);
  encoder.setCharset("UTF-8");
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_nested_body.xhtml");
  is(out, expected, "test with two nested body elements");

  // ------------- two body elements
  body.parentNode.insertBefore(body2, body);

  is(doc.getElementsByTagName('body').length, 2); // to be sure we have two body elements
  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak);
  encoder.setCharset("UTF-8");
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_sibling_body.xhtml");
  is(out, expected, "test with two body elements");

  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak | de.OutputBodyOnly);
  encoder.setCharset("UTF-8");
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_sibling_body_only_body.xhtml");
  is(out, expected, "test with two body elements, and output body only");

  // --------------- no body element
  doc.documentElement.removeChild(body);
  doc.documentElement.removeChild(body2);

  encoder.init(doc, "application/xhtml+xml", de.OutputLFLineBreak);
  encoder.setCharset("UTF-8");
  out = encoder.encodeToString();
  expected = loadFileContent("file_xhtmlserializer_1_no_body.xhtml");
  is(out, expected, "test with no body element");

  SimpleTest.finish();
}

SimpleTest.waitForExplicitFinish();

addLoadEvent(testHtmlSerializer_1);

</script>
</pre>
</body>
</html>

Messung V0.5

¤ Dauer der Verarbeitung: 0.3 Sekunden ¤

Wurzel

Suchen

Beweissystem der NASA

Beweissystem Isabelle

NIST Cobol Testsuite

Cephes Mathematical Library

Wiener Entwicklungsmethode

Haftungshinweis

Die Informationen auf dieser Webseite wurden nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit, noch Qualität der bereit gestellten Informationen zugesichert.

Bemerkung:

Die farbliche Syntaxdarstellung und die Messung sind noch experimentell.