<!DOCTYPE html>
<html>
    <head>
        <title>ExecCommand argument combinations</title>
        <style>
            .pass { font-weight: bold; color: green; }
            .fail { font-weight: bold; color: red; }
            #console { border: 1px solid black; padding: 10px; margin-bottom: 20px; }
        </style>
        <script type="text/javascript">
            function debug(msg)
            {
                var span = document.createElement("span");
                span.innerHTML = msg + '<br>';
                document.getElementById("console").appendChild(span);
            }

            function escapeHTML(text)
            {
                return text.replace(/&/g, "&amp;").replace(/</g, "&lt;");
            }

            function testPassed(msg)
            {
                debug('<span class="pass">PASS</span> ' + msg + '</span>');
            }

            function testFailed(msg)
            {
                debug('<span class="fail">FAIL</span> ' + msg + '</span>');
            }

            function testEquals(a, b)
            {
                if (a == b) {
                    testPassed(escapeHTML(a) + " <b>is</b> " + escapeHTML(b));
                } else {
                    testFailed("<b>expected output was</b> " + escapeHTML(a) + " <b>should have been</b> " + escapeHTML(b));
                }
            }

            function test(codeToEval, expectedOutput)
            {
                var e = document.createElement('div');
                e.setAttribute('contentEditable', 'true');
                document.body.appendChild(e);
                e.focus();
                eval(codeToEval);
                testEquals(e.innerHTML, expectedOutput);
            }

            function runTests()
            {
                if (window.testRunner)
                     testRunner.dumpAsText();

                // Test with 1 argument.
                test('document.execCommand("InsertHorizontalRule")', '<hr>');

                // Test with 2 arguments.
                test('document.execCommand("InsertHorizontalRule", false)', '<hr>');

                // Test with 3 arguments.
                test('document.execCommand("InsertHorizontalRule", false, "foo")', '<hr id="foo">');

                // Test with 4 arguments. (should ignore the fourth argument silently)
                test('document.execCommand("InsertHorizontalRule", false, "foo", "bar")', '<hr id="foo">');

                // Test empty String 3rd parameter. (should not add an empty id value)
                test('document.execCommand("InsertHorizontalRule", false, "")', '<hr>');

                // Test null 3rd parameter. (should stringify to "null")
                test('document.execCommand("InsertHorizontalRule", false, null)', '<hr id="null">');

                // Test undefined 3rd parameter. (should treat as if only two arguments were passed)
                test('document.execCommand("InsertHorizontalRule", false, undefined)', '<hr>');

                // Test 0 for 3rd parameter. (nothing special, id value should equal the string 0)
                test('document.execCommand("InsertHorizontalRule", false, 0)', '<hr id="0">');

                // Test undefined 3rd parameter implicitly using helper function. (should treat as if only two arguments were passed, same as null)
                test('function ExecCommand(command, commandParam) { document.execCommand(command, false, commandParam); } ExecCommand("InsertHorizontalRule");', '<hr>');
            }
        </script>
    </head>
    <body onload="runTests();">
        <p>These are tests for testing the how execCommand() works with different combinations of arguments. The "InsertHorizontalRule" command was 
            chosen arbitrarily because it was what I was working on at the time, but the results should be paralleled in the other commands as well.</p>

        <h4>CONSOLE</h4>
        <pre id='console'></pre>
    </body>
</html>
