LayoutTests/inspector/console/queryHolders.html - WebKit - Git at Google

 <!DOCTYPE html>
 <html>
 <head>
 <script src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script>
 // Use classes so the corresponding RemoteObject has a nicer preview.
 Root = new (class Root { });
 Root.Root = Root;

 Root.C = new (class C { });
 Root.B = new (class B { });
 Root.B.C = Root.C;
 Root.A = new (class A { });
 Root.A.b = Root.B;
 Root.A.C = Root.C;

 Root.ArrayItem = new (class ArrayItem { });
 Root.Array = new Array([Root.ArrayItem]);

 Root.MapKey = new (class MapKey { });
 Root.MapValue = new (class MapValue { });
 Root.Map = new Map([[Root.MapKey, Root.MapValue]]);

 Root.SetItem = new (class SetItem { });
 Root.Set = new Set([Root.SetItem]);

 Root.WeakMapKey = new (class WeakMapKey { });
 Root.WeakMapValue = new (class WeakMapValue { });
 Root.WeakMap = new WeakMap([[Root.WeakMapKey, Root.WeakMapValue]]);

 Root.WeakSetItem = new (class WeakSetItem { });
 Root.WeakSet = new WeakSet([Root.WeakSetItem]);

 Root.Promise = new Promise(() => {});
 Root.PromiseThen = Root.Promise.then(() => {});
 Root.PromiseCatch = Root.Promise.catch(() => {});
 Root.PromiseFinally = Root.Promise.finally(() => {});

 Root.EventListenerCallback = () => {};
 Root.EventListenerTarget = document.createElement("div");
 Root.EventListenerTarget.id = "event-listener-target";
 Root.EventListenerTarget.addEventListener("custom", Root.EventListenerCallback);

 Root.SymbolReferenceObject = new (class SymbolReferenceObject { });
 Root.SymbolReferenceHolder = new (class SymbolReferenceHolder { });
 Root.SymbolReferenceHolder[Symbol("symbol-reference")] = Root.SymbolReferenceObject;

 Root.MultipleReferenceObject = new (class MultipleReferenceObject { });
 Root.MultipleReferenceHolder = Array(1000).fill().map((item, i) => {
     let holder = Function(`return new (class C${i} { })`)(); // create different dynamic classes so they're distinguishable in object previews
     holder.MultipleReferenceObject = Root.MultipleReferenceObject;
     return holder;
 });

 Root.RepeatedReferenceObject = new (class RepeatedReferenceObject { });
 Root.RepeatedReferenceHolder = new (class RepeatedReferenceHolder { });
 for (let i = 0; i < 1000; ++i)
     Root.RepeatedReferenceHolder[i] = Root.RepeatedReferenceObject;

 function test() {
     function queryHolders(target, callback) {
         WI.runtimeManager.evaluateInInspectedWindow(`queryHolders(${target})`, {objectGroup: "test", includeCommandLineAPI: true, generatePreview: true}, callback);
     }

     let suite = InspectorTest.createAsyncSuite("CommandLineAPI.queryHolders");

     function addTest(target) {
         suite.addTestCase({
             name: `CommandLineAPI.queryHolders.${target}`,
             test(resolve, reject) {
                 queryHolders("Root." + target, (remoteObject, wasThrown, savedResultIndex) => {
                     if (wasThrown) {
                         InspectorTest.fail("An exception was thrown.");
                         InspectorTest.log(remoteObject.description);
                         resolve();
                         return;
                     }

                     InspectorTest.assert(remoteObject.type === "object", "The result should be an object.");
                     InspectorTest.assert(remoteObject.subtype === "array", "The result should be an array object.");

                     if (remoteObject.preview.propertyPreviews.length < 5) {
                         let propertyPreviews = remoteObject.preview.propertyPreviews.map((preview) => preview.value || preview.subtype || preview.type);
                         propertyPreviews.sort();
                         InspectorTest.log("[" + propertyPreviews.join(", ") + "] (" + remoteObject.preview.size + ")");
                     } else
                         InspectorTest.log("[<filtered>] (" + remoteObject.preview.size + ")");

                     resolve();
                 });
             }
         });
     }

     addTest(`Root`);

     addTest(`A`);
     addTest(`B`);
     addTest(`C`);

     addTest(`Array`);
     addTest(`ArrayItem`);

     addTest(`Map`);
     addTest(`MapKey`);
     addTest(`MapValue`);

     addTest(`Set`);
     addTest(`SetItem`);

     addTest(`WeakMap`);
     addTest(`WeakMapKey`);
     addTest(`WeakMapValue`);

     addTest(`WeakSet`);
     addTest(`WeakSetItem`);

     addTest(`Promise`);
     addTest(`PromiseThen`);
     addTest(`PromiseCatch`);
     addTest(`PromiseFinally`);

     addTest(`EventListenerCallback`);

     addTest(`SymbolReferenceObject`);
     addTest(`MultipleReferenceObject`);
     addTest(`RepeatedReferenceObject`);

     suite.addTestCase({
         name: "CommandLineAPI.queryHolders.OnlyHeldByDebugger",
         async test() {
             let savedResult = null;

             {
                 let [remoteObject, wasThrown, savedResultIndex] = await promisify((callback) => {
                     WI.runtimeManager.evaluateInInspectedWindow(`new (class OnlyHeldByDebugger { })`, {
                         objectGroup: "test",
                         includeCommandLineAPI: true,
                         generatePreview: true,
                         saveResult: true,
                     }, callback);
                 });

                 InspectorTest.assert(!wasThrown);
                 if (wasThrown)
                     InspectorTest.log(remoteObject.description);

                 savedResult = "$" + savedResultIndex;
             }

             {
                 let [remoteObject, wasThrown, savedResultIndex] = await promisify((callback) => {
                     queryHolders(savedResult, callback);
                 });

                 InspectorTest.assert(!wasThrown);
                 if (wasThrown)
                     InspectorTest.log(remoteObject.description);

                 InspectorTest.assert(remoteObject.type === "object", "The result should be an object.");
                 InspectorTest.assert(remoteObject.subtype === "array", "The result should be an array object.");
                 InspectorTest.expectEqual(remoteObject.size, 0, `The result should have 0 items.`);
             }
         }
     });

     suite.addTestCase({
         name: "CommandLineAPI.queryHolders.NonObject",
         test(resolve, reject) {
             const target = `"test"`;
             queryHolders(target, (remoteObject, wasThrown, savedResultIndex) => {
                 InspectorTest.expectTrue(wasThrown, "Should produce an exception.");
                 InspectorTest.log("Error: " + remoteObject.description);
                 resolve();
             });
         }
     });

     suite.addTestCase({
         name: "CommandLineAPI.queryHolders.NoParameter",
         test(resolve, reject) {
             const target = ``;
             queryHolders(target, (remoteObject, wasThrown, savedResultIndex) => {
                 if (wasThrown) {
                     InspectorTest.fail("An exception was thrown.");
                     InspectorTest.log(remoteObject.description);
                     reject();
                     return;
                 }

                 InspectorTest.expectEqual(remoteObject.type, "undefined", "The result should be undefined.");
                 resolve();
             });
         }
     });

     suite.runTestCasesAndFinish();
 }
 </script>
 </head>
 <body onload="runTest()">
 <p>Tests for the `queryHolders` function in the Command Line API.</p>
 </body>
 </html>
	<!DOCTYPE html>
	<html>
	<head>
	<script src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script>
	// Use classes so the corresponding RemoteObject has a nicer preview.
	Root = new (class Root { });
	Root.Root = Root;

	Root.C = new (class C { });
	Root.B = new (class B { });
	Root.B.C = Root.C;
	Root.A = new (class A { });
	Root.A.b = Root.B;
	Root.A.C = Root.C;

	Root.ArrayItem = new (class ArrayItem { });
	Root.Array = new Array([Root.ArrayItem]);

	Root.MapKey = new (class MapKey { });
	Root.MapValue = new (class MapValue { });
	Root.Map = new Map([[Root.MapKey, Root.MapValue]]);

	Root.SetItem = new (class SetItem { });
	Root.Set = new Set([Root.SetItem]);

	Root.WeakMapKey = new (class WeakMapKey { });
	Root.WeakMapValue = new (class WeakMapValue { });
	Root.WeakMap = new WeakMap([[Root.WeakMapKey, Root.WeakMapValue]]);

	Root.WeakSetItem = new (class WeakSetItem { });
	Root.WeakSet = new WeakSet([Root.WeakSetItem]);

	Root.Promise = new Promise(() => {});
	Root.PromiseThen = Root.Promise.then(() => {});
	Root.PromiseCatch = Root.Promise.catch(() => {});
	Root.PromiseFinally = Root.Promise.finally(() => {});

	Root.EventListenerCallback = () => {};
	Root.EventListenerTarget = document.createElement("div");
	Root.EventListenerTarget.id = "event-listener-target";
	Root.EventListenerTarget.addEventListener("custom", Root.EventListenerCallback);

	Root.SymbolReferenceObject = new (class SymbolReferenceObject { });
	Root.SymbolReferenceHolder = new (class SymbolReferenceHolder { });
	Root.SymbolReferenceHolder[Symbol("symbol-reference")] = Root.SymbolReferenceObject;

	Root.MultipleReferenceObject = new (class MultipleReferenceObject { });
	Root.MultipleReferenceHolder = Array(1000).fill().map((item, i) => {
	let holder = Function(`return new (class C${i} { })`)(); // create different dynamic classes so they're distinguishable in object previews
	holder.MultipleReferenceObject = Root.MultipleReferenceObject;
	return holder;
	});

	Root.RepeatedReferenceObject = new (class RepeatedReferenceObject { });
	Root.RepeatedReferenceHolder = new (class RepeatedReferenceHolder { });
	for (let i = 0; i < 1000; ++i)
	Root.RepeatedReferenceHolder[i] = Root.RepeatedReferenceObject;

	function test() {
	function queryHolders(target, callback) {
	WI.runtimeManager.evaluateInInspectedWindow(`queryHolders(${target})`, {objectGroup: "test", includeCommandLineAPI: true, generatePreview: true}, callback);
	}

	let suite = InspectorTest.createAsyncSuite("CommandLineAPI.queryHolders");

	function addTest(target) {
	suite.addTestCase({
	name: `CommandLineAPI.queryHolders.${target}`,
	test(resolve, reject) {
	queryHolders("Root." + target, (remoteObject, wasThrown, savedResultIndex) => {
	if (wasThrown) {
	InspectorTest.fail("An exception was thrown.");
	InspectorTest.log(remoteObject.description);
	resolve();
	return;
	}

	InspectorTest.assert(remoteObject.type === "object", "The result should be an object.");
	InspectorTest.assert(remoteObject.subtype === "array", "The result should be an array object.");

	if (remoteObject.preview.propertyPreviews.length < 5) {
	let propertyPreviews = remoteObject.preview.propertyPreviews.map((preview) => preview.value \|\| preview.subtype \|\| preview.type);
	propertyPreviews.sort();
	InspectorTest.log("[" + propertyPreviews.join(", ") + "] (" + remoteObject.preview.size + ")");
	} else
	InspectorTest.log("[<filtered>] (" + remoteObject.preview.size + ")");

	resolve();
	});
	}
	});
	}

	addTest(`Root`);

	addTest(`A`);
	addTest(`B`);
	addTest(`C`);

	addTest(`Array`);
	addTest(`ArrayItem`);

	addTest(`Map`);
	addTest(`MapKey`);
	addTest(`MapValue`);

	addTest(`Set`);
	addTest(`SetItem`);

	addTest(`WeakMap`);
	addTest(`WeakMapKey`);
	addTest(`WeakMapValue`);

	addTest(`WeakSet`);
	addTest(`WeakSetItem`);

	addTest(`Promise`);
	addTest(`PromiseThen`);
	addTest(`PromiseCatch`);
	addTest(`PromiseFinally`);

	addTest(`EventListenerCallback`);

	addTest(`SymbolReferenceObject`);
	addTest(`MultipleReferenceObject`);
	addTest(`RepeatedReferenceObject`);

	suite.addTestCase({
	name: "CommandLineAPI.queryHolders.OnlyHeldByDebugger",
	async test() {
	let savedResult = null;

	{
	let [remoteObject, wasThrown, savedResultIndex] = await promisify((callback) => {
	WI.runtimeManager.evaluateInInspectedWindow(`new (class OnlyHeldByDebugger { })`, {
	objectGroup: "test",
	includeCommandLineAPI: true,
	generatePreview: true,
	saveResult: true,
	}, callback);
	});

	InspectorTest.assert(!wasThrown);
	if (wasThrown)
	InspectorTest.log(remoteObject.description);

	savedResult = "$" + savedResultIndex;
	}

	{
	let [remoteObject, wasThrown, savedResultIndex] = await promisify((callback) => {
	queryHolders(savedResult, callback);
	});

	InspectorTest.assert(!wasThrown);
	if (wasThrown)
	InspectorTest.log(remoteObject.description);

	InspectorTest.assert(remoteObject.type === "object", "The result should be an object.");
	InspectorTest.assert(remoteObject.subtype === "array", "The result should be an array object.");
	InspectorTest.expectEqual(remoteObject.size, 0, `The result should have 0 items.`);
	}
	}
	});

	suite.addTestCase({
	name: "CommandLineAPI.queryHolders.NonObject",
	test(resolve, reject) {
	const target = `"test"`;
	queryHolders(target, (remoteObject, wasThrown, savedResultIndex) => {
	InspectorTest.expectTrue(wasThrown, "Should produce an exception.");
	InspectorTest.log("Error: " + remoteObject.description);
	resolve();
	});
	}
	});

	suite.addTestCase({
	name: "CommandLineAPI.queryHolders.NoParameter",
	test(resolve, reject) {
	const target = ``;
	queryHolders(target, (remoteObject, wasThrown, savedResultIndex) => {
	if (wasThrown) {
	InspectorTest.fail("An exception was thrown.");
	InspectorTest.log(remoteObject.description);
	reject();
	return;
	}

	InspectorTest.expectEqual(remoteObject.type, "undefined", "The result should be undefined.");
	resolve();
	});
	}
	});

	suite.runTestCasesAndFinish();
	}
	</script>
	</head>
	<body onload="runTest()">
	<p>Tests for the `queryHolders` function in the Command Line API.</p>
	</body>
	</html>