src/v8/test/mjsunit/with-leave.js

   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
  28 L: with ({x:12}) {
  29   assertEquals(12, x);
  30   break L;
  31   assertTrue(false);
  32 }
  33
  34 do {
  35   with ({x:15}) {
  36     assertEquals(15, x);
  37     continue;
  38     assertTrue(false);
  39   }
  40 } while (false);
  41
  42 var caught = false;
  43 try {
  44   with ({x:18}) { throw 25; assertTrue(false); }
  45 } catch (e) {
  46   caught = true;
  47   assertEquals(25, e);
  48   with ({y:19}) {
  49     assertEquals(19, y);
  50     try {
  51       // NOTE: This checks that the object containing x has been
  52       // removed from the context chain.
  53       x;
  54       assertTrue(false);  // should not reach here
  55     } catch (e2) {
  56       assertTrue(e2 instanceof ReferenceError);
  57     }
  58   }
  59 }
  60 assertTrue(caught);
  61
  62
  63 // We want to test the context chain shape.  In each of the tests cases
  64 // below, the outer with is to force a runtime lookup of the identifier 'x'
  65 // to actually verify that the inner context has been discarded.  A static
  66 // lookup of 'x' might accidentally succeed.
  67 with ({x: 'outer'}) {
  68   label: {
  69     with ({x: 'inner'}) {
  70       break label;
  71     }
  72   }
  73   assertEquals('outer', x);
  74 }
  75
  76
  77 with ({x: 'outer'}) {
  78   label: {
  79     with ({x: 'middle'}) {
  80       with ({x: 'inner'}) {
  81         break label;
  82       }
  83     }
  84   }
  85   assertEquals('outer', x);
  86 }
  87
  88
  89 with ({x: 'outer'}) {
  90   for (var i = 0; i < 10; ++i) {
  91     with ({x: 'inner' + i}) {
  92       continue;
  93     }
  94   }
  95   assertEquals('outer', x);
  96 }
  97
  98
  99 with ({x: 'outer'}) {
 100   label: for (var i = 0; i < 10; ++i) {
 101     with ({x: 'middle' + i}) {
 102       for (var j = 0; j < 10; ++j) {
 103         with ({x: 'inner' + j}) {
 104           continue label;
 105         }
 106       }
 107     }
 108   }
 109   assertEquals('outer', x);
 110 }
 111
 112
 113 with ({x: 'outer'}) {
 114   try {
 115     with ({x: 'inner'}) {
 116       throw 0;
 117     }
 118   } catch (e) {
 119     assertEquals('outer', x);
 120   }
 121 }
 122
 123
 124 with ({x: 'outer'}) {
 125   try {
 126     with ({x: 'middle'}) {
 127       with ({x: 'inner'}) {
 128         throw 0;
 129       }
 130     }
 131   } catch (e) {
 132     assertEquals('outer', x);
 133   }
 134 }
 135
 136
 137 try {
 138   with ({x: 'outer'}) {
 139     try {
 140       with ({x: 'inner'}) {
 141         throw 0;
 142       }
 143     } finally {
 144       assertEquals('outer', x);
 145     }
 146   }
 147 } catch (e) {
 148   if (e instanceof MjsUnitAssertionError) throw e;
 149 }
 150
 151
 152 try {
 153   with ({x: 'outer'}) {
 154     try {
 155       with ({x: 'middle'}) {
 156         with ({x: 'inner'}) {
 157           throw 0;
 158         }
 159       }
 160     } finally {
 161       assertEquals('outer', x);
 162     }
 163   }
 164 } catch (e) {
 165   if (e instanceof MjsUnitAssertionError) throw e;
 166 }
 167
 168
 169 // Verify that the context is correctly set in the stack frame after exiting
 170 // from with.
 171 function f() {}
 172
 173 with ({x: 'outer'}) {
 174   label: {
 175     with ({x: 'inner'}) {
 176       break label;
 177     }
 178   }
 179   f();  // The context could be restored from the stack after the call.
 180   assertEquals('outer', x);
 181 }
 182
 183
 184 with ({x: 'outer'}) {
 185   for (var i = 0; i < 10; ++i) {
 186     with ({x: 'inner' + i}) {
 187       continue;
 188     }
 189   }
 190   f();
 191   assertEquals('outer', x);
 192 }
 193
 194
 195 with ({x: 'outer'}) {
 196   try {
 197     with ({x: 'inner'}) {
 198       throw 0;
 199     }
 200   } catch (e) {
 201     f();
 202     assertEquals('outer', x);
 203   }
 204 }
 205
 206
 207 try {
 208   with ({x: 'outer'}) {
 209     try {
 210       with ({x: 'inner'}) {
 211         throw 0;
 212       }
 213     } finally {
 214       f();
 215       assertEquals('outer', x);
 216     }
 217   }
 218 } catch (e) {
 219   if (e instanceof MjsUnitAssertionError) throw e;
 220 }