tests/stress/custom-iterators.js

   1 // This test checks the behavior of custom iterable objects.
   2
   3 var returnCalled = false;
   4 var iter = {
   5     __key: 0,
   6     next: function () {
   7         return {
   8             done: this.__key === 42,
   9             value: this.__key++
  10         };
  11     },
  12     [Symbol.iterator]: function () {
  13         return this;
  14     },
  15     return: function () {
  16         returnCalled = true;
  17     }
  18 };
  19 var expected = 0;
  20 for (var value of iter) {
  21     if (value !== expected++)
  22         throw "Error: bad value: " + value;
  23 }
  24 if (returnCalled)
  25     throw "Error: return is called.";
  26
  27
  28
  29 var returnCalled = false;
  30 var iter = {
  31     __key: 0,
  32     next: function () {
  33         return {
  34             done: this.__key === 42,
  35             value: this.__key++
  36         };
  37     },
  38     [Symbol.iterator]: function () {
  39         return this;
  40     },
  41     return: function () {
  42         returnCalled = true;
  43         return {
  44             done: true,
  45             value: undefined
  46         };
  47     }
  48 };
  49
  50 try {
  51     for (var value of iter) {
  52         throw "Error: Terminate iteration.";
  53     }
  54 } catch (e) {
  55     if (String(e) !== "Error: Terminate iteration.")
  56         throw "Error: bad error thrown: " + e;
  57 }
  58 if (!returnCalled)
  59     throw "Error: return is not called.";
  60
  61
  62
  63 var returnCalled = false;
  64 var iter = {
  65     __key: 0,
  66     next: function () {
  67         return {
  68             done: this.__key === 42,
  69             value: this.__key++
  70         };
  71     },
  72     [Symbol.iterator]: function () {
  73         return this;
  74     },
  75     return: function () {
  76         returnCalled = true;
  77         return {
  78             done: true,
  79             value: undefined
  80         };
  81     }
  82 };
  83
  84 for (var value of iter) {
  85     break;
  86 }
  87 if (!returnCalled)
  88     throw "Error: return is not called.";
  89
  90
  91
  92 var returnCalled = false;
  93 var iter = {
  94     __key: 0,
  95     get next() {
  96         throw "Error: looking up next.";
  97     },
  98     [Symbol.iterator]: function () {
  99         return this;
 100     },
 101     return: function () {
 102         returnCalled = true;
 103     }
 104 };
 105 try {
 106     for (var value of iter) {
 107         throw "Error: Iteration should not occur.";
 108     }
 109 } catch (e) {
 110     if (String(e) !== "Error: looking up next.")
 111         throw "Error: bad error thrown: " + e;
 112 }
 113 if (returnCalled)
 114     throw "Error: return is called.";
 115
 116
 117
 118 var iter = {
 119     __key: 0,
 120     next: function () {
 121         return {
 122             done: this.__key === 42,
 123             value: this.__key++
 124         };
 125     },
 126     [Symbol.iterator]: function () {
 127         return this;
 128     },
 129     get return() {
 130         throw "Error: looking up return."
 131     }
 132 };
 133 try {
 134     for (var value of iter) {
 135         throw "Error: Terminate iteration.";
 136     }
 137 } catch (e) {
 138     if (String(e) !== "Error: looking up return.")
 139         throw "Error: bad error thrown: " + e;
 140 }
 141
 142
 143
 144 var returnCalled = false;
 145 var iter = {
 146     __key: 0,
 147     next: function () {
 148         throw "Error: next is called."
 149     },
 150     [Symbol.iterator]: function () {
 151         return this;
 152     },
 153     return: function () {
 154         returnCalled = true;
 155         return {
 156             done: true,
 157             value: undefined
 158         };
 159     }
 160 };
 161
 162 try {
 163     for (var value of iter) {
 164         throw "Error: Terminate iteration.";
 165     }
 166 } catch (e) {
 167     if (String(e) !== "Error: next is called.")
 168         throw "Error: bad error thrown: " + e;
 169 }
 170 if (returnCalled)
 171     throw "Error: return is called.";
 172
 173
 174
 175 var returnCalled = false;
 176 var iter = {
 177     __key: 0,
 178     next: function () {
 179         return { done: false, value: 42 };
 180     },
 181     [Symbol.iterator]: function () {
 182         return this;
 183     },
 184     return: function () {
 185         returnCalled = true;
 186         throw "Error: return is called.";
 187     }
 188 };
 189
 190 try {
 191     for (var value of iter) {
 192         throw "Error: Terminate iteration.";
 193     }
 194 } catch (e) {
 195     if (String(e) !== "Error: Terminate iteration.")
 196         throw "Error: bad error thrown: " + e;
 197 }
 198 if (!returnCalled)
 199     throw "Error: return is not called.";
 200
 201
 202 var returnCalled = false;
 203 var iter = {
 204     __key: 0,
 205     next: function () {
 206         return { done: false, value: 42 };
 207     },
 208     [Symbol.iterator]: function () {
 209         return this;
 210     },
 211     return: function () {
 212         returnCalled = true;
 213         throw "Error: return is called.";
 214     }
 215 };
 216 try {
 217     for (var value of iter) {
 218         break;
 219     }
 220 } catch (e) {
 221     if (String(e) !== "Error: return is called.")
 222         throw "Error: bad error thrown: " + e;
 223 }
 224 if (!returnCalled)
 225     throw "Error: return is not called.";
 226
 227
 228 var primitives = [
 229     undefined,
 230     null,
 231     42,
 232     "string",
 233     true,
 234     Symbol("Cocoa")
 235 ];
 236
 237 function iteratorInterfaceErrorTest(notIteratorResult) {
 238     var returnCalled = false;
 239     var iter = {
 240         __key: 0,
 241         next: function () {
 242             return notIteratorResult;
 243         },
 244         [Symbol.iterator]: function () {
 245             return this;
 246         },
 247         return: function () {
 248             returnCalled = true;
 249             return undefined;
 250         }
 251     };
 252     try {
 253         for (var value of iter) {
 254             throw "Error: Iteration should not occur.";
 255         }
 256     } catch (e) {
 257         if (String(e) !== "TypeError: Iterator result interface is not an object.")
 258             throw "Error: bad error thrown: " + e;
 259     }
 260     if (returnCalled)
 261         throw "Error: return is called.";
 262 }
 263
 264 function iteratorInterfaceErrorTestReturn(notIteratorResult) {
 265     var returnCalled = false;
 266     var iter = {
 267         __key: 0,
 268         next: function () {
 269             return { done: false, value: 42 };
 270         },
 271         [Symbol.iterator]: function () {
 272             return this;
 273         },
 274         return: function () {
 275             returnCalled = true;
 276             return notIteratorResult;
 277         }
 278     };
 279     try {
 280         for (var value of iter) {
 281             throw "Error: Terminate iteration.";
 282         }
 283     } catch (e) {
 284         if (String(e) !== "Error: Terminate iteration.")
 285             throw "Error: bad error thrown: " + e;
 286     }
 287     if (!returnCalled)
 288         throw "Error: return is not called.";
 289 }
 290
 291 primitives.forEach(iteratorInterfaceErrorTest);
 292 primitives.forEach(iteratorInterfaceErrorTestReturn);
 293
 294
 295 function iteratorInterfaceBreakTestReturn(notIteratorResult) {
 296     var returnCalled = false;
 297     var iter = {
 298         __key: 0,
 299         next: function () {
 300             return { done: false, value: 42 };
 301         },
 302         [Symbol.iterator]: function () {
 303             return this;
 304         },
 305         return: function () {
 306             returnCalled = true;
 307             return notIteratorResult;
 308         }
 309     };
 310     try {
 311         for (var value of iter) {
 312             break;
 313         }
 314     } catch (e) {
 315         if (String(e) !== "TypeError: Iterator result interface is not an object.")
 316             throw "Error: bad error thrown: " + e;
 317     }
 318     if (!returnCalled)
 319         throw "Error: return is not called.";
 320 }
 321
 322 primitives.forEach(iteratorInterfaceBreakTestReturn);