LayoutTests/inspector/dom/breakpoint-for-event-listener.html - WebKit - Git at Google

 <!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>
	<!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>