// 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.

// Flags: --harmony-proxies

// 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)');