LayoutTests/inspector/worker/debugger-multiple-targets-pause.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script src="../debugger/resources/log-pause-location.js"></script>
 <script>
 let worker1, worker2;
 let testVariable = "main thread";

 function triggerStartWorkers() {
     worker1 = new Worker("resources/worker-debugger-thread-1.js");
     worker2 = new Worker("resources/worker-debugger-thread-2.js");
 }

 function triggerWork() {
     worker1.postMessage("doWork");
     worker2.postMessage("doWork");
     setTimeout(workOnMainThread, 250);
 }

 function workOnMainThread() {
     TestPage.dispatchEventToFrontend("MainThreadDidWork");
     Date.now();
 }

 function test()
 {
     let mainTarget = WI.mainTarget;
     let workerTarget1;
     let workerTarget2;

     function areAllTargetsPaused() {
         for (let target of WI.targets) {
             let targetData = WI.debuggerManager.dataForTarget(target);
             if (!targetData.paused)
                 return false;
         }
         return true;
     }

     function areAllTargetsUnpaused() {
         for (let target of WI.targets) {
             let targetData = WI.debuggerManager.dataForTarget(target);
             if (targetData.paused)
                 return false;
         }
         return true;
     }

     function dumpCallFrames() {
         InspectorTest.log("");
         for (let target of WI.targets) {
             InspectorTest.log(`TARGET: ${target.displayName}`);
             let targetData = WI.debuggerManager.dataForTarget(target);
             let callFrames = targetData.callFrames;
             for (let i = 0; i < callFrames.length; ++i) {
                 let callFrame = callFrames[i];
                 let active = callFrame === WI.debuggerManager.activeCallFrame;
                 InspectorTest.log(` ${active ? "*" : " "} CALL FRAME #${i + 1}: ${callFrame.functionName}`);
             }
         }
     }

     let okayToReceiveMainThreadEvent = false;
     InspectorTest.singleFireEventListener("MainThreadDidWork", (event) => {
         if (!okayToReceiveMainThreadEvent) {
             InspectorTest.fail("Main Thread's work fired before it could pause. Failing early.");
             InspectorTest.completeTest();
         }
     });

     let suite = InspectorTest.createAsyncSuite("Worker.Debugger.Threads");

     suite.addTestCase({
         name: "Worker.Debugger.Threads.CreateThreads",
         description: "Spawn multiple targets.",
         test(resolve, reject) {
             InspectorTest.evaluateInPage(`triggerStartWorkers()`);
             WI.targetManager.singleFireEventListener(WI.TargetManager.Event.TargetAdded, (event) => {
                 InspectorTest.pass("Created Worker 1");
                 workerTarget1 = event.data.target;
                 WI.targetManager.singleFireEventListener(WI.TargetManager.Event.TargetAdded, (event) => {
                     InspectorTest.pass("Created Worker 2");
                     workerTarget2 = event.data.target;
                     resolve();
                 });
             });
         }
     });

     suite.addTestCase({
         name: "Worker.Debugger.Threads.Pause",
         description: "Should be able to pause in multiple targets.",
         test(resolve, reject) {
             InspectorTest.evaluateInPage(`triggerWork()`);

             let receivedCallFramesDidChange = false;
             let receivedPauseBeforeCallFramesDidChange = false;
             let otherTargetsPausing = false;

             WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Paused, (event) => {
                 receivedPauseBeforeCallFramesDidChange = !receivedCallFramesDidChange;
                 otherTargetsPausing = WI.debuggerManager.dataForTarget(mainTarget).pausing && WI.debuggerManager.dataForTarget(workerTarget2).pausing;
             });

             let listener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
                 receivedCallFramesDidChange = true;
                 if (!areAllTargetsPaused())
                     return;

                 WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.CallFramesDidChange, listener);

                 let activeCallFrame = WI.debuggerManager.activeCallFrame;
                 InspectorTest.assert(activeCallFrame.target === workerTarget1);

                 InspectorTest.expectThat(receivedPauseBeforeCallFramesDidChange, "Paused event should happen before CallFramesDidChange event.");
                 InspectorTest.expectThat(otherTargetsPausing, "In Paused event all other Targets should be pausing.");
                 InspectorTest.expectEqual(activeCallFrame.target.displayName, "worker-debugger-thread-1.js", "Worker 1 should be the first to pause.");
                 InspectorTest.pass("All Targets should eventually pause.");
                 dumpCallFrames();
                 resolve();
             });
         }
     });

     function addEvaluateTestCase({name, targetResolver, expected}) {
         suite.addTestCase({
             name, description: "Should be able to evaluate in different threads while paused.",
             test(resolve, reject) {
                 let target = targetResolver();
                 let targetData = WI.debuggerManager.dataForTarget(target);
                 WI.debuggerManager.activeCallFrame = targetData.callFrames[0];
                 WI.runtimeManager.evaluateInInspectedWindow("testVariable", {objectGroup: "test", includeCommandLineAPI: true}, (remoteObject) => {
                     InspectorTest.expectEqual(remoteObject.description, expected, `Evaluated result in ${target.displayName} should be ${JSON.stringify(expected)}.`)
                     resolve();
                 });
             }
         });
     }

     addEvaluateTestCase({
         name: "Worker.Debugger.Threads.Paused.Worker1Evaluate",
         targetResolver: () => workerTarget1,
         expected: "worker thread 1",
     });

     addEvaluateTestCase({
         name: "Worker.Debugger.Threads.Paused.Worker2Evaluate",
         targetResolver: () => workerTarget2,
         expected: "worker thread 2",
     });

     addEvaluateTestCase({
         name: "Worker.Debugger.Threads.Paused.MainEvaluate",
         targetResolver: () => mainTarget,
         expected: "main thread",
     });

     suite.addTestCase({
         name: "Worker.Debugger.Threads.Paused.Worker1.StepOut",
         description: "Should be able to step in individual threads and not affect the others.",
         test(resolve, reject) {
             let targetData = WI.debuggerManager.dataForTarget(workerTarget1);
             WI.debuggerManager.activeCallFrame = targetData.callFrames[0];
             WI.debuggerManager.stepOut();
             WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
                 InspectorTest.expectEqual(event.data.target, workerTarget1, "Should receive CallFramesDidChange for Worker 1.");
                 dumpCallFrames();
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "Worker.Debugger.Threads.Paused.Worker2.ResumeThread",
         description: "Should be able to resume an individual thread and not affect the others.",
         test(resolve, reject) {
             let targetData = WI.debuggerManager.dataForTarget(workerTarget2);
             WI.debuggerManager.continueUntilNextRunLoop(workerTarget2);
             WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
                 InspectorTest.expectEqual(event.data.target, workerTarget2, "Should Receive CallFramesDidChange for Worker 2.");
                 InspectorTest.expectThat(targetData.pausing, "Worker 2 should be pausing.");
                 WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
                     InspectorTest.expectEqual(event.data.target, workerTarget2, "Should Receive CallFramesDidChange for Worker 2.");
                     InspectorTest.expectThat(targetData.paused, "Worker 2 should be paused.");
                     dumpCallFrames();
                     resolve();
                 });
             });
         }
     });

     suite.addTestCase({
         name: "Worker.Debugger.Threads.Complete",
         description: "Resume all threads for the test to complete.",
         test(resolve, reject) {
             okayToReceiveMainThreadEvent = true;
             WI.debuggerManager.resume();
             WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Resumed, () => {
                 InspectorTest.pass("Received Resume event.");
                 InspectorTest.expectThat(areAllTargetsUnpaused(), "All Targets should be unpaused.");
                 resolve();
             });
         }
     });

     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
 <p>Ensure we can pause in multiple targets and evaluate in each.</p>
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script src="../debugger/resources/log-pause-location.js"></script>
	<script>
	let worker1, worker2;
	let testVariable = "main thread";

	function triggerStartWorkers() {
	worker1 = new Worker("resources/worker-debugger-thread-1.js");
	worker2 = new Worker("resources/worker-debugger-thread-2.js");
	}

	function triggerWork() {
	worker1.postMessage("doWork");
	worker2.postMessage("doWork");
	setTimeout(workOnMainThread, 250);
	}

	function workOnMainThread() {
	TestPage.dispatchEventToFrontend("MainThreadDidWork");
	Date.now();
	}

	function test()
	{
	let mainTarget = WI.mainTarget;
	let workerTarget1;
	let workerTarget2;

	function areAllTargetsPaused() {
	for (let target of WI.targets) {
	let targetData = WI.debuggerManager.dataForTarget(target);
	if (!targetData.paused)
	return false;
	}
	return true;
	}

	function areAllTargetsUnpaused() {
	for (let target of WI.targets) {
	let targetData = WI.debuggerManager.dataForTarget(target);
	if (targetData.paused)
	return false;
	}
	return true;
	}

	function dumpCallFrames() {
	InspectorTest.log("");
	for (let target of WI.targets) {
	InspectorTest.log(`TARGET: ${target.displayName}`);
	let targetData = WI.debuggerManager.dataForTarget(target);
	let callFrames = targetData.callFrames;
	for (let i = 0; i < callFrames.length; ++i) {
	let callFrame = callFrames[i];
	let active = callFrame === WI.debuggerManager.activeCallFrame;
	InspectorTest.log(` ${active ? "*" : " "} CALL FRAME #${i + 1}: ${callFrame.functionName}`);
	}
	}
	}

	let okayToReceiveMainThreadEvent = false;
	InspectorTest.singleFireEventListener("MainThreadDidWork", (event) => {
	if (!okayToReceiveMainThreadEvent) {
	InspectorTest.fail("Main Thread's work fired before it could pause. Failing early.");
	InspectorTest.completeTest();
	}
	});

	let suite = InspectorTest.createAsyncSuite("Worker.Debugger.Threads");

	suite.addTestCase({
	name: "Worker.Debugger.Threads.CreateThreads",
	description: "Spawn multiple targets.",
	test(resolve, reject) {
	InspectorTest.evaluateInPage(`triggerStartWorkers()`);
	WI.targetManager.singleFireEventListener(WI.TargetManager.Event.TargetAdded, (event) => {
	InspectorTest.pass("Created Worker 1");
	workerTarget1 = event.data.target;
	WI.targetManager.singleFireEventListener(WI.TargetManager.Event.TargetAdded, (event) => {
	InspectorTest.pass("Created Worker 2");
	workerTarget2 = event.data.target;
	resolve();
	});
	});
	}
	});

	suite.addTestCase({
	name: "Worker.Debugger.Threads.Pause",
	description: "Should be able to pause in multiple targets.",
	test(resolve, reject) {
	InspectorTest.evaluateInPage(`triggerWork()`);

	let receivedCallFramesDidChange = false;
	let receivedPauseBeforeCallFramesDidChange = false;
	let otherTargetsPausing = false;

	WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Paused, (event) => {
	receivedPauseBeforeCallFramesDidChange = !receivedCallFramesDidChange;
	otherTargetsPausing = WI.debuggerManager.dataForTarget(mainTarget).pausing && WI.debuggerManager.dataForTarget(workerTarget2).pausing;
	});

	let listener = WI.debuggerManager.addEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
	receivedCallFramesDidChange = true;
	if (!areAllTargetsPaused())
	return;

	WI.debuggerManager.removeEventListener(WI.DebuggerManager.Event.CallFramesDidChange, listener);

	let activeCallFrame = WI.debuggerManager.activeCallFrame;
	InspectorTest.assert(activeCallFrame.target === workerTarget1);

	InspectorTest.expectThat(receivedPauseBeforeCallFramesDidChange, "Paused event should happen before CallFramesDidChange event.");
	InspectorTest.expectThat(otherTargetsPausing, "In Paused event all other Targets should be pausing.");
	InspectorTest.expectEqual(activeCallFrame.target.displayName, "worker-debugger-thread-1.js", "Worker 1 should be the first to pause.");
	InspectorTest.pass("All Targets should eventually pause.");
	dumpCallFrames();
	resolve();
	});
	}
	});

	function addEvaluateTestCase({name, targetResolver, expected}) {
	suite.addTestCase({
	name, description: "Should be able to evaluate in different threads while paused.",
	test(resolve, reject) {
	let target = targetResolver();
	let targetData = WI.debuggerManager.dataForTarget(target);
	WI.debuggerManager.activeCallFrame = targetData.callFrames[0];
	WI.runtimeManager.evaluateInInspectedWindow("testVariable", {objectGroup: "test", includeCommandLineAPI: true}, (remoteObject) => {
	InspectorTest.expectEqual(remoteObject.description, expected, `Evaluated result in ${target.displayName} should be ${JSON.stringify(expected)}.`)
	resolve();
	});
	}
	});
	}

	addEvaluateTestCase({
	name: "Worker.Debugger.Threads.Paused.Worker1Evaluate",
	targetResolver: () => workerTarget1,
	expected: "worker thread 1",
	});

	addEvaluateTestCase({
	name: "Worker.Debugger.Threads.Paused.Worker2Evaluate",
	targetResolver: () => workerTarget2,
	expected: "worker thread 2",
	});

	addEvaluateTestCase({
	name: "Worker.Debugger.Threads.Paused.MainEvaluate",
	targetResolver: () => mainTarget,
	expected: "main thread",
	});

	suite.addTestCase({
	name: "Worker.Debugger.Threads.Paused.Worker1.StepOut",
	description: "Should be able to step in individual threads and not affect the others.",
	test(resolve, reject) {
	let targetData = WI.debuggerManager.dataForTarget(workerTarget1);
	WI.debuggerManager.activeCallFrame = targetData.callFrames[0];
	WI.debuggerManager.stepOut();
	WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
	InspectorTest.expectEqual(event.data.target, workerTarget1, "Should receive CallFramesDidChange for Worker 1.");
	dumpCallFrames();
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "Worker.Debugger.Threads.Paused.Worker2.ResumeThread",
	description: "Should be able to resume an individual thread and not affect the others.",
	test(resolve, reject) {
	let targetData = WI.debuggerManager.dataForTarget(workerTarget2);
	WI.debuggerManager.continueUntilNextRunLoop(workerTarget2);
	WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
	InspectorTest.expectEqual(event.data.target, workerTarget2, "Should Receive CallFramesDidChange for Worker 2.");
	InspectorTest.expectThat(targetData.pausing, "Worker 2 should be pausing.");
	WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.CallFramesDidChange, (event) => {
	InspectorTest.expectEqual(event.data.target, workerTarget2, "Should Receive CallFramesDidChange for Worker 2.");
	InspectorTest.expectThat(targetData.paused, "Worker 2 should be paused.");
	dumpCallFrames();
	resolve();
	});
	});
	}
	});

	suite.addTestCase({
	name: "Worker.Debugger.Threads.Complete",
	description: "Resume all threads for the test to complete.",
	test(resolve, reject) {
	okayToReceiveMainThreadEvent = true;
	WI.debuggerManager.resume();
	WI.debuggerManager.singleFireEventListener(WI.DebuggerManager.Event.Resumed, () => {
	InspectorTest.pass("Received Resume event.");
	InspectorTest.expectThat(areAllTargetsUnpaused(), "All Targets should be unpaused.");
	resolve();
	});
	}
	});

	suite.runTestCasesAndFinish();
	}
	</script>
	</head>
	<body onload="runTest()">
	<p>Ensure we can pause in multiple targets and evaluate in each.</p>
	</body>
	</html>