<!doctype html>
<html>
<head>
<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
<script>
function handleButton1Click(event) {
    TestPage.dispatchEventToFrontend("TestPageButton1Click");
}

function handleButton2Click(event) {
    TestPage.dispatchEventToFrontend("TestPageButton2Click");
}

function clickButton1() {
    document.getElementById("button1").click();
}

function clickButton2() {
    document.getElementById("button2").click();
}

function test() {
    let button1Node = null;
    let button2Node = null;

    async function getClickEventListener(nodeId) {
        let {listeners} = await DOMAgent.getEventListenersForNode(nodeId);
        return listeners.find((eventListener) => eventListener.type === "click");
    }

    async function setBreakpointForClickEventListener(node) {
        let clickEventListener = await getClickEventListener(node.id);
        InspectorTest.assert(!clickEventListener.hasBreakpoint, "Click event listener for button1 should not have a breakpoint.");

        return new Promise((resolve, reject) => {
            WI.domDebuggerManager.singleFireEventListener(WI.DOMDebuggerManager.Event.EventBreakpointAdded, (event) => {
                resolve(event.data.breakpoint);
            });

            WI.domManager.setBreakpointForEventListener(clickEventListener);
        });
    }

    let suite = InspectorTest.createAsyncSuite("DOM.BreakpointForEventListener");

    suite.addTestCase({
        name: "DOM.setBreakpointForEventListener",
        description: "Check that the debugger pauses for this event.",
        test(resolve, reject) {
            let paused = false;
            let clickingButton1 = false;

            let listener = WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                if (clickingButton1)
                    InspectorTest.pass("Should pause before button1 event handler is run.");
                else
                    InspectorTest.fail("Should not pause before button2 event handler is run.");

                paused = true;

                let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
                InspectorTest.expectEqual(targetData.pauseReason, WI.DebuggerManager.PauseReason.Listener, `Pause reason should be Listener.`);
                InspectorTest.expectEqual(targetData.pauseData.eventName, "click", `Pause data eventName should be "click".`);

                getClickEventListener(button1Node.id)
                .then((clickEventListener) => {
                    InspectorTest.assert(targetData.pauseData.eventListenerId === clickEventListener.eventListenerId, `Pause data eventListenerId should be "${clickEventListener.eventListenerId}".`);
                    InspectorTest.assert(clickEventListener.hasBreakpoint, "Click event listener for button1 should have a breakpoint.");

                    WI.debuggerManager.resume();
                });
            });

            InspectorTest.singleFireEventListener("TestPageButton1Click", (event) => {
                if (!paused) {
                    WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);

                    InspectorTest.fail("Should pause before button1 event handler is run.");
                }

                resolve();
            });

            InspectorTest.singleFireEventListener("TestPageButton2Click", (event) => {
                if (!paused)
                    InspectorTest.pass("Should not pause before button2 event handler is run.");

                InspectorTest.log("Clicking button1...");
                clickingButton1 = true;
                InspectorTest.evaluateInPage(`clickButton1()`);
            });

            getClickEventListener(button1Node.id)
            .then((clickEventListener) => {
                InspectorTest.assert(!clickEventListener.hasBreakpoint, "Click event listener for button1 should not have a breakpoint.");

                InspectorTest.log("Adding breakpoint for event listener...");
                return DOMAgent.setBreakpointForEventListener(clickEventListener.eventListenerId);
            })
            .then(() => {
                InspectorTest.log("Clicking button2...");
                return InspectorTest.evaluateInPage(`clickButton2()`);
            })
            .catch(reject);
        }
    });

    suite.addTestCase({
        name: "DOM.removeBreakpointForEventListener",
        description: "Check that the debugger does the not pause for this event.",
        test(resolve, reject) {
            let paused = false;
            let clickingButton1 = false;

            let listener = WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                if (clickingButton1)
                    InspectorTest.fail("Should not pause before button1 event handler is run.");
                else
                    InspectorTest.fail("Should not pause before button2 event handler is run.");

                paused = true;

                let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
                InspectorTest.assert(targetData.pauseReason, WI.DebuggerManager.PauseReason.Listener, `Pause reason should be Listener.`);
                InspectorTest.assert(targetData.pauseData.eventName, "click", `Pause data eventName should be "click".`);

                getClickEventListener(button1Node.id)
                .then((clickEventListener) => {
                    InspectorTest.assert(targetData.pauseData.eventListenerId === clickEventListener.eventListenerId, `Pause data eventListenerId should be "${clickEventListener.eventListenerId}".`);
                    InspectorTest.assert(clickEventListener.hasBreakpoint, "Click event listener for button1 should have a breakpoint.");

                    WI.debuggerManager.resume();
                });
            });

            InspectorTest.singleFireEventListener("TestPageButton1Click", (event) => {
                if (!paused) {
                    WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);

                    InspectorTest.pass("Should not pause before button1 event handler is run.");
                }

                resolve();
            });

            InspectorTest.singleFireEventListener("TestPageButton2Click", (event) => {
                if (!paused)
                    InspectorTest.pass("Should not pause before button2 event handler is run.");

                InspectorTest.log("Clicking button1...");
                clickingButton1 = true;
                InspectorTest.evaluateInPage(`clickButton1()`);
            });

            getClickEventListener(button1Node.id)
            .then((clickEventListener) => {
                InspectorTest.assert(clickEventListener.hasBreakpoint, "Click event listener for button1 should have a breakpoint.");

                InspectorTest.log("Removing breakpoint for event listener...");
                return DOMAgent.removeBreakpointForEventListener(clickEventListener.eventListenerId);
            })
            .then(() => {
                InspectorTest.log("Clicking button2...");
                return InspectorTest.evaluateInPage(`clickButton2()`);
            })
            .catch(reject);
        }
    });

    suite.addTestCase({
        name: "DOM.setBreakpointForEventListener.Options.Condition",
        description: "Check that the debugger will not pause unless the breakpoint has a truthy breakpoint condition.",
        async test() {
            let pauseCount = 0;

            let listener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                ++pauseCount;
                WI.debuggerManager.resume();
            });

            let breakpoint = await setBreakpointForClickEventListener(button1Node);

            InspectorTest.newline();

            InspectorTest.log("Setting condition to 'false'...");
            breakpoint.condition = "false";

            for (let i = 1; i <= 4; ++i) {
                if (i === 3) {
                    InspectorTest.newline();

                    InspectorTest.log("Setting condition to 'true'...");
                    breakpoint.condition = "true";
                }

                InspectorTest.newline();

                InspectorTest.log("Triggering breakpoint...");
                await Promise.all([
                    InspectorTest.awaitEvent("TestPageButton1Click"),
                    InspectorTest.evaluateInPage(`clickButton1()`),
                ]);

                if (i <= 2)
                    InspectorTest.expectEqual(pauseCount, 0, "Should not pause.");
                else
                    InspectorTest.expectEqual(pauseCount, i - 2, "Should pause.");
            }

            breakpoint.remove();
            WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);
        },
    });

    suite.addTestCase({
        name: "DOM.setBreakpointForEventListener.Options.IgnoreCount",
        description: "Check that the debugger will not pause unless the breakpoint is hit at least as many times as it's `ignoreCount`.",
        async test() {
            let pauseCount = 0;

            let listener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                ++pauseCount;
                WI.debuggerManager.resume();
            });

            let breakpoint = await setBreakpointForClickEventListener(button1Node);

            InspectorTest.newline();

            InspectorTest.log("Setting ignoreCount to '2'...");
            breakpoint.ignoreCount = 2;

            for (let i = 1; i <=4; ++i) {
                InspectorTest.newline();

                InspectorTest.log("Triggering breakpoint...");
                await Promise.all([
                    InspectorTest.awaitEvent("TestPageButton1Click"),
                    InspectorTest.evaluateInPage(`clickButton1()`),
                ]);

                if (i <= 2)
                    InspectorTest.expectEqual(pauseCount, 0, "Should not pause.");
                else
                    InspectorTest.expectEqual(pauseCount, i - 2, "Should pause.");
            }

            breakpoint.remove();
            WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);
        },
    });

    suite.addTestCase({
        name: "DOM.setBreakpointForEventListener.Options.Action.Log",
        description: "Check that log breakpoint actions execute when the breakpoint is hit.",
        async test() {
            let pauseCount = 0;

            let listener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                ++pauseCount;
                WI.debuggerManager.resume();
            });

            let breakpoint = await setBreakpointForClickEventListener(button1Node);

            InspectorTest.newline();

            InspectorTest.log("Adding log action...");
            let action = new WI.BreakpointAction(WI.BreakpointAction.Type.Log, {data: "BREAKPOINT ACTION LOG 1"});
            breakpoint.addAction(action);

            for (let i = 1; i <= 4; ++i) {
                if (i > 1) {
                    InspectorTest.newline();

                    InspectorTest.log("Editing log action...");
                    action.data = `BREAKPOINT ACTION LOG ${i}`;

                    if (i === 3) {
                        InspectorTest.log("Enabling auto-continue...");
                        breakpoint.autoContinue = true;
                    }
                }

                InspectorTest.newline();

                InspectorTest.log("Triggering breakpoint...");
                let [messageAddedEvent] = await Promise.all([
                    WI.consoleManager.awaitEvent(WI.ConsoleManager.Event.MessageAdded),
                    InspectorTest.awaitEvent("TestPageButton1Click"),
                    InspectorTest.evaluateInPage(`clickButton1()`),
                ]);

                InspectorTest.expectEqual(messageAddedEvent.data.message.messageText, action.data, "Should execute breakpoint action.");

                if (i <= 2)
                    InspectorTest.expectEqual(pauseCount, i, "Should pause.");
                else
                    InspectorTest.expectEqual(pauseCount, 2, "Should not pause.");
            }

            breakpoint.remove();
            WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);
        },
    });

    suite.addTestCase({
        name: "DOM.setBreakpointForEventListener.Options.Actions.Evaluate",
        description: "Check that evaluate breakpoint actions execute when the breakpoint is hit.",
        async test() {
            let pauseCount = 0;

            let listener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                ++pauseCount;
                WI.debuggerManager.resume();
            });

            let breakpoint = await setBreakpointForClickEventListener(button1Node);

            InspectorTest.newline();

            InspectorTest.log("Adding evaluate action...");
            let action = new WI.BreakpointAction(WI.BreakpointAction.Type.Evaluate, {data: "window.BREAKPOINT_ACTION_EVALUATE = 1;"});
            breakpoint.addAction(action);

            for (let i = 1; i <= 4; ++i) {
                if (i > 1) {
                    InspectorTest.newline();

                    InspectorTest.log("Editing evaluate action...");
                    action.data = `window.BREAKPOINT_ACTION_EVALUATE = ${i};`;

                    if (i === 3) {
                        InspectorTest.log("Enabling auto-continue...");
                        breakpoint.autoContinue = true;
                    }
                }

                InspectorTest.newline();

                InspectorTest.log("Triggering breakpoint...");
                await Promise.all([
                    InspectorTest.awaitEvent("TestPageButton1Click"),
                    InspectorTest.evaluateInPage(`clickButton1()`),
                ]);

                let breakpointActionEvaluateResult = await InspectorTest.evaluateInPage(`window.BREAKPOINT_ACTION_EVALUATE`);
                InspectorTest.expectEqual(breakpointActionEvaluateResult, i, "Should execute breakpoint action.");

                if (i <= 2)
                    InspectorTest.expectEqual(pauseCount, i, "Should pause.");
                else
                    InspectorTest.expectEqual(pauseCount, 2, "Should not pause.");
            }

            breakpoint.remove();
            WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, listener);
        },
    });

    suite.addTestCase({
        name: "DOM.setBreakpointForEventListener.Invalid",
        description: "Invalid event listener identifiers should cause an error.",
        test(resolve, reject) {
            const invalidEventListenerId = 9999999;
            DOMAgent.setBreakpointForEventListener(invalidEventListenerId, (error) => {
                InspectorTest.expectThat(error, "Should produce an error.");
                InspectorTest.log("Error: " + error);
                resolve();
            });
        }
    });

    suite.addTestCase({
        name: "DOM.removeBreakpointForEventListener.Invalid",
        description: "Invalid event listener identifiers should cause an error.",
        test(resolve, reject) {
            const invalidEventListenerId = 9999999;
            DOMAgent.removeBreakpointForEventListener(invalidEventListenerId, (error) => {
                InspectorTest.expectThat(error, "Should produce an error.");
                InspectorTest.log("Error: " + error);
                resolve();
            });
        }
    });

    WI.domManager.requestDocument((documentNode) => {
        Promise.all([
            documentNode.querySelector("#button1"),
            documentNode.querySelector("#button2"),
        ])
        .then(([button1Id, button2Id]) => {
            button1Node = WI.domManager.nodeForId(button1Id);
            button2Node = WI.domManager.nodeForId(button2Id);

            suite.runTestCasesAndFinish();
        })
        .catch(() => {
            InspectorTest.fail("Unable to retrieve nodes.");
            InspectorTest.completeTest();
        });
    });
}
</script>
</head>
<body onload="runTest()">
    <p>Testing DOMAgent.setBreakpointForEventListener and DOMAgent.removeBreakpointForEventListener.</p>
    <button id="button1"></button>
    <button id="button2"></button>
    <script>
        document.getElementById("button1").addEventListener("click", handleButton1Click);
        document.getElementById("button2").addEventListener("click", handleButton2Click);
    </script>
</body>
</html>