LayoutTests/inspector/protocol/inspector-backend-invocation-return-value.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script>
 function test()
 {
     let suite = InspectorTest.createAsyncSuite("Protocol.BackendInvocationReturnValues");
     let dummyCallback = () => {};

     // Test behavior for promise-based callbacks.

     suite.addTestCase({
         name: "ResolveCommandPromiseOnSuccess.call",
         description: "Backend command's returned promise should be resolved if the command is successful.",
         test(resolve, reject) {
             let returnValue = RuntimeAgent.evaluate("42");

             InspectorTest.expectThat(returnValue instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(returnValue instanceof Promise))
                 reject();

             returnValue.then(function resolved(result) {
                 InspectorTest.log("PASS: A successful command invocation's promise should be resolved.");
                 resolve();
             }, function rejected(result) {
                 InspectorTest.log("FAIL: A successful command invocation's promise should be resolved.");
                 reject();
             });
         }
     });

     suite.addTestCase({
         name: "ResolveCommandPromiseOnSuccess.invoke",
         description: "Backend command's returned promise should be resolved if the command is successful.",
         test(resolve, reject) {
             let returnValue = RuntimeAgent.evaluate.invoke({expression: "42"});

             InspectorTest.expectThat(returnValue instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(returnValue instanceof Promise))
                 reject();

             returnValue.then(function resolved(result) {
                 InspectorTest.log("PASS: A successful command invocation's promise should be resolved.");
                 resolve();
             }, function rejected(result) {
                 InspectorTest.log("FAIL: A successful command invocation's promise should be resolved.");
                 reject();
             });
         }
     });

     suite.addTestCase({
         name: "RejectCommandPromiseWithInvalidArguments.call",
         description: "Backend command's returned promise should be rejected if the command has invalid arguments.",
         test(resolve, reject) {
             let result = RuntimeAgent.evaluate(42);

             InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(result instanceof Promise))
                 reject();

             result.then(function resolved(result) {
                 InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
                 reject();
             }, function rejected(result) {
                 InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "RejectCommandPromiseWithInvalidArguments.invoke",
         description: "Backend command's returned promise should be rejected if the command has invalid arguments.",
         test(resolve, reject) {
             let result = RuntimeAgent.evaluate.invoke({expression: 42});

             InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(result instanceof Promise))
                 reject();

             result.then(function resolved(result) {
                 InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
                 reject();
             }, function rejected(result) {
                 InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "RejectCommandPromiseWithMissingArguments.call",
         description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
         test(resolve, reject) {
             let result = RuntimeAgent.evaluate();

             InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(result instanceof Promise))
                 reject();

             result.then(function resolved(result) {
                 InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
                 reject();
             }, function rejected(result) {
                 InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "RejectCommandPromiseWithMissingArguments.invoke.MissingObject",
         description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
         test(resolve, reject) {
             let result = RuntimeAgent.evaluate.invoke();

             InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(result instanceof Promise))
                 reject();

             result.then(function resolved(result) {
                 InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
                 reject();
             }, function rejected(result) {
                 InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "RejectCommandPromiseWithMissingArguments.invoke.NonObject",
         description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
         test(resolve, reject) {
             let result = RuntimeAgent.evaluate.invoke("test");

             InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(result instanceof Promise))
                 reject();

             result.then(function resolved(result) {
                 InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
                 reject();
             }, function rejected(result) {
                 InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "RejectCommandPromiseWithMissingArguments.invoke.EmptyObject",
         description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
         test(resolve, reject) {
             let result = RuntimeAgent.evaluate.invoke({});

             InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(result instanceof Promise))
                 reject();

             result.then(function resolved(result) {
                 InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
                 reject();
             }, function rejected(result) {
                 InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "RejectCommandPromiseWithExtraArgumentThatIsNotCallback.call",
         description: "Backend command's returned promise should be rejected if the command has an extra argument that is not a callback.",
         test(resolve, reject) {
             let result = RuntimeAgent.enable(1);

             InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
             // If a promise wasn't returned, we can't test the rest so just die.
             if (!(result instanceof Promise))
                 reject();

             result.then(function resolved(result) {
                 InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
                 reject();
             }, function rejected(result) {
                 InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
                 resolve();
             });
         }
     });

     // Test behavior for function-based callbacks.

     suite.addTestCase({
         name: "ReturnNothingIfCallback.call",
         description: "Backend commands should not return anything if a callback is supplied.",
         test(resolve, reject) {
             let returnValue = RuntimeAgent.evaluate("41", dummyCallback);
             InspectorTest.expectThat(returnValue === undefined, "A backend command should not have a return value when invoked with a callback.");
             resolve();
         }
     });

     suite.addTestCase({
         name: "ReturnNothingIfCallback.invoke",
         description: "Backend commands should not return anything if a callback is supplied.",
         test(resolve, reject) {
             let returnValue = RuntimeAgent.evaluate.invoke({expression: "41"}, dummyCallback);
             InspectorTest.expectThat(returnValue === undefined, "A backend command should not have a return value when invoked with a callback.");
             resolve();
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithResultOnSuccess.call",
         description: "Backend command callback should be invoked with a result if the command is successful.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate("42", function(error, result) {
                 InspectorTest.expectThat(error === null, "A successful command should invoke the callback with a 'null' first parameter.");
                 InspectorTest.expectThat(arguments.length > 1, "A successful command should invoke the callback with one or more result parameters.");
                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithResultOnSuccess.invoke",
         description: "Backend command callback should be invoked with a result if the command is successful.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate.invoke({expression: "42"}, function(error, result) {
                 InspectorTest.expectThat(error === null, "A successful command should invoke the callback with a 'null' first parameter.");
                 InspectorTest.expectThat(arguments.length > 1, "A successful command should invoke the callback with one or more result parameters.");
                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithErrorForInvalidArguments.call",
         description: "Backend command callback should be invoked with an error if the command has invalid arguments.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate(42, function callback(error) {
                 InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
                 InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");
                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithErrorForInvalidArguments.invoke",
         description: "Backend command callback should be invoked with an error if the command has invalid arguments.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate.invoke({expression: 42}, function callback(error) {
                 InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
                 InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");
                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithErrorForMissingArguments.call",
         description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate(function callback(error) {
                 InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
                 InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithErrorForMissingArguments.invoke.MissingObject",
         description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate.invoke(undefined, function callback(error) {
                 InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
                 InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithErrorForMissingArguments.invoke.NonObject",
         description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate.invoke("test", function callback(error) {
                 InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
                 InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.addTestCase({
         name: "InvokeCallbackWithErrorForMissingArguments.invoke.EmptyObject",
         description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
         test(resolve, reject) {
             let initialState = 1;
             let returnValue = RuntimeAgent.evaluate.invoke({}, function callback(error) {
                 InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
                 InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

                 initialState++;
                 resolve();
             });

             InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
             InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
         }
     });

     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
     <p>Testing the inspector backend's return values when invoking a protocol command in various ways.</p>
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script>
	function test()
	{
	let suite = InspectorTest.createAsyncSuite("Protocol.BackendInvocationReturnValues");
	let dummyCallback = () => {};

	// Test behavior for promise-based callbacks.

	suite.addTestCase({
	name: "ResolveCommandPromiseOnSuccess.call",
	description: "Backend command's returned promise should be resolved if the command is successful.",
	test(resolve, reject) {
	let returnValue = RuntimeAgent.evaluate("42");

	InspectorTest.expectThat(returnValue instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(returnValue instanceof Promise))
	reject();

	returnValue.then(function resolved(result) {
	InspectorTest.log("PASS: A successful command invocation's promise should be resolved.");
	resolve();
	}, function rejected(result) {
	InspectorTest.log("FAIL: A successful command invocation's promise should be resolved.");
	reject();
	});
	}
	});

	suite.addTestCase({
	name: "ResolveCommandPromiseOnSuccess.invoke",
	description: "Backend command's returned promise should be resolved if the command is successful.",
	test(resolve, reject) {
	let returnValue = RuntimeAgent.evaluate.invoke({expression: "42"});

	InspectorTest.expectThat(returnValue instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(returnValue instanceof Promise))
	reject();

	returnValue.then(function resolved(result) {
	InspectorTest.log("PASS: A successful command invocation's promise should be resolved.");
	resolve();
	}, function rejected(result) {
	InspectorTest.log("FAIL: A successful command invocation's promise should be resolved.");
	reject();
	});
	}
	});

	suite.addTestCase({
	name: "RejectCommandPromiseWithInvalidArguments.call",
	description: "Backend command's returned promise should be rejected if the command has invalid arguments.",
	test(resolve, reject) {
	let result = RuntimeAgent.evaluate(42);

	InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(result instanceof Promise))
	reject();

	result.then(function resolved(result) {
	InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
	reject();
	}, function rejected(result) {
	InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "RejectCommandPromiseWithInvalidArguments.invoke",
	description: "Backend command's returned promise should be rejected if the command has invalid arguments.",
	test(resolve, reject) {
	let result = RuntimeAgent.evaluate.invoke({expression: 42});

	InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(result instanceof Promise))
	reject();

	result.then(function resolved(result) {
	InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
	reject();
	}, function rejected(result) {
	InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "RejectCommandPromiseWithMissingArguments.call",
	description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
	test(resolve, reject) {
	let result = RuntimeAgent.evaluate();

	InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(result instanceof Promise))
	reject();

	result.then(function resolved(result) {
	InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
	reject();
	}, function rejected(result) {
	InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "RejectCommandPromiseWithMissingArguments.invoke.MissingObject",
	description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
	test(resolve, reject) {
	let result = RuntimeAgent.evaluate.invoke();

	InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(result instanceof Promise))
	reject();

	result.then(function resolved(result) {
	InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
	reject();
	}, function rejected(result) {
	InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "RejectCommandPromiseWithMissingArguments.invoke.NonObject",
	description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
	test(resolve, reject) {
	let result = RuntimeAgent.evaluate.invoke("test");

	InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(result instanceof Promise))
	reject();

	result.then(function resolved(result) {
	InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
	reject();
	}, function rejected(result) {
	InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "RejectCommandPromiseWithMissingArguments.invoke.EmptyObject",
	description: "Backend command's returned promise should be rejected if the command lacks required arguments.",
	test(resolve, reject) {
	let result = RuntimeAgent.evaluate.invoke({});

	InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(result instanceof Promise))
	reject();

	result.then(function resolved(result) {
	InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
	reject();
	}, function rejected(result) {
	InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "RejectCommandPromiseWithExtraArgumentThatIsNotCallback.call",
	description: "Backend command's returned promise should be rejected if the command has an extra argument that is not a callback.",
	test(resolve, reject) {
	let result = RuntimeAgent.enable(1);

	InspectorTest.expectThat(result instanceof Promise, "A backend command should return a Promise when invoked without a callback.");
	// If a promise wasn't returned, we can't test the rest so just die.
	if (!(result instanceof Promise))
	reject();

	result.then(function resolved(result) {
	InspectorTest.log("FAIL: An invalid command invocation's promise should be rejected.");
	reject();
	}, function rejected(result) {
	InspectorTest.log("PASS: An invalid command invocation's promise should be rejected.");
	resolve();
	});
	}
	});

	// Test behavior for function-based callbacks.

	suite.addTestCase({
	name: "ReturnNothingIfCallback.call",
	description: "Backend commands should not return anything if a callback is supplied.",
	test(resolve, reject) {
	let returnValue = RuntimeAgent.evaluate("41", dummyCallback);
	InspectorTest.expectThat(returnValue === undefined, "A backend command should not have a return value when invoked with a callback.");
	resolve();
	}
	});

	suite.addTestCase({
	name: "ReturnNothingIfCallback.invoke",
	description: "Backend commands should not return anything if a callback is supplied.",
	test(resolve, reject) {
	let returnValue = RuntimeAgent.evaluate.invoke({expression: "41"}, dummyCallback);
	InspectorTest.expectThat(returnValue === undefined, "A backend command should not have a return value when invoked with a callback.");
	resolve();
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithResultOnSuccess.call",
	description: "Backend command callback should be invoked with a result if the command is successful.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate("42", function(error, result) {
	InspectorTest.expectThat(error === null, "A successful command should invoke the callback with a 'null' first parameter.");
	InspectorTest.expectThat(arguments.length > 1, "A successful command should invoke the callback with one or more result parameters.");
	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithResultOnSuccess.invoke",
	description: "Backend command callback should be invoked with a result if the command is successful.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate.invoke({expression: "42"}, function(error, result) {
	InspectorTest.expectThat(error === null, "A successful command should invoke the callback with a 'null' first parameter.");
	InspectorTest.expectThat(arguments.length > 1, "A successful command should invoke the callback with one or more result parameters.");
	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithErrorForInvalidArguments.call",
	description: "Backend command callback should be invoked with an error if the command has invalid arguments.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate(42, function callback(error) {
	InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
	InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");
	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithErrorForInvalidArguments.invoke",
	description: "Backend command callback should be invoked with an error if the command has invalid arguments.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate.invoke({expression: 42}, function callback(error) {
	InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
	InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");
	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithErrorForMissingArguments.call",
	description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate(function callback(error) {
	InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
	InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithErrorForMissingArguments.invoke.MissingObject",
	description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate.invoke(undefined, function callback(error) {
	InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
	InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithErrorForMissingArguments.invoke.NonObject",
	description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate.invoke("test", function callback(error) {
	InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
	InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.addTestCase({
	name: "InvokeCallbackWithErrorForMissingArguments.invoke.EmptyObject",
	description: "Backend command callback should be invoked with an error if the command lacks required arguments.",
	test(resolve, reject) {
	let initialState = 1;
	let returnValue = RuntimeAgent.evaluate.invoke({}, function callback(error) {
	InspectorTest.expectThat(typeof error === "string", "A failed command should invoke the callback with a string error message as its first parameter.");
	InspectorTest.expectThat(arguments.length === 1, "A failed command should invoke the callback with only an error parameter.");

	initialState++;
	resolve();
	});

	InspectorTest.expectThat(returnValue === undefined, "A backend command should not return anything when invoked with a callback.");
	InspectorTest.expectThat(initialState === 1, "A backend command should always invoke its callback asynchronously.");
	}
	});

	suite.runTestCasesAndFinish();
	}
	</script>
	</head>
	<body onload="runTest()">
	<p>Testing the inspector backend's return values when invoking a protocol command in various ways.</p>
	</body>
	</html>