LayoutTests/inspector/dom-debugger/dom-breakpoint-subtree-modified-remove.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 testSubtreeModified() {
     document.getElementById("subtree-modified-test").appendChild(document.createElement("div"));
 }

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

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

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

             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.expectTrue(pauseData.insertion, "Should have 'insertion'.");
                 InspectorTest.assert(!("targetNodeId" in pauseData), "Should not have 'targetNodeId'.");

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

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

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

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

     suite.addTestCase({
         name: `DOMBreakpoint.SubtreeModified.Remove.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("#subtree-modified-test");

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

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

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

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

             InspectorTest.assert(breakpoint.domNode === node, "Should 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.SubtreeModified.Remove.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("#subtree-modified-test");

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

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

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

             InspectorTest.assert(breakpoint.domNode === node, "Should 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.SubtreeModified.Remove.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("#subtree-modified-test");

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

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

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

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

             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: "Remove.",
         async createBreakpoint() {
             let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#subtree-modified-test");
             return InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.SubtreeModified);
         },
         async triggerBreakpoint(breakpoint) {
             InspectorTest.assert(breakpoint.domNode, "Should have domNode.");
             return InspectorTest.evaluateInPage(`testSubtreeModified()`);
         },
     });

     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>
 </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 testSubtreeModified() {
	document.getElementById("subtree-modified-test").appendChild(document.createElement("div"));
	}

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

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

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

	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.expectTrue(pauseData.insertion, "Should have 'insertion'.");
	InspectorTest.assert(!("targetNodeId" in pauseData), "Should not have 'targetNodeId'.");

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

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

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

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

	suite.addTestCase({
	name: `DOMBreakpoint.SubtreeModified.Remove.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("#subtree-modified-test");

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

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

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

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

	InspectorTest.assert(breakpoint.domNode === node, "Should 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.SubtreeModified.Remove.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("#subtree-modified-test");

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

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

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

	InspectorTest.assert(breakpoint.domNode === node, "Should 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.SubtreeModified.Remove.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("#subtree-modified-test");

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

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

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

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

	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: "Remove.",
	async createBreakpoint() {
	let node = await InspectorTest.DOMBreakpoint.awaitQuerySelector("#subtree-modified-test");
	return InspectorTest.DOMBreakpoint.createBreakpoint(node, WI.DOMBreakpoint.Type.SubtreeModified);
	},
	async triggerBreakpoint(breakpoint) {
	InspectorTest.assert(breakpoint.domNode, "Should have domNode.");
	return InspectorTest.evaluateInPage(`testSubtreeModified()`);
	},
	});

	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>
	</body>
	</html>