third_party/WebKit/LayoutTests/inspector/console/console-tainted-globals.html

   1 <html>
   2 <head>
   3 <script src="../../http/tests/inspector/inspector-test.js"></script>
   4 <script src="../../http/tests/inspector/console-test.js"></script>
   5 <script>
   6
   7 var originalError = window.Error;
   8
   9 (function() {
  10     var originalFunctionCall = Function.prototype.call;
  11     var originalFunctionApply = Function.prototype.apply;
  12
  13     var overriddenFunctionCall = function() {
  14         original();
  15         console.error("FAIL: Function.prototype.call should not be called!");
  16         var result = originalFunctionCall.apply(this, arguments);
  17         overridden();
  18         return result;
  19     }
  20
  21     var overriddenFunctionApply = function(thisArg, argsArray) {
  22         original();
  23         console.error("FAIL: Function.prototype.apply should not be called!");
  24         var result = originalFunctionApply.call(this, thisArg, argsArray);
  25         overridden();
  26         return result;
  27     }
  28
  29     function original()
  30     {
  31         Function.prototype.call = originalFunctionCall;
  32         Function.prototype.apply = originalFunctionApply;
  33     }
  34
  35     function overridden()
  36     {
  37         Function.prototype.call = overriddenFunctionCall;
  38         Function.prototype.apply = overriddenFunctionApply;
  39     }
  40
  41     overridden();
  42 })();
  43
  44 function throwGetter()
  45 {
  46    console.error("FAIL: Should not be called!");
  47    throw new Error("FAIL");
  48 }
  49
  50 function testOverriddenArrayPushAndMathMax()
  51 {
  52     Object.defineProperty(Array.prototype, "push", {
  53         get: throwGetter
  54     });
  55     Object.defineProperty(Math, "max", {
  56         get: throwGetter
  57     });
  58     return [1, 2, 3];
  59 }
  60
  61 function testOverriddenConstructorName()
  62 {
  63     var obj = {};
  64     obj.constructor = { name: "foo" };
  65     return obj;
  66 }
  67
  68 function testThrowConstructorName()
  69 {
  70     var obj = {};
  71     Object.defineProperty(obj, "constructor", {
  72         get: throwGetter
  73     });
  74     return obj;
  75 }
  76
  77 function testOverriddenIsFinite()
  78 {
  79     window.isFinite = throwGetter;
  80     var out;
  81     (function() {
  82         out = arguments;
  83     })("arg1", "arg2");
  84     return out;
  85 }
  86
  87 function testOverriddenError()
  88 {
  89     window.Error = 42;
  90     return { result: "PASS" };
  91 }
  92
  93 function restoreError()
  94 {
  95     window.Error = originalError;
  96     return { result: "PASS" };
  97 }
  98
  99 function testOverriddenToString(obj, overrideThrow)
 100 {
 101     if (overrideThrow)
 102         var func = function() { throw new Error; }
 103     else
 104         var func = function() { return [1]; }
 105
 106     Object.defineProperty(obj, "toString", { value: func, enumerable: false });
 107     Object.defineProperty(obj, "valueOf", { value: func, enumerable: false });
 108
 109     // Now the ("" + obj) expression should throw.
 110     try {
 111         var dummy = "" + obj;
 112         console.error("FAIL: Expected to throw but got: " + dummy);
 113     } catch (e) {
 114     }
 115
 116     return obj;
 117 }
 118
 119 function test()
 120 {
 121     InspectorTest.runTestSuite([
 122         function evaluateInConsole(next)
 123         {
 124             var expressions = [
 125                 "testOverriddenArrayPushAndMathMax()",
 126                 "testOverriddenConstructorName()",
 127                 "testThrowConstructorName()",
 128                 "testOverriddenIsFinite()",
 129                 "testOverriddenError()",
 130                 "restoreError()",
 131                 "testOverriddenToString(function func() {}, true)",
 132                 "testOverriddenToString(function func() {}, false)",
 133                 "testOverriddenToString(new Function, true)",
 134                 "testOverriddenToString(new Function, false)",
 135                 "testOverriddenToString(/^regex$/, true)",
 136                 "testOverriddenToString(/^regex$/, false)",
 137                 "testOverriddenToString(new Date, true)",
 138                 "testOverriddenToString(new Date, false)",
 139                 "testOverriddenToString({}, true)",
 140                 "testOverriddenToString({}, false)",
 141                 "testOverriddenToString(new Number(1), true)",
 142                 "testOverriddenToString(new Number(1), false)",
 143             ];
 144
 145             function iterate()
 146             {
 147                 var expr = expressions.shift();
 148                 if (!expr) {
 149                     InspectorTest.runAfterPendingDispatches(next);
 150                     return;
 151                 }
 152                 InspectorTest.evaluateInConsole(expr, iterate);
 153             }
 154             iterate();
 155         },
 156
 157         function testRuntimeAgentCallFunctionOn(next)
 158         {
 159             InspectorTest.RuntimeAgent.evaluate("({ a : 1, b : 2 })", step1);
 160
 161             function step1(error, result, wasThrown)
 162             {
 163                 function sum()
 164                 {
 165                     return this.a + this.b;
 166                 }
 167                 InspectorTest.RuntimeAgent.callFunctionOn(result.objectId, sum.toString(), step2);
 168             }
 169
 170             function step2(error, result, wasThrown)
 171             {
 172                 InspectorTest.assertEquals(3, result.value);
 173                 next();
 174             }
 175         },
 176
 177         function dumpConsoleMessages(next)
 178         {
 179             InspectorTest.dumpConsoleMessages();
 180             next();
 181         }
 182     ]);
 183 }
 184 </script>
 185 </head>
 186
 187 <body onload="runTest()">
 188 <p>
 189 Tests that overriding global methods (like Array.prototype.push, Math.max) will not break the inspector.
 190 </p>
 191
 192 </body>
 193 </html>