216 lines
8.5 KiB
HTML
216 lines
8.5 KiB
HTML
<!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>
|