<!DOCTYPE html>
<html>
<head>
<title>HTML Templates: 'In body' insertion mode: Template end tag without start one. Element should be ignored</title>
<meta name="author" title="Sergey G. Grekhov" href="mailto:sgrekhov@unipro.ru">
<meta name="author" title="Aleksei Yu. Semenov" href="a.semenov@unipro.ru">
<meta name="assert" content="If parser in 'in body' insertion mode meets template end tag and if the stack of open elements has no template element in html scope, then this is a parse error; ignore the token">
<link rel="help" href="http://www.w3.org/TR/2013/WD-html-templates-20130214/#in-body-addition">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/html/resources/common.js"></script>
<link rel="stylesheet" href="/resources/testharness.css">
</head>
<body>
<div id="log"></div>
<script type="text/javascript">


test(function () {
    var doc = newHTMLDocument();

    doc.body.innerHTML = '</template>';

    assert_equals(doc.body.childNodes.length, 0, 'Element must be ignored');

}, '</template> tag in HTML body without start one should be ignored');



test(function () {
    var doc = newHTMLDocument();

    doc.body.innerHTML = '<template id="tmpl"></template></template>';

    assert_equals(doc.body.childNodes.length, 1, 'Element must be ignored');
    assert_not_equals(doc.querySelector('#tmpl'), null,
            'Element should present it document body');

}, '</template> tag in HTML body without start one should be ignored. '
    + 'Test valid <template> element and </template> tag after it');



test(function () {
    var doc = newHTMLDocument();

    doc.body.innerHTML = '</template><template id="tmpl"></template>';

    assert_equals(doc.body.childNodes.length, 1, 'Element must be ignored');
    assert_not_equals(doc.querySelector('#tmpl'), null,
            'Element should present it document body');

}, '</template> tag in HTML body without start one should be ignored. '
    + 'Test valid <template> element and </template> tag before it');



test(function () {
    var doc = newHTMLDocument();

    doc.body.innerHTML = '</template><template id="tmpl"></template><title></title>';

    assert_equals(doc.body.childNodes.length, 2, 'Element must be ignored');
    assert_not_equals(doc.querySelector('#tmpl'), null,
            'Valid element should present it document body');
    assert_not_equals(doc.querySelector('title'), null,
            'Valid title element should present it document body');

}, '</template> tag in HTML body without start one should be ignored. '
    + 'Test valid <template> element, <title> element and </template> tag before them');



test(function () {
    var doc = newHTMLDocument();

    doc.body.innerHTML = '<template id="tmpl"></template><title></title></template>';

    assert_equals(doc.body.childNodes.length, 2, 'Element must be ignored');
    assert_not_equals(doc.querySelector('#tmpl'), null,
            'Valid element should present it document body');
    assert_not_equals(doc.querySelector('title'), null,
            'Valid title element should present it document body');

}, '</template> tag in HTML body without start one should be ignored. '
    + 'Test valid <template> element, <title> element and </template> tag after them');


testInIFrame('/html/semantics/scripting-1/the-template-element/resources/end-template-tag-in-body.html', function(context) {
    var doc = context.iframes[0].contentDocument;

    assert_equals(doc.body.querySelector('template'), null,
            '</template> must be ignored');
    assert_not_equals(doc.body.querySelector('div'), null,
            'Valid element should present it document body');

}, '</template> tag in HTML body without start one should be ignored. '
    + 'Test HTML document loaded from file');


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