LayoutTests/inspector/dom-debugger/dom-breakpoints.html - WebKit - Git at Google

 <!doctype html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script src="../debugger/resources/log-active-stack-trace.js"></script>
 <script>
 function subtreeModifiedTest() {
     document.getElementById("subtree-modified-test").append(document.createElement("p"));
 }

 function attributeModifiedTest() {
     document.getElementById("attribute-modified-test").setAttribute("display", "none");
 }

 function nodeRemovedDirectTest() {
     let node = document.getElementById("node-removed-direct-test");
     let parent = node.parentNode;
     node.remove();
     parent.append(node);
 }

 function nodeRemovedAncestorTest() {
     let node = document.getElementById("node-removed-ancestor-test");
     let parent = node.parentNode;
     let grandparent = parent.parentNode;
     parent.remove(node);
     grandparent.append(parent);
 }

 function test()
 {
     const subtreeModifiedTestId = "subtree-modified-test";
     const attributeModifiedTestId = "attribute-modified-test";
     const nodeRemovedDirectTestId = "node-removed-direct-test";
     const nodeRemovedAncestorTestId = "node-removed-ancestor-test";
     const multipleBreakpointsTestId = "multiple-breakpoints-test";

     let debuggerPausedListener = null;

     let suite = InspectorTest.createAsyncSuite("DOMBreakpoints");

     function teardown(resolve) {
         let breakpoints = WI.domDebuggerManager.domBreakpoints;
         for (let breakpoint of breakpoints)
             WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);
         InspectorTest.assert(!WI.domDebuggerManager.domBreakpoints.length);

         WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, debuggerPausedListener);
         debuggerPausedListener = null;

         resolve();
     }

     function rejectOnPause() {
         return new Promise((resolve, reject) => {
             InspectorTest.assert(!debuggerPausedListener);
             debuggerPausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                 WI.debuggerManager.resume();
                 InspectorTest.fail("Should not pause.");
                 reject();
             });
         });
     }

     function awaitEvaluateInPage(expression) {
         return new Promise((resolve, reject) => {
             InspectorTest.log("Wait for evaluate in page to return.");
             InspectorTest.evaluateInPage(expression, (error) => {
                 if (error)
                     reject(error);

                 resolve();
             });
         });
     }

     function awaitQuerySelector(selector) {
         return new Promise((resolve, reject) => {
             WI.domManager.requestDocument((documentNode) => {
                 if (!documentNode) {
                     reject();
                     return;
                 }

                 WI.domManager.querySelector(documentNode.id, selector, (nodeId) => {
                     if (!nodeId) {
                         InspectorTest.fail("Selector returned no nodes.", selector);
                         reject();
                         return;
                     }

                     let node = WI.domManager.nodeForId(nodeId);
                     InspectorTest.assert(node, "Missing node for id.", nodeId);
                     if (!node) {
                         reject();
                         return;
                     }

                     resolve(node);
                 });
             });
         });
     }

     function addBreakpointForElementIdentifier(elementIdentifier, type, disabled) {
         return new Promise((resolve, reject) => {
             awaitQuerySelector("#" + elementIdentifier)
             .then((node) => {
                 WI.domDebuggerManager.awaitEvent(WI.DOMDebuggerManager.Event.DOMBreakpointAdded)
                 .then((event) => {
                     let breakpoint = event.data.breakpoint;
                     InspectorTest.pass(`Added '${type}' breakpoint.`);
                     resolve(event);
                 });

                 WI.domDebuggerManager.addDOMBreakpoint(new WI.DOMBreakpoint(node, type, {disabled}));
             });
         });
     }

     function addTestsForBreakpointType({name, elementIdentifier, type, expression, insertion, shouldMatch}) {
         suite.addTestCase({
             name: `DOMBreakpoints.${name}.BreakpointEnabled`,
             description: "Check that debugger pauses for breakpoint type.",
             teardown,
             test(resolve, reject) {
                 addBreakpointForElementIdentifier(elementIdentifier, type)
                 .then((event) => {
                     let breakpoint = event.data.breakpoint;
                     InspectorTest.expectEqual(breakpoint.type, type, "Breakpoint should have expected type.");

                     InspectorTest.log("Call DOM operation.");
                     InspectorTest.evaluateInPage(expression);
                     return WI.debuggerManager.awaitEvent(WI.DebuggerManager.Event.Paused);
                 })
                 .then(() => {
                     let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
                     InspectorTest.log("PAUSED:");
                     InspectorTest.expectEqual(targetData.pauseReason, WI.DebuggerManager.PauseReason.DOM, "Pause reason should be DOM.");

                     let pauseData = targetData.pauseData;
                     InspectorTest.expectEqual(pauseData.type, type, `Pause type should be '${type}'.`);
                     InspectorTest.expectEqual(pauseData.nodeId, domNodeIdentifier, `Pause nodeId should be expected value.`);

                     if (insertion !== undefined)
                         InspectorTest.expectEqual(insertion, target.pauseData.insertion, `Pause insertion should be '${insertion}'.`);

                     if (pauseData.targetNodeId) {
                         if (shouldMatch)
                             InspectorTest.expectEqual(pauseData.targetNodeId, pauseData.nodeId, "Pause targetNodeId should match nodeId.");
                         else
                             InspectorTest.expectNotEqual(pauseData.targetNodeId, pauseData.nodeId, "Pause targetNodeId should not match nodeId.");
                     }

                     logActiveStackTrace();
                     return WI.debuggerManager.resume();
                 })
                 .then(resolve, reject);
             }
         });

         suite.addTestCase({
             name: `DOMBreakpoints.${name}.BreakpointDisabled`,
             description: "Check that debugger does not pause for disabled breakpoint.",
             teardown,
             test(resolve, reject) {
                 const disabled = true;
                 addBreakpointForElementIdentifier(elementIdentifier, type, disabled)
                 .then(() => Promise.race([awaitEvaluateInPage(expression), rejectOnPause()]))
                 .then(() => {
                     InspectorTest.pass("Should not pause for disabled breakpoint.");
                     resolve();
                 })
                 .catch(reject);
             }
         });

         suite.addTestCase({
             name: `DOMBreakpoints.${name}.DebuggerDisabled`,
             description: "Check that debugger does not pause when the debugger is disabled.",
             teardown,
             test(resolve, reject) {
                 addBreakpointForElementIdentifier(elementIdentifier, type)
                 .then(() => DebuggerAgent.setBreakpointsActive(false))
                 .then(() => Promise.race([awaitEvaluateInPage(expression), rejectOnPause()]))
                 .then(() => DebuggerAgent.setBreakpointsActive(true))
                 .then(() => {
                     InspectorTest.pass("Should not pause for disabled breakpoint.");
                     resolve();
                 })
                 .catch(reject);
             }
         });

         suite.addTestCase({
             name: `DOMBreakpoints.${name}.RemoveBreakpoint`,
             description: "Check that debugger does not pause for removed breakpoint.",
             teardown,
             test(resolve, reject) {
                 addBreakpointForElementIdentifier(elementIdentifier, type)
                 .then((event) => {
                     let promise = WI.domDebuggerManager.awaitEvent(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved);
                     let breakpoint = event.data.breakpoint;

                     InspectorTest.log("Remove breakpoint.");
                     WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);
                     return promise;
                 })
                 .then(() => Promise.race([awaitEvaluateInPage(expression), rejectOnPause()]))
                 .then(() => {
                     InspectorTest.pass("Should not pause for removed breakpoint.");
                     resolve();
                 })
                 .catch(reject);
             }
         });
     }

     suite.addTestCase({
         name: "BasicBreakpoint",
         description: "Check that breakpoint is in a valid initial state.",
         teardown,
         test(resolve, reject) {
             addBreakpointForElementIdentifier(subtreeModifiedTestId, WI.DOMBreakpoint.Type.SubtreeModified)
             .then((event) => {
                 let breakpoint = event.data.breakpoint;
                 InspectorTest.expectFalse(breakpoint.disabled, "Breakpoint should not be disabled.");
                 InspectorTest.expectThat(breakpoint.domNodeIdentifier, "Breakpoint should have node identifier.");

                 InspectorTest.assert(WI.networkManager.mainFrame, "Missing main frame.");
                 let documentURL = WI.networkManager.mainFrame.url;
                 InspectorTest.expectEqual(breakpoint.url, documentURL, "Breakpoint URL should match document URL.");
             })
             .then(resolve, reject);
         }
     });

     addTestsForBreakpointType({
         name: "SubtreeModified",
         elementIdentifier: subtreeModifiedTestId,
         type: WI.DOMBreakpoint.Type.SubtreeModified,
         expression: "subtreeModifiedTest()",
         insertion: true,
         shouldMatch: true,
     });

     addTestsForBreakpointType({
         name: "AttributeModified",
         elementIdentifier: attributeModifiedTestId,
         type: WI.DOMBreakpoint.Type.AttributeModified,
         expression: "attributeModifiedTest()",
     });

     addTestsForBreakpointType({
         name: "NodeRemovedSelf",
         elementIdentifier: nodeRemovedDirectTestId,
         type: WI.DOMBreakpoint.Type.NodeRemoved,
         expression: "nodeRemovedDirectTest()",
     });

     addTestsForBreakpointType({
         name: "NodeRemovedAncestor",
         elementIdentifier: nodeRemovedAncestorTestId,
         type: WI.DOMBreakpoint.Type.NodeRemoved,
         expression: "nodeRemovedAncestorTest()",
         shouldMatch: true,
     });

     suite.addTestCase({
         name: "RemoveAllBreakpointsForNode",
         description: "Check that debugger does not pause for removed breakpoints on node.",
         teardown,
         test(resolve, reject) {
             let breakpointTypes = Object.values(WI.DOMBreakpoint.Type);
             let breakpointPromises = breakpointTypes.map(type => addBreakpointForElementIdentifier(multipleBreakpointsTestId, type));

             Promise.all(breakpointPromises)
             .then((values) => {
                 let breakpoints = values.map(event => event.data.breakpoint);
                 if (!breakpoints.length) {
                     InspectorTest.fail("No breakpoints added.");
                     reject();
                     return;
                 }

                 let node = WI.domManager.nodeForId(breakpoints[0].domNodeIdentifier);
                 if (!node) {
                     InspectorTest.fail("No DOM node associated with breakpoint.");
                     reject();
                     return;
                 }

                 let breakpointsRemoved = 0;

                 function breakpointRemoved() {
                     if (++breakpointsRemoved === breakpoints.length) {
                         InspectorTest.pass(`Removed ${breakpointsRemoved} breakpoints.`);

                         let nodeBreakpoints = WI.domDebuggerManager.domBreakpointsForNode(node);
                         InspectorTest.expectThat(!nodeBreakpoints.length, "DOM node should have no breakpoints.");

                         WI.domDebuggerManager.removeEventListener(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, breakpointRemoved);
                         resolve();
                     }
                 }

                 WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, breakpointRemoved);
                 WI.domDebuggerManager.removeDOMBreakpointsForNode(node);
             })
             .then(resolve, reject);
         }
     });

     suite.addTestCase({
         name: "SetBreakpointWithInvalidNodeId",
         description: "Check that setting a breakpoint for a nonexistant node returns an error.",
         teardown,
         test(resolve, reject) {
             InspectorTest.log("Attempting to set breakpoint.");

             DOMDebuggerAgent.setDOMBreakpoint(0, WI.DOMBreakpoint.Type.SubtreeModified, (error) => {
                 InspectorTest.log("Protocol result: " + error);
                 InspectorTest.expectThat(error, "Protocol should return an error.")
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "SetBreakpointWithInvalidType",
         description: "Check that setting a breakpoint with an invalid type returns an error.",
         teardown,
         test(resolve, reject) {
             awaitQuerySelector("body")
             .then((node) => {
                 InspectorTest.log("Attempting to set breakpoint.");

                 DOMDebuggerAgent.setDOMBreakpoint(node.id, "custom-breakpoint-type", (error) => {
                     InspectorTest.log("Protocol result: " + error);
                     InspectorTest.expectThat(error, "Protocol should return an error.")
                     resolve();
                 });
             });
         }
     });

     suite.addTestCase({
         name: "RemoveBreakpointWithInvalidNodeId",
         description: "Check that removing a breakpoint for a nonexistant node returns an error.",
         teardown,
         test(resolve, reject) {
             InspectorTest.log("Attempting to remove breakpoint.");

             DOMDebuggerAgent.removeDOMBreakpoint(0, WI.DOMBreakpoint.Type.SubtreeModified, (error) => {
                 InspectorTest.log("Protocol result: " + error);
                 InspectorTest.expectThat(error, "Protocol should return an error.")
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "RemoveBreakpointWithInvalidType",
         description: "Check that removing a breakpoint with an invalid type returns an error.",
         teardown,
         test(resolve, reject) {
             awaitQuerySelector("body")
             .then((node) => {
                 InspectorTest.log("Attempting to remove breakpoint.");

                 DOMDebuggerAgent.removeDOMBreakpoint(node.id, "custom-breakpoint-type", (error) => {
                     InspectorTest.log("Protocol result: " + error);
                     InspectorTest.expectThat(error, "Protocol should return an error.")
                     resolve();
                 });
             });
         }
     });

     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
 <p>Tests for DOM breakpoints.</p>
 <div id="test-container" style="display: none">
     <div id="subtree-modified-test"></div>
     <div id="attribute-modified-test"></div>
     <div id="node-removed-direct-test"></div>
     <div><div id="node-removed-ancestor-test"></div></div>
     <div id="multiple-breakpoints-test"></div>
 </div>
 </body>
 </html>
	<!doctype html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script src="../debugger/resources/log-active-stack-trace.js"></script>
	<script>
	function subtreeModifiedTest() {
	document.getElementById("subtree-modified-test").append(document.createElement("p"));
	}

	function attributeModifiedTest() {
	document.getElementById("attribute-modified-test").setAttribute("display", "none");
	}

	function nodeRemovedDirectTest() {
	let node = document.getElementById("node-removed-direct-test");
	let parent = node.parentNode;
	node.remove();
	parent.append(node);
	}

	function nodeRemovedAncestorTest() {
	let node = document.getElementById("node-removed-ancestor-test");
	let parent = node.parentNode;
	let grandparent = parent.parentNode;
	parent.remove(node);
	grandparent.append(parent);
	}

	function test()
	{
	const subtreeModifiedTestId = "subtree-modified-test";
	const attributeModifiedTestId = "attribute-modified-test";
	const nodeRemovedDirectTestId = "node-removed-direct-test";
	const nodeRemovedAncestorTestId = "node-removed-ancestor-test";
	const multipleBreakpointsTestId = "multiple-breakpoints-test";

	let debuggerPausedListener = null;

	let suite = InspectorTest.createAsyncSuite("DOMBreakpoints");

	function teardown(resolve) {
	let breakpoints = WI.domDebuggerManager.domBreakpoints;
	for (let breakpoint of breakpoints)
	WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);
	InspectorTest.assert(!WI.domDebuggerManager.domBreakpoints.length);

	WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, debuggerPausedListener);
	debuggerPausedListener = null;

	resolve();
	}

	function rejectOnPause() {
	return new Promise((resolve, reject) => {
	InspectorTest.assert(!debuggerPausedListener);
	debuggerPausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
	WI.debuggerManager.resume();
	InspectorTest.fail("Should not pause.");
	reject();
	});
	});
	}

	function awaitEvaluateInPage(expression) {
	return new Promise((resolve, reject) => {
	InspectorTest.log("Wait for evaluate in page to return.");
	InspectorTest.evaluateInPage(expression, (error) => {
	if (error)
	reject(error);

	resolve();
	});
	});
	}

	function awaitQuerySelector(selector) {
	return new Promise((resolve, reject) => {
	WI.domManager.requestDocument((documentNode) => {
	if (!documentNode) {
	reject();
	return;
	}

	WI.domManager.querySelector(documentNode.id, selector, (nodeId) => {
	if (!nodeId) {
	InspectorTest.fail("Selector returned no nodes.", selector);
	reject();
	return;
	}

	let node = WI.domManager.nodeForId(nodeId);
	InspectorTest.assert(node, "Missing node for id.", nodeId);
	if (!node) {
	reject();
	return;
	}

	resolve(node);
	});
	});
	});
	}

	function addBreakpointForElementIdentifier(elementIdentifier, type, disabled) {
	return new Promise((resolve, reject) => {
	awaitQuerySelector("#" + elementIdentifier)
	.then((node) => {
	WI.domDebuggerManager.awaitEvent(WI.DOMDebuggerManager.Event.DOMBreakpointAdded)
	.then((event) => {
	let breakpoint = event.data.breakpoint;
	InspectorTest.pass(`Added '${type}' breakpoint.`);
	resolve(event);
	});

	WI.domDebuggerManager.addDOMBreakpoint(new WI.DOMBreakpoint(node, type, {disabled}));
	});
	});
	}

	function addTestsForBreakpointType({name, elementIdentifier, type, expression, insertion, shouldMatch}) {
	suite.addTestCase({
	name: `DOMBreakpoints.${name}.BreakpointEnabled`,
	description: "Check that debugger pauses for breakpoint type.",
	teardown,
	test(resolve, reject) {
	addBreakpointForElementIdentifier(elementIdentifier, type)
	.then((event) => {
	let breakpoint = event.data.breakpoint;
	InspectorTest.expectEqual(breakpoint.type, type, "Breakpoint should have expected type.");

	InspectorTest.log("Call DOM operation.");
	InspectorTest.evaluateInPage(expression);
	return WI.debuggerManager.awaitEvent(WI.DebuggerManager.Event.Paused);
	})
	.then(() => {
	let targetData = WI.debuggerManager.dataForTarget(WI.debuggerManager.activeCallFrame.target);
	InspectorTest.log("PAUSED:");
	InspectorTest.expectEqual(targetData.pauseReason, WI.DebuggerManager.PauseReason.DOM, "Pause reason should be DOM.");

	let pauseData = targetData.pauseData;
	InspectorTest.expectEqual(pauseData.type, type, `Pause type should be '${type}'.`);
	InspectorTest.expectEqual(pauseData.nodeId, domNodeIdentifier, `Pause nodeId should be expected value.`);

	if (insertion !== undefined)
	InspectorTest.expectEqual(insertion, target.pauseData.insertion, `Pause insertion should be '${insertion}'.`);

	if (pauseData.targetNodeId) {
	if (shouldMatch)
	InspectorTest.expectEqual(pauseData.targetNodeId, pauseData.nodeId, "Pause targetNodeId should match nodeId.");
	else
	InspectorTest.expectNotEqual(pauseData.targetNodeId, pauseData.nodeId, "Pause targetNodeId should not match nodeId.");
	}

	logActiveStackTrace();
	return WI.debuggerManager.resume();
	})
	.then(resolve, reject);
	}
	});

	suite.addTestCase({
	name: `DOMBreakpoints.${name}.BreakpointDisabled`,
	description: "Check that debugger does not pause for disabled breakpoint.",
	teardown,
	test(resolve, reject) {
	const disabled = true;
	addBreakpointForElementIdentifier(elementIdentifier, type, disabled)
	.then(() => Promise.race([awaitEvaluateInPage(expression), rejectOnPause()]))
	.then(() => {
	InspectorTest.pass("Should not pause for disabled breakpoint.");
	resolve();
	})
	.catch(reject);
	}
	});

	suite.addTestCase({
	name: `DOMBreakpoints.${name}.DebuggerDisabled`,
	description: "Check that debugger does not pause when the debugger is disabled.",
	teardown,
	test(resolve, reject) {
	addBreakpointForElementIdentifier(elementIdentifier, type)
	.then(() => DebuggerAgent.setBreakpointsActive(false))
	.then(() => Promise.race([awaitEvaluateInPage(expression), rejectOnPause()]))
	.then(() => DebuggerAgent.setBreakpointsActive(true))
	.then(() => {
	InspectorTest.pass("Should not pause for disabled breakpoint.");
	resolve();
	})
	.catch(reject);
	}
	});

	suite.addTestCase({
	name: `DOMBreakpoints.${name}.RemoveBreakpoint`,
	description: "Check that debugger does not pause for removed breakpoint.",
	teardown,
	test(resolve, reject) {
	addBreakpointForElementIdentifier(elementIdentifier, type)
	.then((event) => {
	let promise = WI.domDebuggerManager.awaitEvent(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved);
	let breakpoint = event.data.breakpoint;

	InspectorTest.log("Remove breakpoint.");
	WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);
	return promise;
	})
	.then(() => Promise.race([awaitEvaluateInPage(expression), rejectOnPause()]))
	.then(() => {
	InspectorTest.pass("Should not pause for removed breakpoint.");
	resolve();
	})
	.catch(reject);
	}
	});
	}

	suite.addTestCase({
	name: "BasicBreakpoint",
	description: "Check that breakpoint is in a valid initial state.",
	teardown,
	test(resolve, reject) {
	addBreakpointForElementIdentifier(subtreeModifiedTestId, WI.DOMBreakpoint.Type.SubtreeModified)
	.then((event) => {
	let breakpoint = event.data.breakpoint;
	InspectorTest.expectFalse(breakpoint.disabled, "Breakpoint should not be disabled.");
	InspectorTest.expectThat(breakpoint.domNodeIdentifier, "Breakpoint should have node identifier.");

	InspectorTest.assert(WI.networkManager.mainFrame, "Missing main frame.");
	let documentURL = WI.networkManager.mainFrame.url;
	InspectorTest.expectEqual(breakpoint.url, documentURL, "Breakpoint URL should match document URL.");
	})
	.then(resolve, reject);
	}
	});

	addTestsForBreakpointType({
	name: "SubtreeModified",
	elementIdentifier: subtreeModifiedTestId,
	type: WI.DOMBreakpoint.Type.SubtreeModified,
	expression: "subtreeModifiedTest()",
	insertion: true,
	shouldMatch: true,
	});

	addTestsForBreakpointType({
	name: "AttributeModified",
	elementIdentifier: attributeModifiedTestId,
	type: WI.DOMBreakpoint.Type.AttributeModified,
	expression: "attributeModifiedTest()",
	});

	addTestsForBreakpointType({
	name: "NodeRemovedSelf",
	elementIdentifier: nodeRemovedDirectTestId,
	type: WI.DOMBreakpoint.Type.NodeRemoved,
	expression: "nodeRemovedDirectTest()",
	});

	addTestsForBreakpointType({
	name: "NodeRemovedAncestor",
	elementIdentifier: nodeRemovedAncestorTestId,
	type: WI.DOMBreakpoint.Type.NodeRemoved,
	expression: "nodeRemovedAncestorTest()",
	shouldMatch: true,
	});

	suite.addTestCase({
	name: "RemoveAllBreakpointsForNode",
	description: "Check that debugger does not pause for removed breakpoints on node.",
	teardown,
	test(resolve, reject) {
	let breakpointTypes = Object.values(WI.DOMBreakpoint.Type);
	let breakpointPromises = breakpointTypes.map(type => addBreakpointForElementIdentifier(multipleBreakpointsTestId, type));

	Promise.all(breakpointPromises)
	.then((values) => {
	let breakpoints = values.map(event => event.data.breakpoint);
	if (!breakpoints.length) {
	InspectorTest.fail("No breakpoints added.");
	reject();
	return;
	}

	let node = WI.domManager.nodeForId(breakpoints[0].domNodeIdentifier);
	if (!node) {
	InspectorTest.fail("No DOM node associated with breakpoint.");
	reject();
	return;
	}

	let breakpointsRemoved = 0;

	function breakpointRemoved() {
	if (++breakpointsRemoved === breakpoints.length) {
	InspectorTest.pass(`Removed ${breakpointsRemoved} breakpoints.`);

	let nodeBreakpoints = WI.domDebuggerManager.domBreakpointsForNode(node);
	InspectorTest.expectThat(!nodeBreakpoints.length, "DOM node should have no breakpoints.");

	WI.domDebuggerManager.removeEventListener(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, breakpointRemoved);
	resolve();
	}
	}

	WI.domDebuggerManager.addEventListener(WI.DOMDebuggerManager.Event.DOMBreakpointRemoved, breakpointRemoved);
	WI.domDebuggerManager.removeDOMBreakpointsForNode(node);
	})
	.then(resolve, reject);
	}
	});

	suite.addTestCase({
	name: "SetBreakpointWithInvalidNodeId",
	description: "Check that setting a breakpoint for a nonexistant node returns an error.",
	teardown,
	test(resolve, reject) {
	InspectorTest.log("Attempting to set breakpoint.");

	DOMDebuggerAgent.setDOMBreakpoint(0, WI.DOMBreakpoint.Type.SubtreeModified, (error) => {
	InspectorTest.log("Protocol result: " + error);
	InspectorTest.expectThat(error, "Protocol should return an error.")
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "SetBreakpointWithInvalidType",
	description: "Check that setting a breakpoint with an invalid type returns an error.",
	teardown,
	test(resolve, reject) {
	awaitQuerySelector("body")
	.then((node) => {
	InspectorTest.log("Attempting to set breakpoint.");

	DOMDebuggerAgent.setDOMBreakpoint(node.id, "custom-breakpoint-type", (error) => {
	InspectorTest.log("Protocol result: " + error);
	InspectorTest.expectThat(error, "Protocol should return an error.")
	resolve();
	});
	});
	}
	});

	suite.addTestCase({
	name: "RemoveBreakpointWithInvalidNodeId",
	description: "Check that removing a breakpoint for a nonexistant node returns an error.",
	teardown,
	test(resolve, reject) {
	InspectorTest.log("Attempting to remove breakpoint.");

	DOMDebuggerAgent.removeDOMBreakpoint(0, WI.DOMBreakpoint.Type.SubtreeModified, (error) => {
	InspectorTest.log("Protocol result: " + error);
	InspectorTest.expectThat(error, "Protocol should return an error.")
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "RemoveBreakpointWithInvalidType",
	description: "Check that removing a breakpoint with an invalid type returns an error.",
	teardown,
	test(resolve, reject) {
	awaitQuerySelector("body")
	.then((node) => {
	InspectorTest.log("Attempting to remove breakpoint.");

	DOMDebuggerAgent.removeDOMBreakpoint(node.id, "custom-breakpoint-type", (error) => {
	InspectorTest.log("Protocol result: " + error);
	InspectorTest.expectThat(error, "Protocol should return an error.")
	resolve();
	});
	});
	}
	});

	suite.runTestCasesAndFinish();
	}
	</script>
	</head>
	<body onload="runTest()">
	<p>Tests for DOM breakpoints.</p>
	<div id="test-container" style="display: none">
	<div id="subtree-modified-test"></div>
	<div id="attribute-modified-test"></div>
	<div id="node-removed-direct-test"></div>
	<div><div id="node-removed-ancestor-test"></div></div>
	<div id="multiple-breakpoints-test"></div>
	</div>
	</body>
	</html>