// Copyright (c) 2011, the Dart project authors.  Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
// Dart test program testing closures.

import "package:expect/expect.dart";

class LocalFunctionTest {
  LocalFunctionTest()
      : field1 = 100,
        field2_ = 200 {}
  static int f(int n) {
    int a = 0;
    g(int m) {
      a = 3 * n + m + 1; // Capture parameter n and local a.
      return a;
    }

    var b = g(n);
    return a + b;
  }

  static int h(int n) {
    k(int n) {
      var a = new List(n);
      var b = new List(n);
      int i;
      for (i = 0; i < n; i++) {
        var j = i;
        a[i] = () => i; // Captured i is always n.
        b[i] = () => j; // Captured j varies from 0 to n-1.
      }
      var a_sum = 0;
      var b_sum = 0;
      for (int i = 0; i < n; i++) {
        a_sum += a[i]();
        b_sum += b[i]();
      }
      return a_sum + b_sum;
    }

    return k(n);
  }

  static int h2(int n) {
    k(int n) {
      var a = new List(n);
      var b = new List(n);
      for (int i = 0; i < n; i++) {
        var j = i;
        a[i] = () => i; // Captured i varies from 0 to n-1.
        b[i] = () => j; // Captured j varies from 0 to n-1.
      }
      var a_sum = 0;
      var b_sum = 0;
      for (int i = 0; i < n; i++) {
        a_sum += a[i]();
        b_sum += b[i]();
      }
      return a_sum + b_sum;
    }

    return k(n);
  }

  int field1;
  int field2_;
  int get field2 {
    return field2_;
  }

  void set field2(int value) {
    field2_ = value;
  }

  int method(int n) {
    incField1() {
      field1++;
    }

    incField2() {
      field2++;
    }

    for (int i = 0; i < n; i++) {
      incField1();
      incField2();
    }
    return field1 + field2;
  }

  int execute(int times, apply(int x)) {
    for (int i = 0; i < times; i++) {
      apply(i);
    }
    return field1;
  }

  int testExecute(int n) {
    execute(n, (int x) {
      field1 += x;
    });
    return field1;
  }

  static int foo(int n) {
    return -100; // Wrong foo.
  }

  static testSelfReference1(int n) {
    int foo(int n) {
      if (n == 0) {
        return 0;
      } else {
        return 1 + foo(n - 1); // Local foo, not static foo.
      }
    }

    ;
    return foo(n); // Local foo, not static foo.
  }

  static void hep(Function f) {
    f();
  }

  static testNesting(int n) {
    var a = new List(n * n);
    f0() {
      for (int i = 0; i < n; i++) {
        int vi = i;
        f1() {
          for (int j = 0; j < n; j++) {
            int vj = j;
            a[i * n + j] = () => vi * n + vj;
          }
        }

        f1();
      }
    }

    f0();
    int result = 0;
    for (int k = 0; k < n * n; k++) {
      Expect.equals(k, a[k]());
      result += a[k]();
    }
    return result;
  }

  static var field5;
  static var set_field5_func;
  static testClosureCallStatement(int x) {
    LocalFunctionTest.set_field5_func = (int n) {
      field5 = n * n;
    };
    (LocalFunctionTest.set_field5_func)(x);
    Expect.equals(x * x, LocalFunctionTest.field5);
    return true;
  }

  static testExceptions() {
    dynamic f = (int n) => n + 1;
    Expect.equals(2, f(1));
    Expect.equals(true, f is Function);
    Expect.equals(true, f is Object);
    Expect.equals(true, f.toString().startsWith("Closure"));
    bool exception_caught = false;
    try {
      f(1, 2);
    } on NoSuchMethodError catch (e) {
      exception_caught = true;
    }
    Expect.equals(true, exception_caught);
    exception_caught = false;
    try {
      f();
    } on NoSuchMethodError catch (e) {
      exception_caught = true;
    }
    Expect.equals(true, exception_caught);
    exception_caught = false;
    try {
      f.xyz(0);
    } on NoSuchMethodError catch (e) {
      exception_caught = true;
    }
    Expect.equals(true, exception_caught);

    // Overwrite closure value.
    f = 3;
    exception_caught = false;
    try {
      f(1);
    } on NoSuchMethodError catch (e) {
      exception_caught = true;
    }
    Expect.equals(true, exception_caught);

    // Do not expect any exceptions to be thrown.
    var g = ([int n = 1]) => n + 1;
    Expect.equals(2, g());
    Expect.equals(3, g(2));
  }

  static int doThis(int n, int f(int n)) {
    return f(n);
  }

  static testMain() {
    Expect.equals(2 * (3 * 2 + 2 + 1), f(2));
    Expect.equals(10 * 10 + 10 * 9 / 2, h(10));
    Expect.equals(90, h2(10));
    Expect.equals(320, new LocalFunctionTest().method(10));
    Expect.equals(145, new LocalFunctionTest().testExecute(10));
    Expect.equals(5, testSelfReference1(5));
    Expect.equals(24 * 25 / 2, testNesting(5));
    Expect.equals(true, testClosureCallStatement(7));
    Expect.equals(99, doThis(10, (n) => n * n - 1));
    testExceptions();
  }
}

main() {
  LocalFunctionTest.testMain();
}