LayoutTests/inspector/dom-debugger/dom-breakpoint-node-removed-ancestor.html - WebKit - Git at Google

 <!doctype html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script src="../debugger/resources/breakpoint-options-utilities.js"></script>
 <script src="../debugger/resources/log-active-stack-trace.js"></script>
 <script src="resources/dom-breakpoint-utilities.js"></script>
 <script>
 function testNodeRemovedAncestor() {
     let node = document.getElementById("node-removed-ancestor-test");
     let parent = node.parentNode;
     let grandparent = parent.parentNode;
     parent.remove();
     grandparent.appendChild(parent);
 }

 function test()
 {
     let suite = InspectorTest.createAsyncSuite("DOMBreakpoint.NodeRemoved");

     suite.addTestCase({
         name: `DOMBreakpoint.NodeRemoved.Ancestor.BreakpointEnabled`,
         description: "Check that debugger pauses for breakpoint type.",
         async test() {
             let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

             let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

             let paused = false;
             let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                 paused = true;

                 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, breakpoint.type, `Pause type should be '${breakpoint.type}'.`);
                 InspectorTest.expectEqual(pauseData.nodeId, breakpoint.domNode.id, "Pause nodeId should be expected value.");
                 InspectorTest.expectEqual(pauseData.targetNodeId, node.parentNode.id, "Pause targetNodeId should be expected value.");
                 InspectorTest.assert(!("insertion" in pauseData), "Should not have 'insertion'.");

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

             await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

             InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

             InspectorTest.assert(paused, "Should pause.");
             WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
         },
         teardown: InspectorTest.DOMBreakpoint.teardown,
     });

     suite.addTestCase({
         name: `DOMBreakpoint.NodeRemoved.Ancestor.BreakpointDisabled`,
         description: "Check that debugger does not pause for disabled breakpoint.",
         async test() {
             let paused = false;
             let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                 paused = true;

                 WI.debuggerManager.resume();
             });

             let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

             let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

             InspectorTest.log("Disabling breakpoint...");
             breakpoint.disabled = true;

             InspectorTest.assert(breakpoint.domNode === node, "Should have domNode.");

             InspectorTest.log("Triggering breakpoint...");
             await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

             InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

             InspectorTest.expectFalse(paused, "Should not pause for disabled breakpoint.");
             WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
         },
         teardown: InspectorTest.DOMBreakpoint.teardown,
     });

     suite.addTestCase({
         name: `DOMBreakpoint.NodeRemoved.Ancestor.DebuggerDisabled`,
         description: "Check that debugger does not pause when the debugger is disabled.",
         async test() {
             let paused = false;
             let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                 paused = true;

                 WI.debuggerManager.resume();
             });

             let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

             let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

             InspectorTest.log("Disabling all breakpoints...");
             await DebuggerAgent.setBreakpointsActive(false);

             InspectorTest.log("Triggering breakpoint...");
             await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

             InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

             InspectorTest.log("Enabling all breakpoints...");
             await DebuggerAgent.setBreakpointsActive(true);

             InspectorTest.expectFalse(paused, "Should not pause when all breakpoints disabled.");
             WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
         },
         teardown: InspectorTest.DOMBreakpoint.teardown,
     });

     suite.addTestCase({
         name: `DOMBreakpoint.NodeRemoved.Ancestor.RemoveBreakpoint`,
         description: "Check that debugger does not pause for removed breakpoint.",
         async test() {
             let paused = false;
             let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                 paused = true;

                 WI.debuggerManager.resume();
             });

             let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

             let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

             InspectorTest.log("Removing breakpoint...");
             WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);

             InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

             InspectorTest.log("Triggering breakpoint...");
             await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

             InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

             InspectorTest.expectFalse(paused, "Should not pause for removed breakpoint.");
             WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
         },
         teardown: InspectorTest.DOMBreakpoint.teardown,
     });

     InspectorTest.BreakpointOptions.addTestCases(suite, {
         testCaseNamePrefix: "Ancestor.",
         async createBreakpoint() {
             let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");
             return InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);
         },
         async triggerBreakpoint(breakpoint) {
             let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");
             InspectorTest.assert(breakpoint.domNode === node, "Should have domNode.");
             return InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);
         },
         skip: {
             ignoreCount: true,
         },
     });

     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
 <p>Tests for DOM breakpoints.</p>
 <div id="test-container" style="display: none">
     <div><div id="node-removed-ancestor-test"></div></div>
 </div>
 </body>
 </html>
	<!doctype html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script src="../debugger/resources/breakpoint-options-utilities.js"></script>
	<script src="../debugger/resources/log-active-stack-trace.js"></script>
	<script src="resources/dom-breakpoint-utilities.js"></script>
	<script>
	function testNodeRemovedAncestor() {
	let node = document.getElementById("node-removed-ancestor-test");
	let parent = node.parentNode;
	let grandparent = parent.parentNode;
	parent.remove();
	grandparent.appendChild(parent);
	}

	function test()
	{
	let suite = InspectorTest.createAsyncSuite("DOMBreakpoint.NodeRemoved");

	suite.addTestCase({
	name: `DOMBreakpoint.NodeRemoved.Ancestor.BreakpointEnabled`,
	description: "Check that debugger pauses for breakpoint type.",
	async test() {
	let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

	let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

	let paused = false;
	let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
	paused = true;

	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, breakpoint.type, `Pause type should be '${breakpoint.type}'.`);
	InspectorTest.expectEqual(pauseData.nodeId, breakpoint.domNode.id, "Pause nodeId should be expected value.");
	InspectorTest.expectEqual(pauseData.targetNodeId, node.parentNode.id, "Pause targetNodeId should be expected value.");
	InspectorTest.assert(!("insertion" in pauseData), "Should not have 'insertion'.");

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

	await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

	InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

	InspectorTest.assert(paused, "Should pause.");
	WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
	},
	teardown: InspectorTest.DOMBreakpoint.teardown,
	});

	suite.addTestCase({
	name: `DOMBreakpoint.NodeRemoved.Ancestor.BreakpointDisabled`,
	description: "Check that debugger does not pause for disabled breakpoint.",
	async test() {
	let paused = false;
	let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
	paused = true;

	WI.debuggerManager.resume();
	});

	let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

	let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

	InspectorTest.log("Disabling breakpoint...");
	breakpoint.disabled = true;

	InspectorTest.assert(breakpoint.domNode === node, "Should have domNode.");

	InspectorTest.log("Triggering breakpoint...");
	await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

	InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

	InspectorTest.expectFalse(paused, "Should not pause for disabled breakpoint.");
	WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
	},
	teardown: InspectorTest.DOMBreakpoint.teardown,
	});

	suite.addTestCase({
	name: `DOMBreakpoint.NodeRemoved.Ancestor.DebuggerDisabled`,
	description: "Check that debugger does not pause when the debugger is disabled.",
	async test() {
	let paused = false;
	let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
	paused = true;

	WI.debuggerManager.resume();
	});

	let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

	let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

	InspectorTest.log("Disabling all breakpoints...");
	await DebuggerAgent.setBreakpointsActive(false);

	InspectorTest.log("Triggering breakpoint...");
	await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

	InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

	InspectorTest.log("Enabling all breakpoints...");
	await DebuggerAgent.setBreakpointsActive(true);

	InspectorTest.expectFalse(paused, "Should not pause when all breakpoints disabled.");
	WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
	},
	teardown: InspectorTest.DOMBreakpoint.teardown,
	});

	suite.addTestCase({
	name: `DOMBreakpoint.NodeRemoved.Ancestor.RemoveBreakpoint`,
	description: "Check that debugger does not pause for removed breakpoint.",
	async test() {
	let paused = false;
	let pausedListener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.Paused, (event) => {
	paused = true;

	WI.debuggerManager.resume();
	});

	let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");

	let breakpoint = await InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);

	InspectorTest.log("Removing breakpoint...");
	WI.domDebuggerManager.removeDOMBreakpoint(breakpoint);

	InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

	InspectorTest.log("Triggering breakpoint...");
	await InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);

	InspectorTest.assert(!breakpoint.domNode, "Should not have domNode.");

	InspectorTest.expectFalse(paused, "Should not pause for removed breakpoint.");
	WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.Paused, pausedListener);
	},
	teardown: InspectorTest.DOMBreakpoint.teardown,
	});

	InspectorTest.BreakpointOptions.addTestCases(suite, {
	testCaseNamePrefix: "Ancestor.",
	async createBreakpoint() {
	let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");
	return InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.NodeRemoved);
	},
	async triggerBreakpoint(breakpoint) {
	let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#node-removed-ancestor-test");
	InspectorTest.assert(breakpoint.domNode === node, "Should have domNode.");
	return InspectorTest.evaluateInPage(`testNodeRemovedAncestor()`);
	},
	skip: {
	ignoreCount: true,
	},
	});

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