1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
|
// Copyright 2017 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
let {session, contextGroup, Protocol} =
InspectorTest.start('Checks Runtime.queryObjects');
InspectorTest.runAsyncTestSuite([
async function testClass() {
let contextGroup = new InspectorTest.ContextGroup();
let session = contextGroup.connect();
let Protocol = session.Protocol;
InspectorTest.log('Declare class Foo & store its constructor.');
await Protocol.Runtime.evaluate({
expression: 'class Foo{constructor(){}};'
});
let {result:{result:{objectId}}} = await Protocol.Runtime.evaluate({
expression: 'Foo.prototype'
});
for (let i = 0; i < 2; ++i) {
InspectorTest.log('Create object with class Foo.');
Protocol.Runtime.evaluate({expression: 'new Foo()'});
await queryObjects(session, objectId, 'Foo');
}
session.disconnect();
},
async function testDerivedNewClass() {
let contextGroup = new InspectorTest.ContextGroup();
let session = contextGroup.connect();
let Protocol = session.Protocol;
InspectorTest.log('Declare class Foo & store its constructor.');
Protocol.Runtime.evaluate({expression: 'class Foo{};'});
let {result:{result:{objectId}}} = await Protocol.Runtime.evaluate({
expression: 'Foo.prototype'
});
let fooConstructorId = objectId;
InspectorTest.log('Declare class Boo extends Foo & store its constructor.');
Protocol.Runtime.evaluate({expression: 'class Boo extends Foo{};'});
({result:{result:{objectId}}} = await Protocol.Runtime.evaluate({
expression: 'Boo.prototype'
}));
let booConstructorId = objectId;
await queryObjects(session, fooConstructorId, 'Foo');
await queryObjects(session, booConstructorId, 'Boo');
InspectorTest.log('Create object with class Foo');
Protocol.Runtime.evaluate({expression: 'new Foo()'});
await queryObjects(session, fooConstructorId, 'Foo');
InspectorTest.log('Create object with class Boo');
Protocol.Runtime.evaluate({expression: 'new Boo()'});
await queryObjects(session, fooConstructorId, 'Foo');
await queryObjects(session, booConstructorId, 'Boo');
session.disconnect();
},
async function testNewFunction() {
let contextGroup = new InspectorTest.ContextGroup();
let session = contextGroup.connect();
let Protocol = session.Protocol;
InspectorTest.log('Declare Foo & store it.');
Protocol.Runtime.evaluate({expression: 'function Foo(){}'});
let {result:{result:{objectId}}} = await Protocol.Runtime.evaluate({
expression: 'Foo.prototype'
});
for (let i = 0; i < 2; ++i) {
InspectorTest.log('Create object using Foo.');
Protocol.Runtime.evaluate({expression: 'new Foo()'});
await queryObjects(session, objectId, 'Foo');
}
session.disconnect();
},
async function testNonInspectable() {
let contextGroup = new InspectorTest.ContextGroup();
let session = contextGroup.connect();
let Protocol = session.Protocol;
InspectorTest.log('Declare Foo & store it.');
Protocol.Runtime.evaluate({expression: 'function Foo(){}'});
let {result:{result:{objectId}}} = await Protocol.Runtime.evaluate({
expression: 'Foo.prototype'
});
InspectorTest.log('Create object using Foo.');
Protocol.Runtime.evaluate({expression: 'a = new Foo()'});
await queryObjects(session, objectId, 'Foo');
InspectorTest.log('Mark object as not inspectable.')
Protocol.Runtime.evaluate({expression: 'inspector.markObjectAsNotInspectable(a)'});
await queryObjects(session, objectId, 'Foo');
session.disconnect();
},
async function testObjectCreate() {
let contextGroup = new InspectorTest.ContextGroup();
let session = contextGroup.connect();
let Protocol = session.Protocol;
InspectorTest.log('Declare Object p & store it.');
let {result:{result:{objectId}}} = await Protocol.Runtime.evaluate({
expression: 'p = {a:1}'
});
for (let i = 0; i < 2; ++i) {
InspectorTest.log('Create object using Object.create(p).');
Protocol.Runtime.evaluate({expression: 'Object.create(p)'});
await queryObjects(session, objectId, 'p');
}
session.disconnect();
}
]);
const constructorsNameFunction = `
function() {
return this.map(o => o.constructor.name + ',' + typeof o).sort();
}`;
async function queryObjects(sesion, prototypeObjectId, name) {
let {result:{objects}} = await sesion.Protocol.Runtime.queryObjects({
prototypeObjectId
});
InspectorTest.log(`Query objects with ${name} prototype.`);
let {result:{result:{value}}} = await sesion.Protocol.Runtime.callFunctionOn({
objectId: objects.objectId,
functionDeclaration: constructorsNameFunction,
returnByValue: true
});
InspectorTest.log('Dump each object constructor name.');
InspectorTest.logMessage(value);
}
|
