| // Copyright 2013 the V8 project authors. All rights reserved. |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following |
| // disclaimer in the documentation and/or other materials provided |
| // with the distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived |
| // from this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| // Test for-of semantics. |
| |
| "use strict"; |
| |
| |
| // First, some helpers. |
| |
| function* values() { |
| for (var i = 0; i < arguments.length; i++) { |
| yield arguments[i]; |
| } |
| } |
| |
| function wrap_iterator(iterator) { |
| var iterable = {}; |
| iterable[Symbol.iterator] = function() { return iterator; }; |
| return iterable; |
| } |
| |
| function integers_until(max) { |
| function next() { |
| var ret = { value: this.n, done: this.n == max }; |
| this.n++; |
| return ret; |
| } |
| return wrap_iterator({ next: next, n: 0 }); |
| } |
| |
| function results(results) { |
| var i = 0; |
| function next() { |
| return results[i++]; |
| } |
| return wrap_iterator({ next: next }); |
| } |
| |
| function* integers_from(n) { |
| while (1) yield n++; |
| } |
| |
| // A destructive append. |
| function append(x, tail) { |
| tail[tail.length] = x; |
| return tail; |
| } |
| |
| function sum(x, tail) { |
| return x + tail; |
| } |
| |
| function fold(cons, seed, iterable) { |
| for (var x of iterable) { |
| seed = cons(x, seed); |
| } |
| return seed; |
| } |
| |
| function* take(iterable, n) { |
| if (n == 0) return; |
| for (let x of iterable) { |
| yield x; |
| if (--n == 0) break; |
| } |
| } |
| |
| function nth(iterable, n) { |
| for (let x of iterable) { |
| if (n-- == 0) return x; |
| } |
| throw "unreachable"; |
| } |
| |
| function* skip_every(iterable, n) { |
| var i = 0; |
| for (let x of iterable) { |
| if (++i % n == 0) continue; |
| yield x; |
| } |
| } |
| |
| function* iter_map(iterable, f) { |
| for (var x of iterable) { |
| yield f(x); |
| } |
| } |
| function nested_fold(cons, seed, iterable) { |
| var visited = [] |
| for (let x of iterable) { |
| for (let y of x) { |
| seed = cons(y, seed); |
| } |
| } |
| return seed; |
| } |
| |
| function* unreachable(iterable) { |
| for (let x of iterable) { |
| throw "not reached"; |
| } |
| } |
| |
| function one_time_getter(o, prop, val) { |
| function set_never() { throw "unreachable"; } |
| var gotten = false; |
| function get_once() { |
| if (gotten) throw "got twice"; |
| gotten = true; |
| return val; |
| } |
| Object.defineProperty(o, prop, {get: get_once, set: set_never}) |
| return o; |
| } |
| |
| function never_getter(o, prop) { |
| function never() { throw "unreachable"; } |
| Object.defineProperty(o, prop, {get: never, set: never}) |
| return o; |
| } |
| |
| function remove_next_after(iterable, n) { |
| var iterator = iterable[Symbol.iterator](); |
| function next() { |
| if (n-- == 0) delete this.next; |
| return iterator.next(); |
| } |
| return wrap_iterator({ next: next }); |
| } |
| |
| function poison_next_after(iterable, n) { |
| var iterator = iterable[Symbol.iterator](); |
| function next() { |
| return iterator.next(); |
| } |
| function next_getter() { |
| if (n-- < 0) |
| throw "poisoned"; |
| return next; |
| } |
| var o = {}; |
| Object.defineProperty(o, 'next', { get: next_getter }); |
| return wrap_iterator(o); |
| } |
| |
| // Now, the tests. |
| |
| // Non-generator iterators. |
| assertEquals(45, fold(sum, 0, integers_until(10))); |
| // Generator iterators. |
| assertEquals([1, 2, 3], fold(append, [], values(1, 2, 3))); |
| // Break. |
| assertEquals(45, fold(sum, 0, take(integers_from(0), 10))); |
| // Continue. |
| assertEquals(90, fold(sum, 0, take(skip_every(integers_from(0), 2), 10))); |
| // Return. |
| assertEquals(10, nth(integers_from(0), 10)); |
| // Nested for-of. |
| assertEquals([0, 0, 1, 0, 1, 2, 0, 1, 2, 3], |
| nested_fold(append, |
| [], |
| iter_map(integers_until(5), integers_until))); |
| // Result objects with sparse fields. |
| assertEquals([undefined, 1, 2, 3], |
| fold(append, [], |
| results([{ done: false }, |
| { value: 1, done: false }, |
| // A missing "done" is the same as undefined, which |
| // is false. |
| { value: 2 }, |
| // Not done. |
| { value: 3, done: 0 }, |
| // Done. |
| { value: 4, done: 42 }]))); |
| // Results that are not objects. |
| assertThrows(function() { |
| assertEquals([undefined, undefined, undefined], |
| fold(append, [], |
| results([10, "foo", /qux/, { value: 37, done: true }]))); |
| }, TypeError); |
| // Getters (shudder). |
| assertEquals([1, 2], |
| fold(append, [], |
| results([one_time_getter({ value: 1 }, 'done', false), |
| one_time_getter({ done: false }, 'value', 2), |
| { value: 37, done: true }, |
| never_getter(never_getter({}, 'done'), 'value')]))); |
| |
| // Unlike the case with for-in, null and undefined cause an error. |
| assertThrows('fold(sum, 0, unreachable(null))', TypeError); |
| assertThrows('fold(sum, 0, unreachable(undefined))', TypeError); |
| |
| // Other non-iterators do cause an error. |
| assertThrows('fold(sum, 0, unreachable({}))', TypeError); |
| assertThrows('fold(sum, 0, unreachable(false))', TypeError); |
| assertThrows('fold(sum, 0, unreachable(37))', TypeError); |
| |
| // "next" is looked up each time. |
| assertThrows('fold(sum, 0, remove_next_after(integers_until(10), 5))', |
| TypeError); |
| // It is not called at any other time. |
| assertEquals(45, |
| fold(sum, 0, remove_next_after(integers_until(10), 10))); |
| // It is not looked up too many times. |
| assertEquals(45, |
| fold(sum, 0, poison_next_after(integers_until(10), 10))); |
| |
| function labelled_continue(iterable) { |
| var n = 0; |
| outer: |
| while (true) { |
| n++; |
| for (var x of iterable) continue outer; |
| break; |
| } |
| return n; |
| } |
| assertEquals(11, labelled_continue(integers_until(10))); |
| |
| function labelled_break(iterable) { |
| var n = 0; |
| outer: |
| while (true) { |
| n++; |
| for (var x of iterable) break outer; |
| } |
| return n; |
| } |
| assertEquals(1, labelled_break(integers_until(10))); |
| |
| // Test continue/break in catch. |
| function catch_control(iterable, k) { |
| var n = 0; |
| for (var x of iterable) { |
| try { |
| return k(x); |
| } catch (e) { |
| if (e == "continue") continue; |
| else if (e == "break") break; |
| else throw e; |
| } |
| } while (false); |
| return false; |
| } |
| assertEquals(false, |
| catch_control(integers_until(10), |
| function() { throw "break" })); |
| assertEquals(false, |
| catch_control(integers_until(10), |
| function() { throw "continue" })); |
| assertEquals(5, |
| catch_control(integers_until(10), |
| function(x) { |
| if (x == 5) return x; |
| throw "continue"; |
| })); |
| |
| // Test continue/break in try. |
| function try_control(iterable, k) { |
| var n = 0; |
| for (var x of iterable) { |
| try { |
| var e = k(x); |
| if (e == "continue") continue; |
| else if (e == "break") break; |
| return e; |
| } catch (e) { |
| throw e; |
| } |
| } while (false); |
| return false; |
| } |
| assertEquals(false, |
| try_control(integers_until(10), |
| function() { return "break" })); |
| assertEquals(false, |
| try_control(integers_until(10), |
| function() { return "continue" })); |
| assertEquals(5, |
| try_control(integers_until(10), |
| function(x) { return (x == 5) ? x : "continue" })); |
| |
| // TODO(neis,cbruni): Enable once the corresponding traps work again. |
| // Proxy results, with getters. |
| // function transparent_proxy(x) { |
| // return new Proxy({}, { |
| // get: function(receiver, name) { return x[name]; } |
| // }); |
| // } |
| // assertEquals([1, 2], |
| // fold(append, [], |
| // results([one_time_getter({ value: 1 }, 'done', false), |
| // one_time_getter({ done: false }, 'value', 2), |
| // { value: 37, done: true }, |
| // never_getter(never_getter({}, 'done'), 'value')] |
| // .map(transparent_proxy)))); |
| |
| // Proxy iterators. |
| // function poison_proxy_after(iterable, n) { |
| // var iterator = iterable[Symbol.iterator](); |
| // return wrap_iterator(new Proxy({}, { |
| // get: function(receiver, name) { |
| // if (name == 'next' && n-- < 0) throw "unreachable"; |
| // return iterator[name]; |
| // }, |
| // // Needed for integers_until(10)'s this.n++. |
| // set: function(receiver, name, val) { |
| // return iterator[name] = val; |
| // } |
| // })); |
| // } |
| // assertEquals(45, fold(sum, 0, poison_proxy_after(integers_until(10), 10))); |
| |
| |
| function test_iterator_result_object_non_object(value, descr) { |
| var arr = []; |
| var ex; |
| var message = 'Iterator result ' + (descr || value) + ' is not an object'; |
| try { |
| fold(append, arr, |
| results([{value: 1}, {}, value, {value: 2}, {done: true}])); |
| } catch (e) { |
| ex = e; |
| } |
| assertInstanceof(ex, TypeError); |
| assertEquals(message, ex.message); |
| assertArrayEquals([1, undefined], arr); |
| } |
| test_iterator_result_object_non_object(null); |
| test_iterator_result_object_non_object(undefined); |
| test_iterator_result_object_non_object(42); |
| test_iterator_result_object_non_object('abc'); |
| test_iterator_result_object_non_object(false); |
| test_iterator_result_object_non_object(Symbol('x'), 'Symbol(x)'); |
