PASS document.queryCommandEnabled('DefaultParagraphSeparator') is true
PASS document.queryCommandValue('DefaultParagraphSeparator') is "div"
document.execCommand('DefaultParagraphSeparator', false, 'p')
PASS document.queryCommandValue('DefaultParagraphSeparator') is "p"
document.execCommand('DefaultParagraphSeparator', false, 'br')
PASS document.queryCommandValue('DefaultParagraphSeparator') is "p"
document.execCommand('DefaultParagraphSeparator', false, 'invalid')
PASS document.queryCommandValue('DefaultParagraphSeparator') is "p"

Creating paragraphs in the normal way.
document.execCommand('InsertText', false, 'a')
PASS div.innerHTML is "a"
document.execCommand('InsertText', false, '\n')
PASS div.innerHTML is "a<p><br></p>"
document.execCommand('InsertText', false, 'b')
PASS div.innerHTML is "a<p>b</p>"
document.execCommand('InsertText', false, '\n')
PASS div.innerHTML is "a<p>b</p><p><br></p>"
document.execCommand('Delete')
PASS div.innerHTML is "a<p>b</p>"
document.execCommand('Delete')
PASS div.innerHTML is "a<p><br></p>"
document.execCommand('Delete')
PASS div.innerHTML is "a"
document.execCommand('DefaultParagraphSeparator', false, 'div')
document.execCommand('InsertParagraph')
PASS div.innerHTML is "a<div><br></div>"
div.innerHTML = ''

Using the previous block as template for the new one.
document.execCommand('DefaultParagraphSeparator', false, 'p')
document.execCommand("InsertHTML", false, "<pre>a</pre>");
PASS div.innerHTML is "<pre>a</pre>"
document.execCommand('InsertText', false, 'b')
PASS div.innerHTML is "<pre>ab</pre>"
document.execCommand('InsertText', false, '\n')
PASS div.innerHTML is "<pre>ab</pre><pre><br></pre>"
document.execCommand('InsertText', false, 'c')
PASS div.innerHTML is "<pre>ab</pre><pre>c</pre>"
document.execCommand('DefaultParagraphSeparator', false, 'div')
document.execCommand('InsertText', false, '\n')
PASS div.innerHTML is "<pre>ab</pre><pre>c</pre><pre><br></pre>"
document.execCommand('Delete')
document.execCommand('InsertParagraph')
PASS div.innerHTML is "<pre>ab</pre><pre>c</pre><pre><br></pre>"

Breaking out of lists.
div.innerHTML = ''
document.execCommand('DefaultParagraphSeparator', false, 'p')
document.execCommand("InsertHTML", false, "<ul><li>a</li></ul>")
PASS div.innerHTML is "<ul><li>a</li></ul>"
document.execCommand('InsertParagraph')
document.execCommand('InsertParagraph')
PASS div.innerHTML is "<ul><li>a</li></ul><p><br></p>"

Breaking up nested elements.
div.innerHTML = ''
document.execCommand("InsertHTML", false, "<cite>a<cite>bc</cite></cite>")
window.getSelection().modify("move", "backward", "character")
document.execCommand('InsertParagraph')
PASS div.innerHTML is "<cite>a<cite>b</cite></cite><p><cite><cite>c</cite></cite></p>"
PASS successfullyParsed is true

TEST COMPLETE

