| <!DOCTYPE html> |
| <html> |
| <head> |
| <script src="../../http/tests/inspector/resources/inspector-test.js"></script> |
| <script> |
| class ClassA { } |
| class ClassB extends ClassA { } |
| class ClassC extends ClassB { } |
| |
| var Instances = { |
| ClassA: new ClassA, |
| ClassB: new ClassB, |
| ClassC: new ClassC, |
| Object: new Object, |
| Function: new Function, |
| Array: new Array, |
| Boolean: new Boolean, |
| String: new String, |
| Symbol: Symbol(), |
| Number: new Number, |
| Date: new Date, |
| RegExp: new RegExp, |
| Map: new Map, |
| Set: new Set, |
| Promise: new Promise(function() {}), |
| }; |
| |
| var Proxies = { |
| constructor: Proxy, |
| basic: new Proxy({}, {}), |
| object: new Proxy({}, { get() { return Object.prototype; } }), |
| tricky: new Proxy({}, { get() { return this.count++ === 0 ? ClassA : Object.prototype; } }), |
| }; |
| |
| var objectWithDisallowedPrototypeGetter = { |
| get prototype() { return Object.prototype; }, |
| }; |
| |
| var objectWithErrorPrototypeGetter = { |
| get prototype() { throw 42; }, |
| }; |
| |
| class FunctionPrototypeReplacement { }; |
| Function.prototype.__proto__ = FunctionPrototypeReplacement.prototype; |
| |
| class ArrayPrototypeReplacement { }; |
| Array.prototype.__proto__ = ArrayPrototypeReplacement.prototype; |
| |
| class MapPrototypeReplacement { }; |
| Map.prototype.__proto__ = MapPrototypeReplacement.prototype; |
| |
| class SetPrototypeReplacement { }; |
| Set.prototype.__proto__ = SetPrototypeReplacement.prototype; |
| |
| class PromisePrototypeReplacement { }; |
| Promise.prototype.__proto__ = PromisePrototypeReplacement.prototype; |
| |
| function clearInstances() { |
| Instances = {}; |
| } |
| |
| function test() { |
| function queryInstances(prototypeOrConstructor, callback) { |
| WI.runtimeManager.evaluateInInspectedWindow(`queryInstances(${prototypeOrConstructor})`, {objectGroup: "test", includeCommandLineAPI: true, generatePreview: true}, callback); |
| } |
| |
| let suite = InspectorTest.createAsyncSuite("CommandLineAPI.queryInstances"); |
| |
| let cases = [ |
| {prototypeOrConstructor: `Instances.ClassA`, resultCount: 0}, |
| {prototypeOrConstructor: `ClassA`, resultCount: 5}, |
| {prototypeOrConstructor: `ClassA.prototype`, resultCount: 5}, |
| |
| {prototypeOrConstructor: `Instances.ClassB`, resultCount: 0}, |
| {prototypeOrConstructor: `ClassB`, resultCount: 3}, |
| {prototypeOrConstructor: `ClassB.prototype`, resultCount: 3}, |
| |
| {prototypeOrConstructor: `Instances.ClassC`, resultCount: 0}, |
| {prototypeOrConstructor: `ClassC`, resultCount: 1}, |
| {prototypeOrConstructor: `ClassC.prototype`, resultCount: 1}, |
| |
| {prototypeOrConstructor: `HTMLDocument`, resultCount: 1}, |
| {prototypeOrConstructor: `HTMLBodyElement`, resultCount: 1}, |
| {prototypeOrConstructor: `HTMLImageElement`, resultCount: 0}, |
| |
| {prototypeOrConstructor: `objectWithDisallowedPrototypeGetter`, resultCount: 0}, |
| {prototypeOrConstructor: `objectWithErrorPrototypeGetter`, resultCount: 0}, |
| |
| {prototypeOrConstructor: `undefined`, shouldThrow: true}, |
| {prototypeOrConstructor: `null`, shouldThrow: true}, |
| {prototypeOrConstructor: `Infinity`, shouldThrow: true}, |
| {prototypeOrConstructor: `NaN`, shouldThrow: true}, |
| {prototypeOrConstructor: `1`, shouldThrow: true}, |
| {prototypeOrConstructor: `true`, shouldThrow: true}, |
| {prototypeOrConstructor: `"test"`, shouldThrow: true}, |
| |
| {prototypeOrConstructor: `Instances.Symbol`, shouldThrow: true}, |
| {prototypeOrConstructor: `Symbol`, resultCount: 0}, |
| {prototypeOrConstructor: `Symbol.prototype`, resultCount: 0}, |
| |
| {prototypeOrConstructor: `Proxies.constructor`, resultCount: 0}, |
| {prototypeOrConstructor: `Proxies.basic`, shouldThrow: true}, |
| {prototypeOrConstructor: `Proxies.object`, shouldThrow: true}, |
| {prototypeOrConstructor: `Proxies.tricky`, shouldThrow: true}, |
| ]; |
| |
| for (let type of ["Object", "Function", "Array", "Map", "Set", "Promise"]) { |
| cases.push({prototypeOrConstructor: `Instances.${type}`, resultCount: 0}); |
| cases.push({prototypeOrConstructor: type, shouldThrow: true}); |
| cases.push({prototypeOrConstructor: `${type}.prototype`, shouldThrow: true}); |
| } |
| |
| for (let type of ["FunctionPrototypeReplacement", "ArrayPrototypeReplacement", "MapPrototypeReplacement", "SetPrototypeReplacement", "PromisePrototypeReplacement"]) { |
| cases.push({prototypeOrConstructor: type, shouldThrow: true}); |
| cases.push({prototypeOrConstructor: `${type}.prototype`, shouldThrow: true}); |
| } |
| |
| for (let type of ["Boolean", "String", "Number", "Date", "RegExp"]) { |
| cases.push({prototypeOrConstructor: `Instances.${type}`, resultCount: 0}); |
| cases.push({prototypeOrConstructor: type}); |
| cases.push({prototypeOrConstructor: `${type}.prototype`}); |
| } |
| |
| for (let {prototypeOrConstructor, resultCount, shouldThrow} of cases) { |
| suite.addTestCase({ |
| name: `CommandLineAPI.queryInstances.${prototypeOrConstructor}`, |
| test(resolve, reject) { |
| queryInstances(prototypeOrConstructor, (remoteObject, wasThrown, savedResultIndex) => { |
| if (shouldThrow) { |
| InspectorTest.expectThat(wasThrown, `Calling "queryInstances" with "${prototypeOrConstructor}" should throw an exception.`); |
| InspectorTest.log(remoteObject.description); |
| if (wasThrown) { |
| resolve(); |
| return; |
| } |
| } else if (wasThrown) { |
| InspectorTest.fail("An exception was thrown."); |
| InspectorTest.log(remoteObject.description); |
| resolve(); |
| return; |
| } |
| |
| InspectorTest.expectEqual(remoteObject.type, "object", "The result should be an object."); |
| InspectorTest.expectEqual(remoteObject.subtype, "array", "The result should be an array object."); |
| |
| if (resultCount === undefined) |
| InspectorTest.expectGreaterThan(remoteObject.size, 0, `The result should have at least 1 item.`); |
| else { |
| InspectorTest.expectEqual(remoteObject.size, resultCount, `The result should have ${resultCount} items.`); |
| if (remoteObject.size) { |
| let propertyPreviews = remoteObject.preview.propertyPreviews.map((preview) => preview.value); |
| propertyPreviews.sort(); |
| InspectorTest.log("[" + propertyPreviews.join(", ") + "]"); |
| } |
| } |
| |
| resolve(); |
| }); |
| } |
| }); |
| } |
| |
| suite.addTestCase({ |
| name: "CommandLineAPI.queryInstances.GC", |
| test(resolve, reject) { |
| queryInstances(`ClassC`, (remoteObject, wasThrown, savedResultIndex) => { |
| InspectorTest.assert(!wasThrown); |
| if (wasThrown) |
| InspectorTest.log(remoteObject.description); |
| |
| InspectorTest.expectEqual(remoteObject.size, 1, `Should be 1 ClassC instance.`); |
| |
| InspectorTest.log("Clearing instances..."); |
| |
| RuntimeAgent.releaseObjectGroup("test"); |
| InspectorTest.evaluateInPage(`clearInstances()`); |
| |
| queryInstances(`ClassC`, (remoteObject, wasThrown, savedResultIndex) => { |
| InspectorTest.assert(!wasThrown); |
| if (wasThrown) |
| InspectorTest.log(remoteObject.description); |
| |
| InspectorTest.expectEqual(remoteObject.size, 0, `Should now be 0 ClassC instances.`); |
| resolve(); |
| }); |
| }); |
| } |
| }); |
| |
| suite.addTestCase({ |
| name: "CommandLineAPI.queryInstances.NoParameter", |
| test(resolve, reject) { |
| const prototypeOrConstructor = ""; |
| queryInstances(prototypeOrConstructor, (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 `queryInstances` function in the Command Line API.</p> |
| </body> |
| </html> |
