LayoutTests/inspector/runtime/parse.html - WebKit - Git at Google

 <!doctype html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script>
 function test()
 {
     function outputErrorSourceRange(range) {
         var str = " ".repeat("Source: ".length);
         str += " ".repeat(range.startOffset);
         str += "^";
         str += "~".repeat(Math.max(range.endOffset - range.startOffset - 1, 0));
         InspectorTest.log(str);
     }

     let suite = InspectorTest.createAsyncSuite("Runtime.parse");

     suite.addTestCase({
         name: "SyntaxErrorType.None",
         description: "Test source without an issue.",
         test(resolve, reject) {
             function testSource(source) {
                 RuntimeAgent.parse(source, (error, result, message, range) => {
                     InspectorTest.assert(!error, "Should not be a protocol error.");
                     InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.None, "Should be SyntaxErrorType None.");
                     InspectorTest.log("Source: " + source);
                     InspectorTest.assert(!message);
                     InspectorTest.assert(!range);
                     InspectorTest.log("");
                 });
             }

             // Complete programs without syntax errors (could have runtime errors).
             testSource("");
             testSource(";");
             testSource("myVariable");
             testSource("var x = 1; x");
             testSource("[1,2,3]");
             testSource("({})");
             testSource("({prop:true}).x.x.x");
             testSource("if(1)1");
             InspectorBackend.runAfterPendingDispatches(resolve);
         }
     });

     suite.addTestCase({
         name: "SyntaxErrorType.UnterminatedLiteral",
         description: "Test source with an unterminated literal.",
         test(resolve, reject) {
             function testSource(source) {
                 RuntimeAgent.parse(source, (error, result, message, range) => {
                     InspectorTest.assert(!error, "Should not be a protocol error.");
                     InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.UnterminatedLiteral, "Should be SyntaxErrorType UnterminatedLiteral.");
                     InspectorTest.log("Source: " + source);
                     outputErrorSourceRange(range);
                     InspectorTest.log("Error Message: " + message);
                     InspectorTest.log("Range: " + JSON.stringify(range));
                     InspectorTest.log("");
                 });
             }

             // A literal that is not yet complete, but would be a single token.
             testSource("0b"); // binary
             testSource("0o"); // octal
             testSource("0x"); // hex
             testSource("1e"); // scientific notation number
             testSource("'");  // string
             testSource("\""); // string
             testSource("var \\u007"); // identifier unicode escape
             // testSource("/r"); // regexp - Not detected by JavaScriptCore.
             InspectorBackend.runAfterPendingDispatches(resolve);
         }
     });

     suite.addTestCase({
         name: "SyntaxErrorType.Recoverable",
         description: "Test source with a recoverable error.",
         test(resolve, reject) {
             function testSource(source) {
                 RuntimeAgent.parse(source, (error, result, message, range) => {
                     InspectorTest.assert(!error, "Should not be a protocol error.");
                     InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.Recoverable, "Should be SyntaxErrorType Recoverable.");
                     InspectorTest.log("Source: " + source);
                     outputErrorSourceRange(range);
                     InspectorTest.log("Error Message: " + message);
                     InspectorTest.log("Error Range: " + JSON.stringify(range));
                     InspectorTest.log("");
                 });
             }

             // Not yet a syntax error, just an incomplete program.
             testSource("(");
             testSource("{");
             testSource("!");
             testSource("-"); // unary
             testSource("+"); // unary
             testSource("~"); // unary
             testSource("1,");
             testSource("var");
             testSource("'use strict'; let"); // When not in strict mode, let is treated as the start of an identifier, not a keyword!
             testSource("const");
             testSource("var {x"); // destructuring
             testSource("var [x"); // destructuring
             testSource("var x,");
             testSource("if(1)");
             testSource("if(1){");
             testSource("if(1){}else");
             testSource("if(1){}else{");
             testSource("while(1)");
             testSource("while(1){");
             testSource("for(;;)");
             testSource("for(;;){");
             testSource("()=>");  // arrow function
             testSource("()=>{"); // arrow function
             testSource("/*");    // comment
             testSource("`");     // template string
             testSource("`${1}"); // template string
             testSource("`${");   // template string
             testSource("function");
             testSource("function foo");
             testSource("function foo(");
             testSource("function foo(){");
             testSource("(function() {");
             testSource("(function() {}");
             testSource("(function() {})(");
             testSource("switch(x)");
             testSource("switch(x){");
             testSource("switch(x){case");
             testSource("switch(x){case 1");
             testSource("switch(x){case 1:");
             testSource("class");
             testSource("class Klass");
             testSource("class Klass {");
             testSource("var x = {");
             testSource("var x = {prop");
             testSource("var x = {prop:");
             testSource("var x = {prop:123");
             testSource("var x = {prop:123 ");
             testSource("var x = {prop:123,");
             testSource("var x = {prop:123, ");
             testSource("var x = {prop:123, 'prop2'");
             testSource("var x = {prop:123, [12");
             testSource("var x = {prop:123, [12]");
             testSource("var x = {prop:123, [12]:");
             testSource("var x = {prop:123, [12]:567");
             testSource("var x = [");
             testSource("var x = [1");
             testSource("var x = [1,");
             testSource("var x = [1,[]");
             testSource("var x = [1,{}");
             InspectorBackend.runAfterPendingDispatches(resolve);
         }
     });

     suite.addTestCase({
         name: "SyntaxErrorType.Irrecoverable",
         description: "Test source with an irrecoverable issue.",
         test(resolve, reject) {
             function testSource(source) {
                 RuntimeAgent.parse(source, (error, result, message, range) => {
                     InspectorTest.assert(!error, "Should not be a protocol error.");
                     InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.Irrecoverable, "Should be SyntaxErrorType Irrecoverable.");
                     InspectorTest.log("Source: " + source);
                     outputErrorSourceRange(range);
                     InspectorTest.log("Error Message: " + message);
                     InspectorTest.log("Error Range: " + JSON.stringify(range));
                     InspectorTest.log("");
                 });
             }

             // SyntaxErrors. Any typing after the syntax error is detected does not matter.
             testSource("1$");
             testSource("var x = {}}");
             testSource("({}))");
             testSource("var x = =");
             testSource("const x;");
             testSource("let x = 1; let x = 2;");
             testSource("if x(1)");
             InspectorBackend.runAfterPendingDispatches(resolve);
         }
     });

     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
 <p>Tests for the Runtime.parse command.</p>
 </body>
 </html>
	<!doctype html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script>
	function test()
	{
	function outputErrorSourceRange(range) {
	var str = " ".repeat("Source: ".length);
	str += " ".repeat(range.startOffset);
	str += "^";
	str += "~".repeat(Math.max(range.endOffset - range.startOffset - 1, 0));
	InspectorTest.log(str);
	}

	let suite = InspectorTest.createAsyncSuite("Runtime.parse");

	suite.addTestCase({
	name: "SyntaxErrorType.None",
	description: "Test source without an issue.",
	test(resolve, reject) {
	function testSource(source) {
	RuntimeAgent.parse(source, (error, result, message, range) => {
	InspectorTest.assert(!error, "Should not be a protocol error.");
	InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.None, "Should be SyntaxErrorType None.");
	InspectorTest.log("Source: " + source);
	InspectorTest.assert(!message);
	InspectorTest.assert(!range);
	InspectorTest.log("");
	});
	}

	// Complete programs without syntax errors (could have runtime errors).
	testSource("");
	testSource(";");
	testSource("myVariable");
	testSource("var x = 1; x");
	testSource("[1,2,3]");
	testSource("({})");
	testSource("({prop:true}).x.x.x");
	testSource("if(1)1");
	InspectorBackend.runAfterPendingDispatches(resolve);
	}
	});

	suite.addTestCase({
	name: "SyntaxErrorType.UnterminatedLiteral",
	description: "Test source with an unterminated literal.",
	test(resolve, reject) {
	function testSource(source) {
	RuntimeAgent.parse(source, (error, result, message, range) => {
	InspectorTest.assert(!error, "Should not be a protocol error.");
	InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.UnterminatedLiteral, "Should be SyntaxErrorType UnterminatedLiteral.");
	InspectorTest.log("Source: " + source);
	outputErrorSourceRange(range);
	InspectorTest.log("Error Message: " + message);
	InspectorTest.log("Range: " + JSON.stringify(range));
	InspectorTest.log("");
	});
	}

	// A literal that is not yet complete, but would be a single token.
	testSource("0b"); // binary
	testSource("0o"); // octal
	testSource("0x"); // hex
	testSource("1e"); // scientific notation number
	testSource("'"); // string
	testSource("\""); // string
	testSource("var \\u007"); // identifier unicode escape
	// testSource("/r"); // regexp - Not detected by JavaScriptCore.
	InspectorBackend.runAfterPendingDispatches(resolve);
	}
	});

	suite.addTestCase({
	name: "SyntaxErrorType.Recoverable",
	description: "Test source with a recoverable error.",
	test(resolve, reject) {
	function testSource(source) {
	RuntimeAgent.parse(source, (error, result, message, range) => {
	InspectorTest.assert(!error, "Should not be a protocol error.");
	InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.Recoverable, "Should be SyntaxErrorType Recoverable.");
	InspectorTest.log("Source: " + source);
	outputErrorSourceRange(range);
	InspectorTest.log("Error Message: " + message);
	InspectorTest.log("Error Range: " + JSON.stringify(range));
	InspectorTest.log("");
	});
	}

	// Not yet a syntax error, just an incomplete program.
	testSource("(");
	testSource("{");
	testSource("!");
	testSource("-"); // unary
	testSource("+"); // unary
	testSource("~"); // unary
	testSource("1,");
	testSource("var");
	testSource("'use strict'; let"); // When not in strict mode, let is treated as the start of an identifier, not a keyword!
	testSource("const");
	testSource("var {x"); // destructuring
	testSource("var [x"); // destructuring
	testSource("var x,");
	testSource("if(1)");
	testSource("if(1){");
	testSource("if(1){}else");
	testSource("if(1){}else{");
	testSource("while(1)");
	testSource("while(1){");
	testSource("for(;;)");
	testSource("for(;;){");
	testSource("()=>"); // arrow function
	testSource("()=>{"); // arrow function
	testSource("/*"); // comment
	testSource("`"); // template string
	testSource("`${1}"); // template string
	testSource("`${"); // template string
	testSource("function");
	testSource("function foo");
	testSource("function foo(");
	testSource("function foo(){");
	testSource("(function() {");
	testSource("(function() {}");
	testSource("(function() {})(");
	testSource("switch(x)");
	testSource("switch(x){");
	testSource("switch(x){case");
	testSource("switch(x){case 1");
	testSource("switch(x){case 1:");
	testSource("class");
	testSource("class Klass");
	testSource("class Klass {");
	testSource("var x = {");
	testSource("var x = {prop");
	testSource("var x = {prop:");
	testSource("var x = {prop:123");
	testSource("var x = {prop:123 ");
	testSource("var x = {prop:123,");
	testSource("var x = {prop:123, ");
	testSource("var x = {prop:123, 'prop2'");
	testSource("var x = {prop:123, [12");
	testSource("var x = {prop:123, [12]");
	testSource("var x = {prop:123, [12]:");
	testSource("var x = {prop:123, [12]:567");
	testSource("var x = [");
	testSource("var x = [1");
	testSource("var x = [1,");
	testSource("var x = [1,[]");
	testSource("var x = [1,{}");
	InspectorBackend.runAfterPendingDispatches(resolve);
	}
	});

	suite.addTestCase({
	name: "SyntaxErrorType.Irrecoverable",
	description: "Test source with an irrecoverable issue.",
	test(resolve, reject) {
	function testSource(source) {
	RuntimeAgent.parse(source, (error, result, message, range) => {
	InspectorTest.assert(!error, "Should not be a protocol error.");
	InspectorTest.expectThat(result === InspectorBackend.Enum.Runtime.SyntaxErrorType.Irrecoverable, "Should be SyntaxErrorType Irrecoverable.");
	InspectorTest.log("Source: " + source);
	outputErrorSourceRange(range);
	InspectorTest.log("Error Message: " + message);
	InspectorTest.log("Error Range: " + JSON.stringify(range));
	InspectorTest.log("");
	});
	}

	// SyntaxErrors. Any typing after the syntax error is detected does not matter.
	testSource("1$");
	testSource("var x = {}}");
	testSource("({}))");
	testSource("var x = =");
	testSource("const x;");
	testSource("let x = 1; let x = 2;");
	testSource("if x(1)");
	InspectorBackend.runAfterPendingDispatches(resolve);
	}
	});

	suite.runTestCasesAndFinish();
	}
	</script>
	</head>
	<body onload="runTest()">
	<p>Tests for the Runtime.parse command.</p>
	</body>
	</html>