LayoutTests/inspector/model/remote-object.html - WebKit - Git at Google

 <!doctype html>
 <html>
 <head>
 <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
 <script type="text/javascript" src="../../http/tests/inspector/resources/inspector-test.js"></script>
 <script>
 function test()
 {
     var currentStepIndex = 0;
     var steps = [
     // Special:

         // Null / undefined
         {expression: "null"},
         {expression: "undefined"},

         // Symbol
         {expression: "Symbol()"},
         {expression: "Symbol('test')"},

     // Primatives:

         // Boolean
         {expression: "true"},
         {expression: "false"},

         // Number
         {expression: "0"},
         {expression: "-0"},
         {expression: "1"},
         {expression: "-1"},
         {expression: "1.234"},
         {expression: "-1.234"},
         {expression: "1e3"},
         {expression: "Number.MAX_VALUE"},
         {expression: "Number.MIN_VALUE"},
         {expression: "NaN"},
         {expression: "Infinity"},
         {expression: "-Infinity"},

         // Strings
         {expression: "''"},
         {expression: "'\"'"}, // a single quote
         {expression: "\"'\""}, // a double quote
         {expression: "'string'"},
         {expression: "'Unicode…'"},
         {expression: "'I wish I had something to put here.'"},

         // Function
         {expression: "(function(){})"},
         {expression: "function foo(){}; foo"},
         {expression: "function myFunction(a, b) { console.log(a, b); }; myFunction"},
         {expression: "function myTarget(a, b) { console.log(a, b); }; myTarget.bind(null)"}, // bound function
         {expression: "Array.prototype.push"}, // native (ECMAScript)
         {expression: "window.setTimeout"}, // native (DOM)
         {expression: "Object.getOwnPropertyDescriptor({ get getter() { return 1 } }, 'getter').get"}, // getter
         {expression: "Object.getOwnPropertyDescriptor({ set setter(v) { console.log(v); } }, 'setter').set"}, // setter

     // Objects:

         // Date
         {expression: "new Date(99)", browserOnly: true},
         {expression: "new Date(1421903245871)", browserOnly: true},

         // Regexp
         {expression: "/ /"},
         {expression: "/(?:)/"},
         {expression: "/^r(e)g[e]{1,}x+/"},
         {expression: "/^r(e)g[e]{1,}x+/ig"},
         {expression: "new RegExp('')"},
         {expression: "new RegExp('test', 'i')"},

         // Array
         {expression: "[]"},
         {expression: "[0, -0, 1, 2]"},
         {expression: "[[1],[2],[3]]"},
         {expression: "[true, 1, 1.234, 'string', /regex/]"},
         {expression: "[[null]]"},
         {expression: "[[undefined]]"},
         {expression: "[{a:1}, {b:2}, {c:2}]"},
         {expression: "[[{a:1}, {b:2}, {c:2}]]"},
         {expression: "arr = []; arr[0] = arr; arr"}, // cyclic
         {expression: "arr = []; arr.length = 100; arr"}, // 100 empty elements
         {expression: "arr = []; arr.length = 100; arr.fill(1)"}, // 100 full elements
         {expression: "arr = []; arr.length = 100; arr[10] = 1; arr"}, // sparse

         // Array-like (Arguments, TypedArrays)
         {expression: "a = null; (function() { a = arguments; })(1, '2', /3/); a"},
         {expression: "new Int32Array(new ArrayBuffer(16))"},
         {expression: "var intArray = new Int32Array(new ArrayBuffer(16)); for (var i = 0; i < intArray.length; ++i) intArray[i] = i; intArray"},
         {expression: "var buffer = new ArrayBuffer(10000000); var int8View = new Int8Array(buffer); int8View"}, // 10000000 elements.

         // Object
         {expression: "({})"},
         {expression: "({a: 1})"},
         {expression: "({a: 1, b: 0, c: -0})"},
         {expression: "({a: 1, b: \"string\", c: /regex/, d: Symbol('sym')})"},
         {expression: "o = {a:1}; o.b = o; o"}, // cyclic
         {expression: "({a:function a(){}, b:function b(){}, get getter(){}, set setter(v){}})"},
         {expression: "function Foo() {}; new Foo"},
         {expression: "var Foo2 = function() {}; new Foo2"},
         {expression: "var namespace = {}; namespace.Foo3 = function() {}; new namespace.Foo3"},
         {expression: "function Bar() { this._x = 5 }; Bar.prototype = {constructor: Bar, get x() {return this._x;}}; new Bar"},
         {expression: "function Bar2() { this._x = 5 }; Bar.prototype = {get x() {return this._x;}}; new Bar2"},
         {expression: "window.loadEvent"}, // window.loadEvent is set inside of <body onload="..."> below.
         {expression: "new ArrayBuffer(16)"},
         {expression: "new DataView(new ArrayBuffer(16))"},
         {expression: "obj = {}; obj['prop'] = 1; obj[Symbol()] = 2; obj[Symbol('sym')] = 3; obj[Symbol('sym')] = 4; obj[Symbol.iterator] = Symbol(); obj"}, // Symbol properties

         // Node
         {expression: "document.body"},
         {expression: "div = document.createElement('div'); div.className = 'foo bar'; div"},
         {expression: "span = document.createElement('span'); span.id = 'foo'; span"},
         {expression: "input = document.createElement('input'); input.type = 'password'; input"},
         {expression: "text = document.createTextNode('text content'); text"},
         {expression: "comment = document.createComment('comment content'); comment"},
         {expression: "svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'rect'); svgElement.classList.add('test'); svgElement"},
         {expression: "[document.body, div, span, input, text, comment, svgElement]"},

         // Node Collections (NodeLists / Collections)
         {expression: "document.all", browserOnly: true}, // HTMLAllCollection
         {expression: "document.head.children"}, // HTMLCollection
         {expression: "document.getElementsByClassName('my-test')"}, // NodeList
         {expression: "document.querySelectorAll('.my-test')"}, // Non-Live NodeList

         // Error
         {expression: "error = null; try { [].x.x; } catch (e) { error = e; }; error"},
         {expression: "error = null; try { eval('if()'); } catch (e) { error = e; }; error"},
         {expression: "error = null; try { document.createTextNode('').splitText(100); } catch (e) { error = e; }; error"},

         // Map / WeakMap
         {expression: "new Map"},
         {expression: "map = new Map; map.set(1, 2); map.set('key', 'value'); map"},
         {expression: "map = new Map; map.set({a:1}, {b:2}); map.set(document.body, [1,2]); map"},
         {expression: "map = new Map; for (var i = 0; i <= 100; i++) map.set(i, i); map"},
         {expression: "map = new Map; map.set(map, map); map"},
         {expression: "map = new WeakMap; strongKey = {id:1}; map.set(strongKey, [1,2]); map"},

         // Set / WeakSet
         {expression: "new Set"},
         {expression: "set = new Set; set.add(1); set.add(2); set.add('key'); set"},
         {expression: "set = new Set; set.add({a:1}); set.add(document.body); set.add([1,2]); set"},
         {expression: "set = new Set; for (var i = 0; i <= 100; i++) set.add(i); set"},
         {expression: "set = new Set; set.add(set); set"},
         {expression: "set = new WeakSet; strongKey = {id:1}; set.add(strongKey); set"},

         // Iterators
         {expression: "'a'[Symbol.iterator]()"},
         {expression: "'long string'[Symbol.iterator]()"},
         {expression: "[][Symbol.iterator]()"},
         {expression: "[1][Symbol.iterator]()"},
         {expression: "[1, 'two', 3, 'four', 5, 'size'][Symbol.iterator]()"},
         {expression: "[1, 'two', 3, 'four', 5, 'size'].keys()"},
         {expression: "[1, 'two', 3, 'four', 5, 'size'].entries()"},
         {expression: "map = new Map; map.set(1, 2); map.set('key', 'value'); map.values()"},
         {expression: "map.keys()"},
         {expression: "map.entries()"},
         {expression: "set = new Set; for (var i = 0; i <= 100; i++) set.add(i); set.values()"},
         {expression: "map.entries()"},
         {expression: "x = undefined; (function() { x = arguments; })(1, 'two'); x[Symbol.iterator]()"},
         {expression: "Reflect.enumerate({a:1, b:2, c:3})"},
         {expression: "Reflect.enumerate([1, 2, 3, 4, 5, 6, 7])"},

         // Promise
         {expression: "new Promise(function(){})"},
         {expression: "Promise.reject()"},
         {expression: "Promise.reject('result')"},
         {expression: "Promise.resolve()"},
         {expression: "Promise.resolve({result:1})"},

         // Proxy
         {expression: "new Proxy({x:1, y:1}, {handler: true})"},

     // Classes

         {expression: "Person = class Person { constructor(name){} get fullName(){} methodName(p1, p2){} }; Person"}, // Constructor => class type
         {expression: "Person.prototype.methodName"}, // Method => just a function type
         {expression: "Alpha = class A { methodA(){} }; Beta = class B extends Alpha { methodB(){} }; Beta"},
         {expression: "[Beta]"},

     // Improveable:

         // Sealed / Frozen objects.
         {expression: "Object.seal({})"},
         {expression: "Object.freeze({})"},
     ];

     if (!window.WebInspector) {
         window.steps = steps;
         return;
     }

     function remoteObjectJSONFilter(key, value)
     {
         if (key === "_objectId")
             return "<filtered>";

         if (key === "_hasChildren")
             return undefined;

         return value;
     }

     function runSteps() {

         function afterStep() {
             if (++currentStepIndex >= steps.length)
                 InspectorTest.completeTest();
         }

         function runStep(step) {
             if (step.browserOnly) {
                 afterStep();
                 return;
             }

             WebInspector.runtimeManager.evaluateInInspectedWindow(step.expression, "test", false, true, false, true, false, function(remoteObject, wasThrown) {
                 InspectorTest.log("");
                 InspectorTest.log("-----------------------------------------------------");
                 InspectorTest.log("EXPRESSION: " + step.expression);
                 InspectorTest.assert(remoteObject instanceof WebInspector.RemoteObject);
                 InspectorTest.log(JSON.stringify(remoteObject, remoteObjectJSONFilter, "  "));
                 afterStep();
             });
         }

         for (var step of steps)
             runStep(step);
     }

     runSteps();
 }

 function runInBrowserTest()
 {
     if (window.testRunner)
         return;

     test(); // get steps.

     for (var step of steps) {
         console.info("EXPRESSION", step.expression);
         try {
             console.log(eval(step.expression));
         } catch (e) {
             console.log("EXCEPTION: " + e);
         }
     }
 }
 </script>
 </head>
 <body onload="window.loadEvent = event; runTest(); runInBrowserTest();">
     <p class="my-test"></p><p class="my-test"></p><p class="my-test"></p>
 </body>
 </html>
	<!doctype html>
	<html>
	<head>
	<meta http-equiv="Content-Type" content="text/html; charset=utf-8">
	<script type="text/javascript" src="../../http/tests/inspector/resources/inspector-test.js"></script>
	<script>
	function test()
	{
	var currentStepIndex = 0;
	var steps = [
	// Special:

	// Null / undefined
	{expression: "null"},
	{expression: "undefined"},

	// Symbol
	{expression: "Symbol()"},
	{expression: "Symbol('test')"},

	// Primatives:

	// Boolean
	{expression: "true"},
	{expression: "false"},

	// Number
	{expression: "0"},
	{expression: "-0"},
	{expression: "1"},
	{expression: "-1"},
	{expression: "1.234"},
	{expression: "-1.234"},
	{expression: "1e3"},
	{expression: "Number.MAX_VALUE"},
	{expression: "Number.MIN_VALUE"},
	{expression: "NaN"},
	{expression: "Infinity"},
	{expression: "-Infinity"},

	// Strings
	{expression: "''"},
	{expression: "'\"'"}, // a single quote
	{expression: "\"'\""}, // a double quote
	{expression: "'string'"},
	{expression: "'Unicode…'"},
	{expression: "'I wish I had something to put here.'"},

	// Function
	{expression: "(function(){})"},
	{expression: "function foo(){}; foo"},
	{expression: "function myFunction(a, b) { console.log(a, b); }; myFunction"},
	{expression: "function myTarget(a, b) { console.log(a, b); }; myTarget.bind(null)"}, // bound function
	{expression: "Array.prototype.push"}, // native (ECMAScript)
	{expression: "window.setTimeout"}, // native (DOM)
	{expression: "Object.getOwnPropertyDescriptor({ get getter() { return 1 } }, 'getter').get"}, // getter
	{expression: "Object.getOwnPropertyDescriptor({ set setter(v) { console.log(v); } }, 'setter').set"}, // setter

	// Objects:

	// Date
	{expression: "new Date(99)", browserOnly: true},
	{expression: "new Date(1421903245871)", browserOnly: true},

	// Regexp
	{expression: "/ /"},
	{expression: "/(?:)/"},
	{expression: "/^r(e)g[e]{1,}x+/"},
	{expression: "/^r(e)g[e]{1,}x+/ig"},
	{expression: "new RegExp('')"},
	{expression: "new RegExp('test', 'i')"},

	// Array
	{expression: "[]"},
	{expression: "[0, -0, 1, 2]"},
	{expression: "[[1],[2],[3]]"},
	{expression: "[true, 1, 1.234, 'string', /regex/]"},
	{expression: "[[null]]"},
	{expression: "[[undefined]]"},
	{expression: "[{a:1}, {b:2}, {c:2}]"},
	{expression: "[[{a:1}, {b:2}, {c:2}]]"},
	{expression: "arr = []; arr[0] = arr; arr"}, // cyclic
	{expression: "arr = []; arr.length = 100; arr"}, // 100 empty elements
	{expression: "arr = []; arr.length = 100; arr.fill(1)"}, // 100 full elements
	{expression: "arr = []; arr.length = 100; arr[10] = 1; arr"}, // sparse

	// Array-like (Arguments, TypedArrays)
	{expression: "a = null; (function() { a = arguments; })(1, '2', /3/); a"},
	{expression: "new Int32Array(new ArrayBuffer(16))"},
	{expression: "var intArray = new Int32Array(new ArrayBuffer(16)); for (var i = 0; i < intArray.length; ++i) intArray[i] = i; intArray"},
	{expression: "var buffer = new ArrayBuffer(10000000); var int8View = new Int8Array(buffer); int8View"}, // 10000000 elements.

	// Object
	{expression: "({})"},
	{expression: "({a: 1})"},
	{expression: "({a: 1, b: 0, c: -0})"},
	{expression: "({a: 1, b: \"string\", c: /regex/, d: Symbol('sym')})"},
	{expression: "o = {a:1}; o.b = o; o"}, // cyclic
	{expression: "({a:function a(){}, b:function b(){}, get getter(){}, set setter(v){}})"},
	{expression: "function Foo() {}; new Foo"},
	{expression: "var Foo2 = function() {}; new Foo2"},
	{expression: "var namespace = {}; namespace.Foo3 = function() {}; new namespace.Foo3"},
	{expression: "function Bar() { this._x = 5 }; Bar.prototype = {constructor: Bar, get x() {return this._x;}}; new Bar"},
	{expression: "function Bar2() { this._x = 5 }; Bar.prototype = {get x() {return this._x;}}; new Bar2"},
	{expression: "window.loadEvent"}, // window.loadEvent is set inside of <body onload="..."> below.
	{expression: "new ArrayBuffer(16)"},
	{expression: "new DataView(new ArrayBuffer(16))"},
	{expression: "obj = {}; obj['prop'] = 1; obj[Symbol()] = 2; obj[Symbol('sym')] = 3; obj[Symbol('sym')] = 4; obj[Symbol.iterator] = Symbol(); obj"}, // Symbol properties

	// Node
	{expression: "document.body"},
	{expression: "div = document.createElement('div'); div.className = 'foo bar'; div"},
	{expression: "span = document.createElement('span'); span.id = 'foo'; span"},
	{expression: "input = document.createElement('input'); input.type = 'password'; input"},
	{expression: "text = document.createTextNode('text content'); text"},
	{expression: "comment = document.createComment('comment content'); comment"},
	{expression: "svgElement = document.createElementNS('http://www.w3.org/2000/svg', 'rect'); svgElement.classList.add('test'); svgElement"},
	{expression: "[document.body, div, span, input, text, comment, svgElement]"},

	// Node Collections (NodeLists / Collections)
	{expression: "document.all", browserOnly: true}, // HTMLAllCollection
	{expression: "document.head.children"}, // HTMLCollection
	{expression: "document.getElementsByClassName('my-test')"}, // NodeList
	{expression: "document.querySelectorAll('.my-test')"}, // Non-Live NodeList

	// Error
	{expression: "error = null; try { [].x.x; } catch (e) { error = e; }; error"},
	{expression: "error = null; try { eval('if()'); } catch (e) { error = e; }; error"},
	{expression: "error = null; try { document.createTextNode('').splitText(100); } catch (e) { error = e; }; error"},

	// Map / WeakMap
	{expression: "new Map"},
	{expression: "map = new Map; map.set(1, 2); map.set('key', 'value'); map"},
	{expression: "map = new Map; map.set({a:1}, {b:2}); map.set(document.body, [1,2]); map"},
	{expression: "map = new Map; for (var i = 0; i <= 100; i++) map.set(i, i); map"},
	{expression: "map = new Map; map.set(map, map); map"},
	{expression: "map = new WeakMap; strongKey = {id:1}; map.set(strongKey, [1,2]); map"},

	// Set / WeakSet
	{expression: "new Set"},
	{expression: "set = new Set; set.add(1); set.add(2); set.add('key'); set"},
	{expression: "set = new Set; set.add({a:1}); set.add(document.body); set.add([1,2]); set"},
	{expression: "set = new Set; for (var i = 0; i <= 100; i++) set.add(i); set"},
	{expression: "set = new Set; set.add(set); set"},
	{expression: "set = new WeakSet; strongKey = {id:1}; set.add(strongKey); set"},

	// Iterators
	{expression: "'a'[Symbol.iterator]()"},
	{expression: "'long string'[Symbol.iterator]()"},
	{expression: "[][Symbol.iterator]()"},
	{expression: "[1][Symbol.iterator]()"},
	{expression: "[1, 'two', 3, 'four', 5, 'size'][Symbol.iterator]()"},
	{expression: "[1, 'two', 3, 'four', 5, 'size'].keys()"},
	{expression: "[1, 'two', 3, 'four', 5, 'size'].entries()"},
	{expression: "map = new Map; map.set(1, 2); map.set('key', 'value'); map.values()"},
	{expression: "map.keys()"},
	{expression: "map.entries()"},
	{expression: "set = new Set; for (var i = 0; i <= 100; i++) set.add(i); set.values()"},
	{expression: "map.entries()"},
	{expression: "x = undefined; (function() { x = arguments; })(1, 'two'); x[Symbol.iterator]()"},
	{expression: "Reflect.enumerate({a:1, b:2, c:3})"},
	{expression: "Reflect.enumerate([1, 2, 3, 4, 5, 6, 7])"},

	// Promise
	{expression: "new Promise(function(){})"},
	{expression: "Promise.reject()"},
	{expression: "Promise.reject('result')"},
	{expression: "Promise.resolve()"},
	{expression: "Promise.resolve({result:1})"},

	// Proxy
	{expression: "new Proxy({x:1, y:1}, {handler: true})"},

	// Classes

	{expression: "Person = class Person { constructor(name){} get fullName(){} methodName(p1, p2){} }; Person"}, // Constructor => class type
	{expression: "Person.prototype.methodName"}, // Method => just a function type
	{expression: "Alpha = class A { methodA(){} }; Beta = class B extends Alpha { methodB(){} }; Beta"},
	{expression: "[Beta]"},

	// Improveable:

	// Sealed / Frozen objects.
	{expression: "Object.seal({})"},
	{expression: "Object.freeze({})"},
	];

	if (!window.WebInspector) {
	window.steps = steps;
	return;
	}

	function remoteObjectJSONFilter(key, value)
	{
	if (key === "_objectId")
	return "<filtered>";

	if (key === "_hasChildren")
	return undefined;

	return value;
	}

	function runSteps() {

	function afterStep() {
	if (++currentStepIndex >= steps.length)
	InspectorTest.completeTest();
	}

	function runStep(step) {
	if (step.browserOnly) {
	afterStep();
	return;
	}

	WebInspector.runtimeManager.evaluateInInspectedWindow(step.expression, "test", false, true, false, true, false, function(remoteObject, wasThrown) {
	InspectorTest.log("");
	InspectorTest.log("-----------------------------------------------------");
	InspectorTest.log("EXPRESSION: " + step.expression);
	InspectorTest.assert(remoteObject instanceof WebInspector.RemoteObject);
	InspectorTest.log(JSON.stringify(remoteObject, remoteObjectJSONFilter, " "));
	afterStep();
	});
	}

	for (var step of steps)
	runStep(step);
	}

	runSteps();
	}

	function runInBrowserTest()
	{
	if (window.testRunner)
	return;

	test(); // get steps.

	for (var step of steps) {
	console.info("EXPRESSION", step.expression);
	try {
	console.log(eval(step.expression));
	} catch (e) {
	console.log("EXCEPTION: " + e);
	}
	}
	}
	</script>
	</head>
	<body onload="window.loadEvent = event; runTest(); runInBrowserTest();">
	<p class="my-test"></p><p class="my-test"></p><p class="my-test"></p>
	</body>
	</html>