Fixed Issue #465: tests for Exports added updated.
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t02.dart b/LanguageFeatures/nnbd/exports_A01_functions_t02.dart
new file mode 100644
index 0000000..439b9a5
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t02.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function with nullable argument is exported from
+ * opted-in library to legacy library and then back to the opted in code, it
+ * retains its status and can accept [null] arguments.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "dart:async";
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(test_nullable_int_arg is void Function(int?));
+ test_nullable_int_arg(null);
+
+ Expect.isTrue(test_nullable_object_arg is void Function(Object?));
+ test_nullable_object_arg(null);
+
+ Expect.isTrue(test_null_arg is void Function(Null));
+ test_null_arg(null);
+
+ Expect.isTrue(test_futureOr_arg is void Function(FutureOr));
+ test_futureOr_arg(null);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t03.dart b/LanguageFeatures/nnbd/exports_A01_functions_t03.dart
new file mode 100644
index 0000000..52c7515
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t03.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function with non-nullable argument is exported
+ * from opted-in library to legacy library and then back to the opted in code,
+ * it retains its status and can accept non-null arguments.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "dart:async";
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(test_int_arg is void Function(int));
+ test_int_arg(1);
+
+ Expect.isTrue(test_object_arg is void Function(Object));
+ test_object_arg(1);
+
+ Expect.isTrue(test_function_arg is void Function(Function));
+ test_function_arg(testme);
+
+ Expect.isTrue(test_futureOrInt_arg is void Function(FutureOr<int>));
+ test_futureOrInt_arg(1);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t04.dart b/LanguageFeatures/nnbd/exports_A01_functions_t04.dart
new file mode 100644
index 0000000..c1342e1
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t04.dart
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function with non-nullable argument is exported
+ * from opted-in library to legacy library and then back to the opted in code,
+ * it retains its status and cannot accept [null] as argument.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ test_int_arg(null);
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ test_object_arg(null);
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ test_function_arg(null);
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ test_futureOrInt_arg(null);
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t05.dart b/LanguageFeatures/nnbd/exports_A01_functions_t05.dart
new file mode 100644
index 0000000..5935885
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t05.dart
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function with [Never] argument is exported from
+ * opted-in library to legacy library and then back to the opted in code, it
+ * retains its status.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(test_never_arg is void Function(Never));
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t06.dart b/LanguageFeatures/nnbd/exports_A01_functions_t06.dart
new file mode 100644
index 0000000..254c028
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t06.dart
@@ -0,0 +1,30 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function with [Never] argument is exported from
+ * opted-in library to legacy library and then back to the opted in code, it
+ * retains its status and so never be can called.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ test_never_arg(1);
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ test_never_arg(null);
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t07.dart b/LanguageFeatures/nnbd/exports_A01_functions_t07.dart
new file mode 100644
index 0000000..35852f2
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t07.dart
@@ -0,0 +1,24 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function with required argument is exported
+ * from opted-in library to legacy library and then back to the opted in code,
+ * it retains its status.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(test_required_arg is void Function({required int i}));
+ test_required_arg(i: 1);
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t08.dart b/LanguageFeatures/nnbd/exports_A01_functions_t08.dart
new file mode 100644
index 0000000..ec28396
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t08.dart
@@ -0,0 +1,31 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function with required argument is exported
+ * from opted-in library to legacy library and then back to the opted in code,
+ * it retains its status, i.e. its parameter cannot be unspecified in the
+ * function call.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ test_required_arg();
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ test_required_arg(i: null);
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t09.dart b/LanguageFeatures/nnbd/exports_A01_functions_t09.dart
new file mode 100644
index 0000000..e702efe
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t09.dart
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function which returns nullable is exported from
+ * opted-in library to legacy library and then back to the opted in code, it
+ * retains its status and so can return [null].
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "dart:async";
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(getNullableInt is int? Function());
+ Expect.isNull(getNullableInt());
+
+ Expect.isTrue(getNullableObject is Object? Function());
+ Expect.isNull(getNullableObject());
+
+ Expect.isTrue(getDynamic is dynamic Function());
+ Expect.isNull(getDynamic());
+
+ Expect.isTrue(getNullableFunction is Function? Function());
+ Expect.isNull(getNullableFunction());
+
+ Expect.isTrue(getNull is Null Function());
+ Expect.isNull(getNull());
+
+ Expect.isTrue(getFutureOr is FutureOr Function());
+ Expect.isNull(getFutureOr());
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t10.dart b/LanguageFeatures/nnbd/exports_A01_functions_t10.dart
new file mode 100644
index 0000000..80c7dfd
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t10.dart
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function which returns non-nullable is exported
+ * from opted-in library to legacy library and then back to the opted in code,
+ * it retains its status.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "dart:async";
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(getInt is int Function());
+ Expect.equals(1, getInt());
+
+ Expect.isTrue(getObject is Object Function());
+ Expect.equals(1, getObject());
+
+ Expect.isTrue(getFunction is Function Function());
+ Expect.equals(testme, getFunction());
+
+ Expect.isTrue(getFutureOrInt is FutureOr<int> Function());
+ Expect.equals(1, getFutureOrInt());
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t11.dart b/LanguageFeatures/nnbd/exports_A01_functions_t11.dart
new file mode 100644
index 0000000..08dbb07
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t11.dart
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if function which returns [Never] is exported
+ * from opted-in library to legacy library and then back to the opted in code,
+ * it retains its status.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ late Never n;
+ Expect.isTrue(getNever is Never Function());
+ Expect.throws(() { n = getNever(); } );
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t12.dart b/LanguageFeatures/nnbd/exports_A01_functions_t12.dart
new file mode 100644
index 0000000..6217602
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t12.dart
@@ -0,0 +1,41 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function with nullable type parameter is
+ * exported from opted-in library to legacy library and then back to the opted
+ * in code, it retains its status and so can accept [Null] as a type parameter.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "dart:async";
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(testGenericDynamic is void Function<T>());
+ testGenericDynamic<Null>();
+
+ Expect.isTrue(testGenericNullableInt is void Function<T extends int?>());
+ testGenericNullableInt<Null>();
+
+ Expect.isTrue(testGenericNullableFunction is void Function<T extends Function?>());
+ testGenericNullableFunction<Null>();
+
+ Expect.isTrue(testGenericNullableObject is void Function<T extends Object?>());
+ testGenericNullableObject<Null>();
+
+ Expect.isTrue(testGenericNull is void Function<T extends Null>());
+ testGenericNull<Null>();
+ testGenericNull();
+
+ Expect.isTrue(testGenericFutureOr is void Function<T extends FutureOr>());
+ testGenericFutureOr<Null>();
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t13.dart b/LanguageFeatures/nnbd/exports_A01_functions_t13.dart
new file mode 100644
index 0000000..a72f159
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t13.dart
@@ -0,0 +1,25 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function with non-nullable type parameter
+ * is exported from opted-in library to legacy library and then back to the
+ * opted in code, it retains its status.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "../../Utils/expect.dart";
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ Expect.isTrue(testGenericInt is void Function<T extends int>());
+ Expect.isTrue(testGenericFunction is void Function<T extends Function>());
+ Expect.isTrue(testGenericObject is void Function<T extends Object>());
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t14.dart b/LanguageFeatures/nnbd/exports_A01_functions_t14.dart
new file mode 100644
index 0000000..6be561f
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t14.dart
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function with non-nullable type parameter
+ * is exported from opted-in library to legacy library and then back to the
+ * opted in code, it retains its status and so cannot accept [Null] as a type
+ * parameter.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ testGenericInt<Null>();
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ testGenericFunction<Null>();
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ testGenericObject<Null>();
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+}
diff --git a/LanguageFeatures/nnbd/exports_A01_functions_t15.dart b/LanguageFeatures/nnbd/exports_A01_functions_t15.dart
new file mode 100644
index 0000000..19a35e5
--- /dev/null
+++ b/LanguageFeatures/nnbd/exports_A01_functions_t15.dart
@@ -0,0 +1,40 @@
+/*
+ * Copyright (c) 2019, 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.
+ */
+/**
+ * @assertion If an unmigrated library re-exports a migrated library, the
+ * re-exported symbols retain their migrated status (that is, downstream
+ * migrated libraries will see their migrated types).
+ * @description Check that if generic function with [Never] type parameter is
+ * exported from opted-in library to legacy library and then back to the opted
+ * in code, it retains its status.
+ * @author iarkh@unipro.ru
+ */
+// SharedOptions=--enable-experiment=non-nullable
+// Requirements=nnbd-strong
+
+import "exports_legacy_A01_lib.dart";
+
+main() {
+ testGenericNever();
+// ^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ testGenericNever<Null>();
+// ^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ testGenericNever<dynamic>();
+// ^^^^^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+
+ testGenericNever<int>();
+// ^^^
+// [analyzer] unspecified
+// [cfe] unspecified
+}
diff --git a/LanguageFeatures/nnbd/exports_opted_in_lib.dart b/LanguageFeatures/nnbd/exports_opted_in_lib.dart
index 2c54a63..aaf5e88 100644
--- a/LanguageFeatures/nnbd/exports_opted_in_lib.dart
+++ b/LanguageFeatures/nnbd/exports_opted_in_lib.dart
@@ -12,6 +12,7 @@
library override_opted_in_lib;
import "dart:async";
+import "../../Utils/expect.dart";
// Nullable variables:
int? nullable_i1;
@@ -97,21 +98,21 @@
void testme() {}
-void test_nullable_int_arg(int? i) {}
-void test_nullable_Object_arg(int? i) {}
-void test_dynamic_arg(dynamic i) {}
-void test_nullable_function(Function? f) {}
-void test_null_arg(Null n) {}
-void test_futureOr_arg(FutureOr i) {}
+void test_nullable_int_arg(int? i) { Expect.isNull(i); }
+void test_nullable_object_arg(Object? i) { Expect.isNull(i); }
+void test_dynamic_arg(dynamic i) { Expect.isNull(i); }
+void test_nullable_function(Function? f) { Expect.isNull(f); }
+void test_null_arg(Null n) { Expect.isNull(n); }
+void test_futureOr_arg(FutureOr i) { Expect.isNull(i); }
-void test_int_arg(int i) {}
-void test_object_arg(Object o) {}
-void test_function_arg(Function f) {}
-void test_futureOrInt_arg(FutureOr<int> i) {}
+void test_int_arg(int i) { Expect.equals(1, i); }
+void test_object_arg(Object o) { Expect.equals(1, o); }
+void test_function_arg(Function f) { Expect.equals(testme, f); }
+void test_futureOrInt_arg(FutureOr<int> i) { Expect.equals(1, i); }
void test_never_arg(Never n) {}
-void test_required_arg({required int i}) {}
+void test_required_arg({required int i}) { Expect.equals(1, i); }
int? getNullableInt() => null;
Object? getNullableObject() => null;
@@ -127,13 +128,15 @@
Never getNever() => throw("Should not reach here");
-void testMeDynamic<T>() {}
-void testMeNullableInt<T extends int?>() {}
-void testMeNullableFunction<T extends Function?>() {}
-void testMeNullableObject<T extends Object?>() {}
-void testMeNull<T extends Null>() {}
-void testMeFutureOr<T extends FutureOr>() {}
+void testGenericDynamic<T>() { Expect.equals(Null, T); }
+void testGenericNullableInt<T extends int?>() { Expect.equals(Null, T); }
+void testGenericNullableFunction<T extends Function?>() { Expect.equals(Null, T); }
+void testGenericNullableObject<T extends Object?>() { Expect.equals(Null, T); }
+void testGenericNull<T extends Null>() { Expect.equals(Null, T); }
+void testGenericFutureOr<T extends FutureOr>() { Expect.equals(Null, T); }
-void testMeInt<T extends int>() {}
-void testMeFunction<T extends Function>() {}
-void testMeObject<T extends Object>() {}
+void testGenericInt<T extends int>() {}
+void testGenericFunction<T extends Function>() {}
+void testGenericObject<T extends Object>() {}
+
+void testGenericNever<T extends Never>() {}
