LayoutTests/inspector/model/remote-object.html

   1 <!doctype html>
   2 <html>
   3 <head>
   4 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
   5 <script type="text/javascript" src="../../http/tests/inspector/inspector-test.js"></script>
   6 <script>
   7 function test()
   8 {
   9     var currentStepIndex = 0;
  10     var steps = [
  11     // Special:
  12
  13         // Null / undefined
  14         {expression: "null"},
  15         {expression: "undefined"},
  16
  17         // Symbol
  18         {expression: "Symbol()"},
  19         {expression: "Symbol('test')"},
  20
  21     // Primatives:
  22
  23         // Boolean
  24         {expression: "true"},
  25         {expression: "false"},
  26
  27         // Number
  28         {expression: "0"},
  29         {expression: "-0"},
  30         {expression: "1"},
  31         {expression: "-1"},
  32         {expression: "1.234"},
  33         {expression: "-1.234"},
  34         {expression: "1e3"},
  35         {expression: "Number.MAX_VALUE"},
  36         {expression: "Number.MIN_VALUE"},
  37         {expression: "NaN"},
  38         {expression: "Infinity"},
  39         {expression: "-Infinity"},
  40
  41         // Strings
  42         {expression: "''"},
  43         {expression: "'\"'"}, // a single quote
  44         {expression: "\"'\""}, // a double quote
  45         {expression: "'string'"},
  46         {expression: "'Unicode…'"},
  47         {expression: "'I wish I had something to put here.'"},
  48
  49         // Function
  50         {expression: "(function(){})"},
  51         {expression: "function foo(){}; foo"},
  52         {expression: "function myFunction(a, b) { console.log(a, b); }; myFunction"},
  53         {expression: "function myTarget(a, b) { console.log(a, b); }; myTarget.bind(null)"}, // bound function
  54         {expression: "Array.prototype.push"}, // native (ECMAScript)
  55         {expression: "window.setTimeout"}, // native (DOM)
  56         {expression: "Object.getOwnPropertyDescriptor({ get getter() { return 1 } }, 'getter').get"}, // getter
  57         {expression: "Object.getOwnPropertyDescriptor({ set setter(v) { console.log(v); } }, 'setter').set"}, // setter
  58
  59     // Objects:
  60
  61         // Date
  62         {expression: "new Date(99)", browserOnly: true},
  63         {expression: "new Date(1421903245871)", browserOnly: true},
  64
  65         // Regexp
  66         {expression: "/ /"},
  67         {expression: "/(?:)/"},
  68         {expression: "/^r(e)g[e]{1,}x+/"},
  69         {expression: "/^r(e)g[e]{1,}x+/ig"},
  70         {expression: "new RegExp('')"},
  71         {expression: "new RegExp('test', 'i')"},
  72
  73         // Array
  74         {expression: "[]"},
  75         {expression: "[0, -0, 1, 2]"},
  76         {expression: "[[1],[2],[3]]"},
  77         {expression: "[true, 1, 1.234, 'string', /regex/]"},
  78         {expression: "[[null]]"},
  79         {expression: "[[undefined]]"},
  80         {expression: "[{a:1}, {b:2}, {c:2}]"},
  81         {expression: "[[{a:1}, {b:2}, {c:2}]]"},
  82         {expression: "arr = []; arr.length = 100; arr"}, // 100 empty elements
  83         {expression: "arr = []; arr.length = 100; arr.fill(1)"}, // 100 full elements
  84         {expression: "arr = []; arr.length = 100; arr[10] = 1; arr"}, // sparse
  85
  86         // Array-like (Arguments, TypedArrays)
  87         {expression: "a = null; (function() { a = arguments; })(1, '2', /3/); a"},
  88         {expression: "new Int32Array(new ArrayBuffer(16))"},
  89         {expression: "var intArray = new Int32Array(new ArrayBuffer(16)); for (var i = 0; i < intArray.length; ++i) intArray[i] = i; intArray"},
  90
  91         // Object
  92         {expression: "({})"},
  93         {expression: "({a: 1})"},
  94         {expression: "({a: 1, b: 0, c: -0})"},
  95         {expression: "({a: 1, b: \"string\", c: /regex/, d: Symbol('sym')})"},
  96         {expression: "o = {a:1}; o.b = o; o"}, // Cyclic.
  97         {expression: "({a:function a(){}, b:function b(){}, get getter(){}, set setter(v){}})"},
  98         {expression: "function Foo() {}; new Foo"},
  99         {expression: "var Foo2 = function() {}; new Foo2"},
 100         {expression: "var namespace = {}; namespace.Foo3 = function() {}; new namespace.Foo3"},
 101         {expression: "function Bar() { this._x = 5 }; Bar.prototype = {constructor: Bar, get x() {return this._x;}}; new Bar"},
 102         {expression: "function Bar2() { this._x = 5 }; Bar.prototype = {get x() {return this._x;}}; new Bar2"},
 103         {expression: "window.loadEvent"}, // window.loadEvent is set inside of <body onload="..."> below.
 104         {expression: "new ArrayBuffer(16)"},
 105         {expression: "new DataView(new ArrayBuffer(16))"},
 106         {expression: "obj = {}; obj['prop'] = 1; obj[Symbol()] = 2; obj[Symbol('sym')] = 3; obj[Symbol('sym')] = 4; obj[Symbol.iterator] = Symbol(); obj"}, // Symbol properties
 107
 108         // Node
 109         {expression: "document.body"},
 110         {expression: "div = document.createElement('div'); div.className = 'foo bar'; div"},
 111         {expression: "span = document.createElement('span'); span.id = 'foo'; span"},
 112         {expression: "document.createTextNode('text')"},
 113
 114         // Node Collections (NodeLists / Collections)
 115         {expression: "document.all", browserOnly: true}, // HTMLAllCollection
 116         {expression: "document.head.children"}, // HTMLCollection
 117         {expression: "document.getElementsByClassName('my-test')"}, // NodeList
 118         {expression: "document.querySelectorAll('.my-test')"}, // Non-Live NodeList
 119
 120         // Error
 121         {expression: "error = null; try { [].x.x; } catch (e) { error = e; }; error"},
 122         {expression: "error = null; try { eval('if()'); } catch (e) { error = e; }; error"},
 123         {expression: "error = null; try { document.createTextNode('').splitText(100); } catch (e) { error = e; }; error"},
 124
 125         // Map / WeakMap
 126         {expression: "new Map"},
 127         {expression: "map = new Map; map.set(1, 2); map.set('key', 'value'); map"},
 128         {expression: "map = new Map; map.set({a:1}, {b:2}); map.set(document.body, [1,2]); map"},
 129         {expression: "map = new Map; for (var i = 0; i <= 100; i++) map.set(i, i); map"},
 130         {expression: "map = new WeakMap; strongKey = {id:1}; map.set(strongKey, [1,2]); map"},
 131
 132         // Set
 133         {expression: "new Set"},
 134         {expression: "set = new Set; set.add(1); set.add(2); set.add('key'); set"},
 135         {expression: "set = new Set; set.add({a:1}); set.add(document.body); set.add([1,2]); set"},
 136         {expression: "set = new Set; for (var i = 0; i <= 100; i++) set.add(i); set"},
 137
 138         // Iterators
 139         {expression: "'a'[Symbol.iterator]()"},
 140         {expression: "'long string'[Symbol.iterator]()"},
 141         {expression: "[][Symbol.iterator]()"},
 142         {expression: "[1][Symbol.iterator]()"},
 143         {expression: "[1, 'two', 3, 'four', 5, 'size'][Symbol.iterator]()"},
 144         {expression: "[1, 'two', 3, 'four', 5, 'size'].keys()"},
 145         {expression: "[1, 'two', 3, 'four', 5, 'size'].entries()"},
 146         {expression: "map = new Map; map.set(1, 2); map.set('key', 'value'); map.values()"},
 147         {expression: "map.keys()"},
 148         {expression: "map.entries()"},
 149         {expression: "set = new Set; for (var i = 0; i <= 100; i++) set.add(i); set.values()"},
 150         {expression: "map.entries()"},
 151         {expression: "x = undefined; (function() { x = arguments; })(1, 'two'); x[Symbol.iterator]()"},
 152
 153         // Promise
 154         {expression: "new Promise(function(){})"},
 155         {expression: "Promise.reject()"},
 156         {expression: "Promise.reject('result')"},
 157         {expression: "Promise.resolve()"},
 158         {expression: "Promise.resolve({result:1})"},
 159
 160     // Classes
 161
 162         {expression: "Person = class Person { constructor(){} get fullName(){} methodName(p1, p2){} }; Person"}, // Constructor => class type
 163         {expression: "Person.prototype.methodName"}, // Method => just a function type
 164         {expression: "Alpha = class A { methodA(){} }; Beta = class B extends Alpha { methodB(){} }; Beta"},
 165         {expression: "[Beta]"},
 166
 167     // Improveable:
 168
 169         // Sealed / Frozen objects.
 170         {expression: "Object.seal({})"},
 171         {expression: "Object.freeze({})"},
 172     ];
 173
 174     if (!window.WebInspector) {
 175         window.steps = steps;
 176         return;
 177     }
 178
 179     function remoteObjectJSONFilter(key, value)
 180     {
 181         if (key === "_objectId")
 182             return "<filtered>";
 183
 184         if (key === "_hasChildren")
 185             return undefined;
 186
 187         return value;
 188     }
 189
 190     function runSteps() {
 191
 192         function afterStep() {
 193             if (++currentStepIndex >= steps.length)
 194                 InspectorTest.completeTest();
 195         }
 196
 197         function runStep(step) {
 198             if (step.browserOnly) {
 199                 afterStep();
 200                 return;
 201             }
 202
 203             WebInspector.runtimeManager.evaluateInInspectedWindow(step.expression, "test", false, true, false, true, false, function(remoteObject, wasThrown) {
 204                 InspectorTest.log("");
 205                 InspectorTest.log("-----------------------------------------------------");
 206                 InspectorTest.log("EXPRESSION: " + step.expression);
 207                 InspectorTest.assert(remoteObject instanceof WebInspector.RemoteObject);
 208                 InspectorTest.log(JSON.stringify(remoteObject, remoteObjectJSONFilter, "  "));
 209                 afterStep();
 210             });
 211         }
 212
 213         for (var step of steps)
 214             runStep(step);
 215     }
 216
 217     runSteps();
 218 }
 219
 220 function runInBrowserTest()
 221 {
 222     if (window.testRunner)
 223         return;
 224
 225     test(); // get steps.
 226
 227     for (var step of steps) {
 228         console.info("EXPRESSION", step.expression);
 229         try {
 230             console.log(eval(step.expression));
 231         } catch (e) {
 232             console.log("EXCEPTION: " + e);
 233         }
 234     }
 235 }
 236 </script>
 237 </head>
 238 <body onload="window.loadEvent = event; runTest(); runInBrowserTest();">
 239     <p class="my-test"></p><p class="my-test"></p><p class="my-test"></p>
 240 </body>
 241 </html>