LayoutTests/inspector/runtime/evaluate-CommandLineAPI.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script>
 var varGlobalVariable = 1;
 let letGlobalVariable = 2;
 const constGlobalVariable = 3;
 var varGlobalFunctionVariable = 4;

 function test()
 {
     const objectGroup = "test";
     const includeCommandLineAPI = true;
     const returnByValue = true;

     function testEvaluate(expression, callback) {
         RuntimeAgent.evaluate.invoke({expression, objectGroup, includeCommandLineAPI, returnByValue}, (error, resultValue, wasThrown) => {
             InspectorTest.assert(!error, "Should not be a protocol error.");
             InspectorTest.assert(!wasThrown, "Should not be a runtime error.");
             if (callback)
                 callback(resultValue.value);
         });
     }

     function testEvaluateThrow(expression, callback) {
         RuntimeAgent.evaluate.invoke({expression, objectGroup, includeCommandLineAPI, returnByValue}, (error, resultValue, wasThrown) => {
             InspectorTest.assert(!error, "Should not be a protocol error.");
             InspectorTest.assert(wasThrown, "Should be a runtime error.");
             if (callback)
                 callback(wasThrown);
         });
     }

     let suite = InspectorTest.createAsyncSuite("Runtime.evaluate.CommandLineAPI");

     suite.addTestCase({
         name: "AccessCommandLineAPI",
         description: "Test evaluate can access CommandLineAPI methods.",
         test(resolve, reject) {
             testEvaluate("keys.toString()", (resultValue) => {
                 InspectorTest.expectThat(resultValue.includes("[Command Line API]"), "CommandLineAPI `keys` can be accessed.");
             });
             testEvaluate("keys({a:1, b:2})", (resultValue) => {
                 InspectorTest.expectThat(resultValue.length === 2 && resultValue[0] === "a" && resultValue[1] === "b", "CommandLineAPI `keys` should work with a simple object.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "AccessGlobalVariable",
         description: "Test evaluate can access global variables.",
         test(resolve, reject) {
             testEvaluate("varGlobalVariable", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 1, "Should be able to access var in global scope.");
             });
             testEvaluate("letGlobalVariable", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 2, "Should be able to access let in global scope.");
             });
             testEvaluate("constGlobalVariable", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 3, "Should be able to access const in global scope.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "CreateGlobalVariable",
         description: "Test evaluate can create global variables.",
         test(resolve, reject) {
             testEvaluate(`
                 var createdVarGlobalVariable = 1;
                 let createdLetGlobalVariable = 2;
                 const createdConstGlobalVariable = 3;
             `);
             testEvaluate("createdVarGlobalVariable", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 1, "Should be able to access created var in global scope.");
             });
             testEvaluate("createdLetGlobalVariable", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 2, "Should be able to access created let in global scope.");
             });
             testEvaluate("createdConstGlobalVariable", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 3, "Should be able to access created const in global scope.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "CreateGlobalClass",
         description: "Test evaluate can create a class.",
         test(resolve, reject) {
             testEvaluate(`
                 class Foo {
                     static staticMethod() {
                         return 42;
                     }
                 }
             `);
             testEvaluate("Foo.staticMethod()", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 42, "Should be able to access class created in earlier evaluation.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "ExpectedExceptionCreatingDuplicateLexicalGlobalVariables",
         description: "Test evaluate produces expected exception creating duplicate lexical global variables across evaluations.",
         test(resolve, reject) {
             testEvaluate(`let duplicateGlobalVariable = 1`);
             testEvaluateThrow(`let duplicateGlobalVariable = 1`, (wasThrown) => {
                 InspectorTest.expectThat(wasThrown, "Should be an exception defining a lexical global multiple times.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "NonStrictAndStrictEvaluations",
         description: "Test evaluate can run strict and non-strict programs.",
         test(resolve, reject) {
             testEvaluate(`
                 // Not strict, this is okay.
                 (function f() {
                     return arguments.callee.name;
                 })();
             `, (resultValue) => {
                 InspectorTest.expectThat(resultValue === "f", "Non-strict evaluation. Should be able to access arguments.callee.");
             });
             testEvaluateThrow(`"use strict";
                 // Strict, this throw an exception.
                 (function() {
                     return arguments.callee;
                 })();`
             , (wasThrown) => {
                 InspectorTest.expectThat(wasThrown, "Script evaluation. Should not be able to access arguments.callee.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "CommandLineAPIDoesNotShadowVariables",
         description: "Test CommandLineAPI does not shadow global variables.",
         test(resolve, reject) {
             testEvaluate("keys.toString()", (resultValue) => {
                 InspectorTest.expectThat(resultValue.includes("[Command Line API]"), "`keys` is currently CommandLineAPI function.");
             });
             testEvaluate("var keys = 123; keys", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 123, "Creating global `keys` variable should be okay.");
             });
             testEvaluate("keys", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 123, "Global `keys` variable should not be shadowed by CommandLineAPI function.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "CommandLineAPIDoesNotShadowGlobalObjectProperties",
         description: "Test CommandLineAPI does not shadow global object properties.",
         test(resolve, reject) {
             testEvaluate("values.toString()", (resultValue) => {
                 InspectorTest.expectThat(resultValue === "[object HTMLDivElement]", "`values` should be `window.values` and not shadowed by CommandLineAPI `values` function.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "NonStrictEvalHoistEvaluations",
         description: "Test CommandLineAPI does not shadow global object variable that hoisted from eval.",
         test(resolve, reject) {
             testEvaluate("varGlobalFunctionVariable", (resultValue) => {
                 InspectorTest.expectThat(resultValue === 4, "Should be able to access var in global scope.");
             });
             testEvaluate(`
                 let noError = varGlobalFunctionVariable === 4;
                 eval('eval(" { function varGlobalFunctionVariable() { }; } ")');
                 typeof varGlobalFunctionVariable === 'function' && noError;
             `, (resultValue) => {
                 InspectorTest.expectThat(resultValue, "Should be able to hoist function to var in global scope.");
             });
             testEvaluate("varGlobalFunctionVariable", (resultValue) => {
                 InspectorTest.expectThat(typeof resultValue, "Should be able to hoist function to var in global scope and keep it.");
                 resolve();
             });
         }
     });

     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
 <div id="values"></div> <!-- This introduces the named property `window.values` on the window global object. -->
 <p>Tests for the Runtime.evaluate with the Command Line API.</p>
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script>
	var varGlobalVariable = 1;
	let letGlobalVariable = 2;
	const constGlobalVariable = 3;
	var varGlobalFunctionVariable = 4;

	function test()
	{
	const objectGroup = "test";
	const includeCommandLineAPI = true;
	const returnByValue = true;

	function testEvaluate(expression, callback) {
	RuntimeAgent.evaluate.invoke({expression, objectGroup, includeCommandLineAPI, returnByValue}, (error, resultValue, wasThrown) => {
	InspectorTest.assert(!error, "Should not be a protocol error.");
	InspectorTest.assert(!wasThrown, "Should not be a runtime error.");
	if (callback)
	callback(resultValue.value);
	});
	}

	function testEvaluateThrow(expression, callback) {
	RuntimeAgent.evaluate.invoke({expression, objectGroup, includeCommandLineAPI, returnByValue}, (error, resultValue, wasThrown) => {
	InspectorTest.assert(!error, "Should not be a protocol error.");
	InspectorTest.assert(wasThrown, "Should be a runtime error.");
	if (callback)
	callback(wasThrown);
	});
	}

	let suite = InspectorTest.createAsyncSuite("Runtime.evaluate.CommandLineAPI");

	suite.addTestCase({
	name: "AccessCommandLineAPI",
	description: "Test evaluate can access CommandLineAPI methods.",
	test(resolve, reject) {
	testEvaluate("keys.toString()", (resultValue) => {
	InspectorTest.expectThat(resultValue.includes("[Command Line API]"), "CommandLineAPI `keys` can be accessed.");
	});
	testEvaluate("keys({a:1, b:2})", (resultValue) => {
	InspectorTest.expectThat(resultValue.length === 2 && resultValue[0] === "a" && resultValue[1] === "b", "CommandLineAPI `keys` should work with a simple object.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "AccessGlobalVariable",
	description: "Test evaluate can access global variables.",
	test(resolve, reject) {
	testEvaluate("varGlobalVariable", (resultValue) => {
	InspectorTest.expectThat(resultValue === 1, "Should be able to access var in global scope.");
	});
	testEvaluate("letGlobalVariable", (resultValue) => {
	InspectorTest.expectThat(resultValue === 2, "Should be able to access let in global scope.");
	});
	testEvaluate("constGlobalVariable", (resultValue) => {
	InspectorTest.expectThat(resultValue === 3, "Should be able to access const in global scope.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "CreateGlobalVariable",
	description: "Test evaluate can create global variables.",
	test(resolve, reject) {
	testEvaluate(`
	var createdVarGlobalVariable = 1;
	let createdLetGlobalVariable = 2;
	const createdConstGlobalVariable = 3;
	`);
	testEvaluate("createdVarGlobalVariable", (resultValue) => {
	InspectorTest.expectThat(resultValue === 1, "Should be able to access created var in global scope.");
	});
	testEvaluate("createdLetGlobalVariable", (resultValue) => {
	InspectorTest.expectThat(resultValue === 2, "Should be able to access created let in global scope.");
	});
	testEvaluate("createdConstGlobalVariable", (resultValue) => {
	InspectorTest.expectThat(resultValue === 3, "Should be able to access created const in global scope.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "CreateGlobalClass",
	description: "Test evaluate can create a class.",
	test(resolve, reject) {
	testEvaluate(`
	class Foo {
	static staticMethod() {
	return 42;
	}
	}
	`);
	testEvaluate("Foo.staticMethod()", (resultValue) => {
	InspectorTest.expectThat(resultValue === 42, "Should be able to access class created in earlier evaluation.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "ExpectedExceptionCreatingDuplicateLexicalGlobalVariables",
	description: "Test evaluate produces expected exception creating duplicate lexical global variables across evaluations.",
	test(resolve, reject) {
	testEvaluate(`let duplicateGlobalVariable = 1`);
	testEvaluateThrow(`let duplicateGlobalVariable = 1`, (wasThrown) => {
	InspectorTest.expectThat(wasThrown, "Should be an exception defining a lexical global multiple times.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "NonStrictAndStrictEvaluations",
	description: "Test evaluate can run strict and non-strict programs.",
	test(resolve, reject) {
	testEvaluate(`
	// Not strict, this is okay.
	(function f() {
	return arguments.callee.name;
	})();
	`, (resultValue) => {
	InspectorTest.expectThat(resultValue === "f", "Non-strict evaluation. Should be able to access arguments.callee.");
	});
	testEvaluateThrow(`"use strict";
	// Strict, this throw an exception.
	(function() {
	return arguments.callee;
	})();`
	, (wasThrown) => {
	InspectorTest.expectThat(wasThrown, "Script evaluation. Should not be able to access arguments.callee.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "CommandLineAPIDoesNotShadowVariables",
	description: "Test CommandLineAPI does not shadow global variables.",
	test(resolve, reject) {
	testEvaluate("keys.toString()", (resultValue) => {
	InspectorTest.expectThat(resultValue.includes("[Command Line API]"), "`keys` is currently CommandLineAPI function.");
	});
	testEvaluate("var keys = 123; keys", (resultValue) => {
	InspectorTest.expectThat(resultValue === 123, "Creating global `keys` variable should be okay.");
	});
	testEvaluate("keys", (resultValue) => {
	InspectorTest.expectThat(resultValue === 123, "Global `keys` variable should not be shadowed by CommandLineAPI function.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "CommandLineAPIDoesNotShadowGlobalObjectProperties",
	description: "Test CommandLineAPI does not shadow global object properties.",
	test(resolve, reject) {
	testEvaluate("values.toString()", (resultValue) => {
	InspectorTest.expectThat(resultValue === "[object HTMLDivElement]", "`values` should be `window.values` and not shadowed by CommandLineAPI `values` function.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "NonStrictEvalHoistEvaluations",
	description: "Test CommandLineAPI does not shadow global object variable that hoisted from eval.",
	test(resolve, reject) {
	testEvaluate("varGlobalFunctionVariable", (resultValue) => {
	InspectorTest.expectThat(resultValue === 4, "Should be able to access var in global scope.");
	});
	testEvaluate(`
	let noError = varGlobalFunctionVariable === 4;
	eval('eval(" { function varGlobalFunctionVariable() { }; } ")');
	typeof varGlobalFunctionVariable === 'function' && noError;
	`, (resultValue) => {
	InspectorTest.expectThat(resultValue, "Should be able to hoist function to var in global scope.");
	});
	testEvaluate("varGlobalFunctionVariable", (resultValue) => {
	InspectorTest.expectThat(typeof resultValue, "Should be able to hoist function to var in global scope and keep it.");
	resolve();
	});
	}
	});

	suite.runTestCasesAndFinish();
	}
	</script>
	</head>
	<body onload="runTest()">
	<div id="values"></div> <!-- This introduces the named property `window.values` on the window global object. -->
	<p>Tests for the Runtime.evaluate with the Command Line API.</p>
	</body>
	</html>