1// Copyright 2011 the V8 project authors. All rights reserved. 2// Redistribution and use in source and binary forms, with or without 3// modification, are permitted provided that the following conditions are 4// met: 5// 6// * Redistributions of source code must retain the above copyright 7// notice, this list of conditions and the following disclaimer. 8// * Redistributions in binary form must reproduce the above 9// copyright notice, this list of conditions and the following 10// disclaimer in the documentation and/or other materials provided 11// with the distribution. 12// * Neither the name of Google Inc. nor the names of its 13// contributors may be used to endorse or promote products derived 14// from this software without specific prior written permission. 15// 16// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS 17// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT 18// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR 19// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT 20// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, 21// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT 22// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 23// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 24// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 25// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE 26// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 27 28assertEquals(void 0, eval()); 29assertEquals(4, eval(4)); 30 31function f() { return 'The f function'; }; 32assertTrue(f === eval(f)); 33 34function g(x, y) { return 4; }; 35 36count = 0; 37assertEquals(4, eval('2 + 2', count++)); 38assertEquals(1, count); 39 40try { 41 eval('hest 7 &*^*&^'); 42 assertUnreachable('Did not throw on syntax error.'); 43} catch (e) { 44 assertEquals('SyntaxError', e.name); 45} 46 47 48// eval has special evaluation order for consistency with other browsers. 49global_eval = eval; 50assertEquals(void 0, eval(eval("var eval = function f(x) { return 'hest';}"))) 51eval = global_eval; 52 53// Test eval with different number of parameters. 54global_eval = eval; 55eval = function(x, y) { return x + y; }; 56assertEquals(4, eval(2, 2)); 57eval = global_eval; 58 59// Test that un-aliased eval reads from local context. 60foo = 0; 61result = 62 (function() { 63 var foo = 2; 64 return eval('foo'); 65 })(); 66assertEquals(2, result); 67 68// Test that un-aliased eval writes to local context. 69foo = 0; 70result = 71 (function() { 72 var foo = 1; 73 eval('foo = 2'); 74 return foo; 75 })(); 76assertEquals(2, result); 77assertEquals(0, foo); 78 79// Test that un-aliased eval has right receiver. 80function MyObject() { this.self = eval('this'); } 81var o = new MyObject(); 82assertTrue(o === o.self); 83 84// Test that aliased eval reads from global context. 85var e = eval; 86foo = 0; 87result = 88 (function() { 89 var foo = 2; 90 return e('foo'); 91 })(); 92assertEquals(0, result); 93 94// Test that aliased eval writes to global context. 95var e = eval; 96foo = 0; 97(function() { e('var foo = 2;'); })(); 98assertEquals(2, foo); 99 100// Test that aliased eval has right receiver. 101function MyOtherObject() { this.self = e('this'); } 102var o = new MyOtherObject(); 103assertTrue(this === o.self); 104 105// Try to cheat the 'aliased eval' detection. 106var x = this; 107foo = 0; 108result = 109 (function() { 110 var foo = 2; 111 // Should be non-direct call. 112 return x.eval('foo'); 113 })(); 114assertEquals(0, result); 115 116foo = 0; 117result = 118 (function() { 119 var foo = 2; 120 // Should be non-direct call. 121 return (1,eval)('foo'); 122 })(); 123assertEquals(0, result); 124 125foo = 0; 126result = 127 (function() { 128 var eval = function(x) { return x; }; 129 var foo = eval(2); 130 // Should be non-direct call. 131 return e('foo'); 132 })(); 133assertEquals(0, result); 134 135foo = 0; 136result = 137 (function() { 138 var foo = 2; 139 // Should be direct call. 140 with ({ eval : e }) { 141 return eval('foo'); 142 } 143 })(); 144assertEquals(2, result); 145 146result = 147 (function() { 148 var eval = function(x) { return 2 * x; }; 149 return (function() { return eval(2); })(); 150 })(); 151assertEquals(4, result); 152 153result = 154 (function() { 155 eval("var eval = function(s) { return this; }"); 156 return eval("42"); // Should return the global object 157 })(); 158assertEquals(this, result); 159 160(function() { 161 var obj = { f: function(eval) { return eval("this"); } }; 162 result = obj.f(eval); 163 assertEquals(obj, result); 164})(); 165 166(function() { 167 var obj = { f: function(eval) { arguments; return eval("this"); } }; 168 result = obj.f(eval); 169 assertEquals(obj, result); 170})(); 171 172eval = function(x) { return 2 * x; }; 173result = 174 (function() { 175 return (function() { return eval(2); })(); 176 })(); 177assertEquals(4, result); 178 179 180 181 182// Regression test: calling a function named eval found in a context that is 183// not the global context should get the global object as receiver. 184result = 185 (function () { 186 var eval = function (x) { return this; }; 187 with ({}) { return eval('ignore'); } 188 })(); 189assertEquals(this, result); 190