<p>This tests to make sure that there is no special class on block placeholders used during the InsertPargraph opreation.  Below there should be an empty paragraph followed by another one that is made up of a block with a &lt;br&gt; inside of it.</p>
<div id="div" contenteditable="true"><br></div>

<script>
div = document.getElementById("div");
div.focus();
document.execCommand("InsertParagraph");
if (window.testRunner) {
    window.testRunner.dumpAsText();
    document.body.innerText = div.innerHTML;
}
</script>
