Bring back the deleted 1.0 corelib tests.

What is dead may never die.

Change-Id: I80ef766b8ce2b6e1416df8e1f9b91fb74169dc79
Reviewed-on: https://dart-review.googlesource.com/7483
Reviewed-by: William Hesse <whesse@google.com>

Author: munificent

PRESUBMIT.py

@@ -102,6 +102,7 @@ def _CheckNewTests(input_api, output_api):
       #    Dart 1 tests                DDC tests
       # =================       ==========================
       ("tests/language/",       "tests/language_2/"),
+      ("tests/corelib/",        "tests/corelib_2/"),
       ("tests/lib/",            "tests/lib_2/"),
       ("tests/html/",           "tests/lib_2/html/"),
   ]

tests/corelib/apply2_test.dart

@@ -0,0 +1,96 @@
+// Copyright (c) 2012, 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.
+
+import "package:expect/expect.dart";
+
+apply(Function function, List positional, Map<Symbol, dynamic> named) {
+  return Function.apply(function, positional, named);
+}
+
+void throwsNSME(function, positional, named) {
+  Expect.throws(
+      () => apply(function, positional, named), (e) => e is NoSuchMethodError);
+}
+
+main() {
+  var c1 = () => 'c1';
+  var c2 = (a) => 'c2 $a';
+  var c3 = ([a = 1]) => 'c3 $a';
+  var c4 = ({a: 1}) => 'c4 $a';
+  var c5 = ({a: 1, b: 2}) => 'c5 $a $b';
+  var c6 = ({b: 1, a: 2}) => 'c6 $a $b';
+  var c7 = (x, {b: 1, a: 2}) => 'c7 $x $a $b';
+  var c8 = (x, y, [a = 2, b = 3]) => 'c8 $x $y $a $b';
+
+  Expect.equals('c1', apply(c1, null, null));
+  Expect.equals('c1', apply(c1, [], null));
+  Expect.equals('c1', apply(c1, [], {}));
+  Expect.equals('c1', apply(c1, null, {}));
+  throwsNSME(c1, [1], null);
+  throwsNSME(c1, [1], {#a: 2});
+  throwsNSME(c1, null, {#a: 2});
+
+  Expect.equals('c2 1', apply(c2, [1], null));
+  Expect.equals('c2 1', apply(c2, [1], {}));
+  throwsNSME(c2, null, null);
+  throwsNSME(c2, [], null);
+  throwsNSME(c2, null, {});
+  throwsNSME(c2, null, {#a: 1});
+  throwsNSME(c2, [2], {#a: 1});
+
+  Expect.equals('c3 1', apply(c3, null, null));
+  Expect.equals('c3 1', apply(c3, [], null));
+  Expect.equals('c3 2', apply(c3, [2], {}));
+  throwsNSME(c3, [1, 2], null);
+  throwsNSME(c3, null, {#a: 1});
+
+  Expect.equals('c4 1', apply(c4, [], null));
+  Expect.equals('c4 2', apply(c4, [], {#a: 2}));
+  Expect.equals('c4 1', apply(c4, null, null));
+  Expect.equals('c4 1', apply(c4, [], {}));
+  throwsNSME(c4, [1], {#a: 1});
+  throwsNSME(c4, [1], {});
+  throwsNSME(c4, [], {#a: 1, #b: 2});
+
+  Expect.equals('c5 1 2', apply(c5, [], null));
+  Expect.equals('c5 3 2', apply(c5, [], {#a: 3}));
+  Expect.equals('c5 1 2', apply(c5, null, null));
+  Expect.equals('c5 1 2', apply(c5, [], {}));
+  Expect.equals('c5 3 4', apply(c5, [], {#a: 3, #b: 4}));
+  Expect.equals('c5 4 3', apply(c5, [], {#b: 3, #a: 4}));
+  Expect.equals('c5 1 3', apply(c5, [], {#b: 3}));
+  throwsNSME(c5, [1], {#a: 1});
+  throwsNSME(c5, [1], {});
+  throwsNSME(c5, [], {#a: 1, #b: 2, #c: 3});
+
+  Expect.equals('c6 2 1', apply(c6, [], null));
+  Expect.equals('c6 3 1', apply(c6, [], {#a: 3}));
+  Expect.equals('c6 2 1', apply(c6, null, null));
+  Expect.equals('c6 2 1', apply(c6, [], {}));
+  Expect.equals('c6 3 4', apply(c6, [], {#a: 3, #b: 4}));
+  Expect.equals('c6 4 3', apply(c6, [], {#b: 3, #a: 4}));
+  Expect.equals('c6 2 3', apply(c6, [], {#b: 3}));
+  throwsNSME(c6, [1], {#a: 1});
+  throwsNSME(c6, [1], {});
+  throwsNSME(c6, [], {#a: 1, #b: 2, #c: 3});
+
+  Expect.equals('c7 7 2 1', apply(c7, [7], null));
+  Expect.equals('c7 7 3 1', apply(c7, [7], {#a: 3}));
+  Expect.equals('c7 7 2 1', apply(c7, [7], {}));
+  Expect.equals('c7 7 3 4', apply(c7, [7], {#a: 3, #b: 4}));
+  Expect.equals('c7 7 4 3', apply(c7, [7], {#b: 3, #a: 4}));
+  Expect.equals('c7 7 2 3', apply(c7, [7], {#b: 3}));
+  throwsNSME(c7, [], {#a: 1});
+  throwsNSME(c7, [], {});
+  throwsNSME(c7, [7], {#a: 1, #b: 2, #c: 3});
+
+  Expect.equals('c8 7 8 2 3', apply(c8, [7, 8], null));
+  Expect.equals('c8 7 8 2 3', apply(c8, [7, 8], {}));
+  Expect.equals('c8 7 8 3 3', apply(c8, [7, 8, 3], null));
+  Expect.equals('c8 7 8 3 4', apply(c8, [7, 8, 3, 4], null));
+  throwsNSME(c8, [], null);
+  throwsNSME(c8, [], {});
+  throwsNSME(c8, [1], null);
+  throwsNSME(c8, [7, 8, 9, 10, 11], null);
+}

tests/corelib/apply3_test.dart

@@ -0,0 +1,69 @@
+// Copyright (c) 2013, 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.
+
+// Test [Function.apply] on user-defined classes that implement [noSuchMethod].
+
+import "package:expect/expect.dart";
+import 'dart:mirrors';
+
+class F {
+  call([p1]) => "call";
+  noSuchMethod(Invocation invocation) => "NSM";
+}
+
+class G {
+  call() => '42';
+  noSuchMethod(Invocation invocation) => invocation;
+}
+
+class H {
+  call(required, {a}) => required + a;
+}
+
+main() {
+  Expect.equals('call', Function.apply(new F(), []));
+  Expect.equals('call', Function.apply(new F(), [1]));
+  Expect.equals('NSM', Function.apply(new F(), [1, 2]));
+  Expect.equals('NSM', Function.apply(new F(), [1, 2, 3]));
+
+  var symbol = const Symbol('a');
+  var requiredParameters = [1];
+  var optionalParameters = new Map()..[symbol] = 42;
+  Invocation i =
+      Function.apply(new G(), requiredParameters, optionalParameters);
+
+  Expect.equals(const Symbol('call'), i.memberName);
+  Expect.listEquals(requiredParameters, i.positionalArguments);
+  Expect.mapEquals(optionalParameters, i.namedArguments);
+  Expect.isTrue(i.isMethod);
+  Expect.isFalse(i.isGetter);
+  Expect.isFalse(i.isSetter);
+  Expect.isFalse(i.isAccessor);
+
+  // Check that changing the passed list and map for parameters does
+  // not affect [i].
+  requiredParameters[0] = 42;
+  optionalParameters[symbol] = 12;
+  Expect.listEquals([1], i.positionalArguments);
+  Expect.mapEquals(new Map()..[symbol] = 42, i.namedArguments);
+
+  // Check that using [i] for invocation yields the same [Invocation]
+  // object.
+  var mirror = reflect(new G());
+  Invocation other = mirror.delegate(i);
+  Expect.equals(i.memberName, other.memberName);
+  Expect.listEquals(i.positionalArguments, other.positionalArguments);
+  Expect.mapEquals(i.namedArguments, other.namedArguments);
+  Expect.equals(i.isMethod, other.isMethod);
+  Expect.equals(i.isGetter, other.isGetter);
+  Expect.equals(i.isSetter, other.isSetter);
+  Expect.equals(i.isAccessor, other.isAccessor);
+
+  // Test that [i] can be used to hit an existing method.
+  Expect.equals(43, new H().call(1, a: 42));
+  Expect.equals(43, Function.apply(new H(), [1], new Map()..[symbol] = 42));
+  mirror = reflect(new H());
+  Expect.equals(43, mirror.delegate(i));
+  Expect.equals(43, mirror.delegate(other));
+}

tests/corelib/apply4_test.dart

@@ -0,0 +1,20 @@
+// Copyright (c) 2015, 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.
+
+import "package:expect/expect.dart";
+
+// Testing Function.apply calls work correctly for arities that are not
+// otherwise present in the program (and thus might not have stubs
+// generated).
+
+class A {
+  foo(x, [y, z, a, b, c, d = 99, e, f, g, h, i, j]) => "$x $d";
+}
+
+main() {
+  var a = new A();
+  var clos = a.foo;
+  Expect.equals(Function.apply(clos, ["well"]), "well 99");
+  Expect.equals(Function.apply(clos, ["well", 0, 2, 4, 3, 6, 9, 10]), "well 9");
+}

tests/corelib/apply5_test.dart

@@ -0,0 +1,23 @@
+// Copyright (c) 2016, 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.
+
+import "package:expect/expect.dart";
+
+// Testing that, when compiled to JS, Function.apply works correctly for
+// functions with that will be invoked directly vs using .apply().
+
+class A {
+  foo([a = 10, b = 20, c = 30, d = 40, e = 50]) => "$a $b $c $d $e";
+}
+
+main() {
+  var a = new A();
+  var clos = a.foo;
+  Expect.equals(Function.apply(clos, []), "10 20 30 40 50");
+  Expect.equals(Function.apply(clos, [11]), "11 20 30 40 50");
+  Expect.equals(Function.apply(clos, [11, 21]), "11 21 30 40 50");
+  Expect.equals(Function.apply(clos, [11, 21, 31]), "11 21 31 40 50");
+  Expect.equals(Function.apply(clos, [11, 21, 31, 41]), "11 21 31 41 50");
+  Expect.equals(Function.apply(clos, [11, 21, 31, 41, 51]), "11 21 31 41 51");
+}

tests/corelib/apply_test.dart

@@ -0,0 +1,76 @@
+// Copyright (c) 2012, 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.
+
+import "package:expect/expect.dart";
+import "symbol_map_helper.dart";
+
+// Testing Function.apply calls correctly.
+// This test is not testing error handling, only that correct parameters
+// cause a correct call.
+
+int test0() => 42;
+int test0a({int a}) => 37 + a;
+int test1(int i) => i + 1;
+int test1a(int i, {int a}) => i + a;
+int test2(int i, int j) => i + j;
+int test2a(int i, int j, {int a}) => i + j + a;
+
+class C {
+  int x = 10;
+  int foo(y) => this.x + y;
+}
+
+class Callable {
+  int call(int x, int y) => x + y;
+}
+
+@NoInline()
+@AssumeDynamic()
+confuse(x) => x;
+
+main() {
+  testMap(res, func, map) {
+    map = symbolMapToStringMap(map);
+    Expect.equals(res, Function.apply(func, null, map));
+    Expect.equals(res, Function.apply(func, [], map));
+  }
+
+  testList(res, func, list) {
+    Expect.equals(res, Function.apply(func, list));
+    Expect.equals(res, Function.apply(func, list, null));
+    Expect.equals(res, Function.apply(func, list, new Map<Symbol, dynamic>()));
+  }
+
+  test(res, func, list, map) {
+    map = symbolMapToStringMap(map);
+    Expect.equals(res, Function.apply(func, list, map));
+  }
+
+  testList(42, test0, null);
+  testList(42, test0, []);
+  testMap(42, test0a, {"a": 5});
+  testList(42, test1, [41]);
+  test(42, test1a, [20], {"a": 22});
+  testList(42, test2, [20, 22]);
+  test(42, test2a, [10, 15], {"a": 17});
+
+  // Test that "this" is correct when calling closurized functions.
+  var cfoo = new C().foo;
+  testList(42, cfoo, [32]);
+
+  // Test that apply works even with a different name.
+  var app = confuse(Function.apply);
+  Expect.equals(42, app(test2, [22, 20]));
+
+  // Test that apply can itself be applied.
+  Expect.equals(
+      42,
+      Function.apply(Function.apply, [
+        test2,
+        [17, 25]
+      ]));
+
+  // Test that apply works on callable objects.
+  testList(42, new Callable(), [13, 29]);
+}