Home | History | Annotate | Download | only in mjsunit 
      1 // Copyright 2008 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 
     28 assertEquals(void 0, eval());
     29 assertEquals(4, eval(4));
     30 
     31 function f() { return 'The f function'; };
     32 assertTrue(f === eval(f));
     33 
     34 function g(x, y) { return 4; };
     35 
     36 count = 0;
     37 assertEquals(4, eval('2 + 2', count++));
     38 assertEquals(1, count);
     39 
     40 try {
     41   eval('hest 7 &*^*&^');
     42   assertTrue(false, '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.
     49 global_eval = eval;
     50 assertEquals(void 0, eval(eval("var eval = function f(x) { return 'hest';}")))
     51 eval = global_eval;
     52 
     53 // Test eval with different number of parameters.
     54 global_eval = eval;
     55 eval = function(x, y) { return x + y; };
     56 assertEquals(4, eval(2, 2));
     57 eval = global_eval;
     58 
     59 // Test that un-aliased eval reads from local context.
     60 foo = 0;
     61 result =
     62   (function() {
     63     var foo = 2;
     64     return eval('foo');
     65   })();
     66 assertEquals(2, result);
     67 
     68 // Test that un-aliased eval writes to local context.
     69 foo = 0;
     70 result =
     71   (function() {
     72     var foo = 1;
     73     eval('foo = 2');
     74     return foo;
     75   })();
     76 assertEquals(2, result);
     77 assertEquals(0, foo);
     78 
     79 // Test that un-aliased eval has right receiver.
     80 function MyObject() { this.self = eval('this'); }
     81 var o = new MyObject();
     82 assertTrue(o === o.self);
     83 
     84 // Test that aliased eval reads from global context.
     85 var e = eval;
     86 foo = 0;
     87 result =
     88   (function() {
     89     var foo = 2;
     90     return e('foo');
     91   })();
     92 assertEquals(0, result);
     93 
     94 // Test that aliased eval writes to global context.
     95 var e = eval;
     96 foo = 0;
     97 (function() { e('var foo = 2;'); })();
     98 assertEquals(2, foo);
     99 
    100 // Test that aliased eval has right receiver.
    101 function MyOtherObject() { this.self = e('this'); }
    102 var o = new MyOtherObject();
    103 assertTrue(this === o.self);
    104 
    105 // Try to cheat the 'aliased eval' detection.
    106 var x = this;
    107 foo = 0;
    108 result =
    109   (function() {
    110     var foo = 2;
    111     return x.eval('foo');
    112   })();
    113 assertEquals(0, result);
    114 
    115 foo = 0;
    116 result =
    117   (function() {
    118     var eval = function(x) { return x; };
    119     var foo = eval(2);
    120     return e('foo');
    121   })();
    122 assertEquals(0, result);
    123 
    124 result =
    125   (function() {
    126     var eval = function(x) { return 2 * x; };
    127     return (function() { return eval(2); })();
    128   })();
    129 assertEquals(4, result);
    130 
    131 result =
    132   (function() {
    133     eval("var eval = function(s) { return this; }");
    134     return eval("42");  // Should return the global object
    135   })();
    136 assertEquals(this, result);
    137 
    138 result =
    139   (function() {
    140     var obj = { f: function(eval) { return eval("this"); } };
    141     return obj.f(eval);
    142   })();
    143 assertEquals(this, result);
    144 
    145 result =
    146   (function() {
    147     var obj = { f: function(eval) { arguments; return eval("this"); } };
    148     return obj.f(eval);
    149   })();
    150 assertEquals(this, result);
    151 
    152 eval = function(x) { return 2 * x; };
    153 result =
    154   (function() {
    155     return (function() { return eval(2); })();
    156   })();
    157 assertEquals(4, result);
    158