From d6ef495a9aeefee04cfdb799d88b174dfce0ab73 Mon Sep 17 00:00:00 2001 From: Robert Nystrom Date: Mon, 5 May 2025 02:31:55 -0700 Subject: [PATCH] Format tests/lib/mirrors using 3.8 style. Change-Id: I9f922f8a4106f993c63b55ebbe3c54ea999cbbd4 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/426287 Auto-Submit: Bob Nystrom Reviewed-by: Lasse Nielsen Commit-Queue: Lasse Nielsen --- tests/lib/mirrors/abstract_test.dart | 4 +- .../mirrors/accessor_cache_overflow_test.dart | 2 +- tests/lib/mirrors/apply3_test.dart | 7 +- .../lib/mirrors/bad_argument_types_test.dart | 14 +- .../mirrors/class_mirror_location_other.dart | 3 + .../mirrors/class_mirror_location_test.dart | 29 ++-- .../class_mirror_type_variables_expect.dart | 4 +- .../closurization_equivalence_test.dart | 21 ++- .../constructor_optional_args_test.dart | 10 +- tests/lib/mirrors/constructors_test.dart | 34 ++-- tests/lib/mirrors/declarations_model.dart | 8 +- .../mirrors/declarations_model_easier.dart | 4 +- tests/lib/mirrors/declarations_type_test.dart | 17 +- .../deferred_mirrors_metadata_lib.dart | 7 +- .../delegate_call_through_getter_test.dart | 9 +- tests/lib/mirrors/dynamic_load_test.dart | 36 +++-- tests/lib/mirrors/enum_test.dart | 65 ++++---- tests/lib/mirrors/equality_test.dart | 71 +++++---- .../mirrors/fake_function_with_call_test.dart | 6 +- .../generic_class_declaration_test.dart | 91 ++++++----- ...eric_f_bounded_mixin_application_test.dart | 28 ++-- .../generic_function_typedef_test.dart | 78 ++++++---- tests/lib/mirrors/generics_helper.dart | 4 +- .../mirrors/hierarchy_invariants_test.dart | 12 +- tests/lib/mirrors/hot_get_field_test.dart | 4 +- tests/lib/mirrors/hot_set_field_test.dart | 4 +- tests/lib/mirrors/inherit_field_test.dart | 4 +- ..._members_unimplemented_interface_test.dart | 9 +- .../instance_members_with_override_test.dart | 23 ++- .../instantiate_abstract_class_test.dart | 7 +- .../mirrors/invoke_call_on_closure_test.dart | 17 +- ...oke_call_through_implicit_getter_test.dart | 30 ++-- .../mirrors/invoke_closurization2_test.dart | 38 +++-- tests/lib/mirrors/invoke_import_test.dart | 30 ++-- .../invoke_private_wrong_library_test.dart | 3 +- tests/lib/mirrors/invoke_test.dart | 49 ++++-- tests/lib/mirrors/issue21079_test.dart | 3 +- tests/lib/mirrors/lazy_static_test.dart | 11 +- tests/lib/mirrors/libraries_test.dart | 5 +- ...ary_enumeration_deferred_loading_test.dart | 7 +- .../mirrors/library_exports_hidden_test.dart | 22 +-- .../mirrors/library_exports_shown_test.dart | 22 +-- .../library_import_deferred_loading_test.dart | 5 +- .../library_imports_deferred_test.dart | 29 ++-- .../mirrors/library_imports_hidden_test.dart | 22 +-- .../library_imports_metadata_test.dart | 65 ++++---- ...brary_imports_prefixed_show_hide_test.dart | 25 +-- .../library_imports_prefixed_test.dart | 16 +- .../mirrors/library_imports_shown_test.dart | 22 +-- tests/lib/mirrors/library_metadata_test.dart | 6 +- tests/lib/mirrors/library_uri_io_test.dart | 6 +- .../lib/mirrors/library_uri_package_test.dart | 4 +- tests/lib/mirrors/load_library_test.dart | 5 +- .../local_function_is_static_test.dart | 9 +- .../method_mirror_extension_type_test.dart | 28 +++- .../mirrors/method_mirror_location_other.dart | 3 + .../mirrors/method_mirror_location_test.dart | 62 +++++--- .../lib/mirrors/method_mirror_name_test.dart | 4 +- .../method_mirror_properties_test.dart | 99 +++++++++--- ...method_mirror_source_line_ending_test.dart | 12 +- .../mirrors/method_mirror_source_test.dart | 97 ++++++------ .../mirrors/mirrors_nsm_mismatch_test.dart | 54 ++++--- tests/lib/mirrors/mirrors_reader.dart | 55 +++++-- tests/lib/mirrors/mirrors_reader_test.dart | 25 +-- tests/lib/mirrors/mirrors_test.dart | 75 +++++---- tests/lib/mirrors/mirrors_visitor.dart | 3 +- .../new_instance_optional_arguments_test.dart | 28 ++-- ...new_instance_with_type_arguments_test.dart | 5 +- tests/lib/mirrors/null_test.dart | 25 ++- tests/lib/mirrors/operator_test.dart | 9 +- .../other_declarations_location_test.dart | 26 +++- .../lib/mirrors/parameter_abstract_test.dart | 15 +- .../parameter_annotation_mirror_test.dart | 26 +++- .../parameter_optional_order_test.dart | 90 ++++++----- tests/lib/mirrors/parameter_test.dart | 146 ++++++++++-------- tests/lib/mirrors/proxy_type_test.dart | 15 +- .../redirecting_factory_reflection_test.dart | 6 +- tests/lib/mirrors/reflect_model_test.dart | 57 ++++--- .../mirrors/reflect_runtime_type_test.dart | 5 +- .../reflect_uninstantiated_class_test.dart | 5 +- tests/lib/mirrors/reflected_type_helper.dart | 6 +- tests/lib/mirrors/regress_26187_test.dart | 8 +- tests/lib/mirrors/regress_38035_test.dart | 6 +- tests/lib/mirrors/return_type_test.dart | 11 +- ...set_field_with_final_inheritance_test.dart | 3 +- .../mirrors/static_members_easier_test.dart | 6 +- tests/lib/mirrors/static_test.dart | 30 ++-- tests/lib/mirrors/stringify.dart | 5 +- tests/lib/mirrors/superclass_test.dart | 5 +- .../synthetic_accessor_properties_test.dart | 14 +- tests/lib/mirrors/to_string_test.dart | 6 +- .../mirrors/typearguments_mirror_test.dart | 66 ++++---- 92 files changed, 1389 insertions(+), 818 deletions(-) diff --git a/tests/lib/mirrors/abstract_test.dart b/tests/lib/mirrors/abstract_test.dart index aad20b2b0db..1772445a685 100644 --- a/tests/lib/mirrors/abstract_test.dart +++ b/tests/lib/mirrors/abstract_test.dart @@ -14,5 +14,7 @@ abstract class Foo {} void main() { expect( - 'Class(s(Foo) in s(test.abstract_test), top-level)', reflectClass(Foo)); + 'Class(s(Foo) in s(test.abstract_test), top-level)', + reflectClass(Foo), + ); } diff --git a/tests/lib/mirrors/accessor_cache_overflow_test.dart b/tests/lib/mirrors/accessor_cache_overflow_test.dart index 0e65d64dca9..bbe28136c9c 100644 --- a/tests/lib/mirrors/accessor_cache_overflow_test.dart +++ b/tests/lib/mirrors/accessor_cache_overflow_test.dart @@ -30,7 +30,7 @@ main() { 'C', 'D', 'E', - 'F' + 'F', ]; var symbols = []; for (var high in digits) { diff --git a/tests/lib/mirrors/apply3_test.dart b/tests/lib/mirrors/apply3_test.dart index d96fa0d264e..2cbc68d0c04 100644 --- a/tests/lib/mirrors/apply3_test.dart +++ b/tests/lib/mirrors/apply3_test.dart @@ -30,8 +30,11 @@ main() { var symbol = const Symbol('a'); var requiredParameters = [1]; var optionalParameters = new Map()..[symbol] = 42; - Invocation i = - Function.apply(new G(), requiredParameters, optionalParameters); + Invocation i = Function.apply( + new G(), + requiredParameters, + optionalParameters, + ); Expect.equals(const Symbol('call'), i.memberName); Expect.listEquals(requiredParameters, i.positionalArguments); diff --git a/tests/lib/mirrors/bad_argument_types_test.dart b/tests/lib/mirrors/bad_argument_types_test.dart index 6544df807a6..a63e7dc3a90 100644 --- a/tests/lib/mirrors/bad_argument_types_test.dart +++ b/tests/lib/mirrors/bad_argument_types_test.dart @@ -72,11 +72,15 @@ void badClassStaticInvoke() { Map map = Map(); map['bar'] = 'Hello world!'; final cm = reflectClass(Foo); - Expect.throwsTypeError(() => cm.invoke(#baz, [ - map - ], { - #bar: {'boo': 'bah'} - })); + Expect.throwsTypeError( + () => cm.invoke( + #baz, + [map], + { + #bar: {'boo': 'bah'}, + }, + ), + ); } void badStaticInvoke() { diff --git a/tests/lib/mirrors/class_mirror_location_other.dart b/tests/lib/mirrors/class_mirror_location_other.dart index 3b72aa13dac..2230eb4005d 100644 --- a/tests/lib/mirrors/class_mirror_location_other.dart +++ b/tests/lib/mirrors/class_mirror_location_other.dart @@ -6,6 +6,9 @@ // "mixin", "mixin class" or the test should be left at 2.19. // @dart=2.19 +// Don't let the formatter change the location of things. +// dart format off + part of test.class_location; class ClassInOtherFile {} diff --git a/tests/lib/mirrors/class_mirror_location_test.dart b/tests/lib/mirrors/class_mirror_location_test.dart index 1c54bcb73e8..39417539f9f 100644 --- a/tests/lib/mirrors/class_mirror_location_test.dart +++ b/tests/lib/mirrors/class_mirror_location_test.dart @@ -6,6 +6,9 @@ // "mixin", "mixin class" or the test should be left at 2.19. // @dart=2.19 +// Don't let the formatter change the location of things. +// dart format off + library test.class_location; import "dart:mirrors"; @@ -52,21 +55,21 @@ main() { String otherSuffix = 'class_mirror_location_other.dart'; // This file. - expectLocation(reflectClass(ClassInMainFile), mainSuffix, 12, 1); - expectLocation(reflectClass(SpaceIndentedInMainFile), mainSuffix, 13, 3); - expectLocation(reflectClass(TabIndentedInMainFile), mainSuffix, 14, 2); - expectLocation(reflectClass(AbstractClass), mainSuffix, 16, 1); - expectLocation(reflectType(Predicate), mainSuffix, 17, 1); - expectLocation(reflectClass(MA), mainSuffix, 21, 1); - expectLocation(reflectClass(MA2), mainSuffix, 22, 1); - expectLocation(reflectClass(WithMetadata), mainSuffix, 26, 1); - expectLocation(reflectClass(Enum), mainSuffix, 29, 1); - expectLocation(reflectClass(AnnotatedEnum), mainSuffix, 31, 1); + expectLocation(reflectClass(ClassInMainFile), mainSuffix, 19, 1); + expectLocation(reflectClass(SpaceIndentedInMainFile), mainSuffix, 20, 3); + expectLocation(reflectClass(TabIndentedInMainFile), mainSuffix, 21, 2); + expectLocation(reflectClass(AbstractClass), mainSuffix, 23, 1); + expectLocation(reflectType(Predicate), mainSuffix, 24, 1); + expectLocation(reflectClass(MA), mainSuffix, 28, 1); + expectLocation(reflectClass(MA2), mainSuffix, 29, 1); + expectLocation(reflectClass(WithMetadata), mainSuffix, 34, 1); + expectLocation(reflectClass(Enum), mainSuffix, 36, 1); + expectLocation(reflectClass(AnnotatedEnum), mainSuffix, 39, 1); // Another part. - expectLocation(reflectClass(ClassInOtherFile), otherSuffix, 7, 1); - expectLocation(reflectClass(SpaceIndentedInOtherFile), otherSuffix, 9, 3); - expectLocation(reflectClass(TabIndentedInOtherFile), otherSuffix, 11, 2); + expectLocation(reflectClass(ClassInOtherFile), otherSuffix, 14, 1); + expectLocation(reflectClass(SpaceIndentedInOtherFile), otherSuffix, 16, 3); + expectLocation(reflectClass(TabIndentedInOtherFile), otherSuffix, 18, 2); // Synthetic classes. Expect.isNull(reflectClass(MA).superclass!.location); diff --git a/tests/lib/mirrors/class_mirror_type_variables_expect.dart b/tests/lib/mirrors/class_mirror_type_variables_expect.dart index 3326b088b75..44c4499adb2 100644 --- a/tests/lib/mirrors/class_mirror_type_variables_expect.dart +++ b/tests/lib/mirrors/class_mirror_type_variables_expect.dart @@ -106,7 +106,9 @@ void testE(Env env) { Expect.isFalse(mapRAndHelperOfString.isOriginalDeclaration); Expect.equals(eR, mapRAndHelperOfString.typeArguments.first); Expect.equals( - env.getHelperOfString(), mapRAndHelperOfString.typeArguments.last); + env.getHelperOfString(), + mapRAndHelperOfString.typeArguments.last, + ); } void testF(Env env) { diff --git a/tests/lib/mirrors/closurization_equivalence_test.dart b/tests/lib/mirrors/closurization_equivalence_test.dart index e1cdbed550b..93b40c31204 100644 --- a/tests/lib/mirrors/closurization_equivalence_test.dart +++ b/tests/lib/mirrors/closurization_equivalence_test.dart @@ -14,12 +14,21 @@ class C { main() { LibraryMirror thisLibrary = reflectClass(C).owner as LibraryMirror; - Expect.equals(thisLibrary.declarations[#topLevelMethod], - (reflect(topLevelMethod) as ClosureMirror).function, "topLevel"); + Expect.equals( + thisLibrary.declarations[#topLevelMethod], + (reflect(topLevelMethod) as ClosureMirror).function, + "topLevel", + ); - Expect.equals(reflectClass(C).declarations[#staticMethod], - (reflect(C.staticMethod) as ClosureMirror).function, "static"); + Expect.equals( + reflectClass(C).declarations[#staticMethod], + (reflect(C.staticMethod) as ClosureMirror).function, + "static", + ); - Expect.equals(reflectClass(C).declarations[#instanceMethod], - (reflect(new C().instanceMethod) as ClosureMirror).function, "instance"); + Expect.equals( + reflectClass(C).declarations[#instanceMethod], + (reflect(new C().instanceMethod) as ClosureMirror).function, + "instance", + ); } diff --git a/tests/lib/mirrors/constructor_optional_args_test.dart b/tests/lib/mirrors/constructor_optional_args_test.dart index 5592fd2f434..734bf58ab07 100644 --- a/tests/lib/mirrors/constructor_optional_args_test.dart +++ b/tests/lib/mirrors/constructor_optional_args_test.dart @@ -16,15 +16,9 @@ class A { class B implements A { final _x, _y, _z; - B([x = 'x', y = 'y']) - : _x = x, - _y = y, - _z = null; + B([x = 'x', y = 'y']) : _x = x, _y = y, _z = null; - B.more([x = 'x', y = 'y', z = 'z']) - : _x = x, - _y = y, - _z = z; + B.more([x = 'x', y = 'y', z = 'z']) : _x = x, _y = y, _z = z; toString() => 'B(x=$_x, y=$_y, z=$_z)'; } diff --git a/tests/lib/mirrors/constructors_test.dart b/tests/lib/mirrors/constructors_test.dart index 3d821989259..00cc2a90f76 100644 --- a/tests/lib/mirrors/constructors_test.dart +++ b/tests/lib/mirrors/constructors_test.dart @@ -45,12 +45,15 @@ main() { expect('{Foo: Method(s(Foo) in s(Foo), constructor)}', fooConstructors); expect('{Bar: Method(s(Bar) in s(Bar), constructor)}', barConstructors); - expect('{Baz.named: Method(s(Baz.named) in s(Baz), constructor)}', - bazConstructors); expect( - '{Biz: Method(s(Biz) in s(Biz), constructor),' - ' Biz.named: Method(s(Biz.named) in s(Biz), constructor)}', - bizConstructors); + '{Baz.named: Method(s(Baz.named) in s(Baz), constructor)}', + bazConstructors, + ); + expect( + '{Biz: Method(s(Biz) in s(Biz), constructor),' + ' Biz.named: Method(s(Biz.named) in s(Biz), constructor)}', + bizConstructors, + ); print(bizConstructors); expect('[]', fooConstructors.values.single.parameters); @@ -61,13 +64,20 @@ main() { } expect( - '[s()]', fooConstructors.values.map((m) => m.constructorName).toList()); + '[s()]', + fooConstructors.values.map((m) => m.constructorName).toList(), + ); expect( - '[s()]', barConstructors.values.map((m) => m.constructorName).toList()); - expect('[s(named)]', - bazConstructors.values.map((m) => m.constructorName).toList()); + '[s()]', + barConstructors.values.map((m) => m.constructorName).toList(), + ); expect( - '[s(), s(named)]', - bizConstructors.values.map((m) => m.constructorName).toList() - ..sort(compareSymbols)); + '[s(named)]', + bazConstructors.values.map((m) => m.constructorName).toList(), + ); + expect( + '[s(), s(named)]', + bizConstructors.values.map((m) => m.constructorName).toList() + ..sort(compareSymbols), + ); } diff --git a/tests/lib/mirrors/declarations_model.dart b/tests/lib/mirrors/declarations_model.dart index 321eee80c7a..7da03fafb8e 100644 --- a/tests/lib/mirrors/declarations_model.dart +++ b/tests/lib/mirrors/declarations_model.dart @@ -89,7 +89,7 @@ class Superclass { Superclass.inheritedGenerativeConstructor(this.inheritedInstanceVariable); Superclass.inheritedRedirectingConstructor(x) - : this.inheritedGenerativeConstructor(x * 2); + : this.inheritedGenerativeConstructor(x * 2); factory Superclass.inheritedNormalFactory(y) => new Superclass.inheritedRedirectingConstructor(y * 3); factory Superclass.inheritedRedirectingFactory(z) = @@ -97,7 +97,7 @@ class Superclass { Superclass._inheritedGenerativeConstructor(this._inheritedInstanceVariable); Superclass._inheritedRedirectingConstructor(x) - : this._inheritedGenerativeConstructor(x * 2); + : this._inheritedGenerativeConstructor(x * 2); factory Superclass._inheritedNormalFactory(y) => new Superclass._inheritedRedirectingConstructor(y * 3); factory Superclass._inheritedRedirectingFactory(z) = @@ -132,13 +132,13 @@ abstract class Class extends Superclass static _staticMethod() => null; Class.generativeConstructor(this.instanceVariable) - : super.inheritedGenerativeConstructor(0); + : super.inheritedGenerativeConstructor(0); Class.redirectingConstructor(x) : this.generativeConstructor(x * 2); factory Class.normalFactory(y) => new ConcreteClass(y * 3); factory Class.redirectingFactory(z) = Class.normalFactory; Class._generativeConstructor(this._instanceVariable) - : super._inheritedGenerativeConstructor(0); + : super._inheritedGenerativeConstructor(0); Class._redirectingConstructor(x) : this._generativeConstructor(x * 2); factory Class._normalFactory(y) => new ConcreteClass(y * 3); factory Class._redirectingFactory(z) = Class._normalFactory; diff --git a/tests/lib/mirrors/declarations_model_easier.dart b/tests/lib/mirrors/declarations_model_easier.dart index 665b691ec33..b1ad75828db 100644 --- a/tests/lib/mirrors/declarations_model_easier.dart +++ b/tests/lib/mirrors/declarations_model_easier.dart @@ -40,7 +40,7 @@ class Superclass { Superclass.inheritedGenerativeConstructor(this.inheritedInstanceVariable); Superclass.inheritedRedirectingConstructor(x) - : this.inheritedGenerativeConstructor(x * 2); + : this.inheritedGenerativeConstructor(x * 2); factory Superclass.inheritedNormalFactory(y) => new Superclass.inheritedRedirectingConstructor(y * 3); factory Superclass.inheritedRedirectingFactory(z) = @@ -63,7 +63,7 @@ abstract class Class extends Superclass implements Interface { static staticMethod() => null; Class.generativeConstructor(this.instanceVariable) - : super.inheritedGenerativeConstructor(0); + : super.inheritedGenerativeConstructor(0); Class.redirectingConstructor(x) : this.generativeConstructor(x * 2); factory Class.normalFactory(y) => new ConcreteClass(y * 3); factory Class.redirectingFactory(z) = Class.normalFactory; diff --git a/tests/lib/mirrors/declarations_type_test.dart b/tests/lib/mirrors/declarations_type_test.dart index 836ce852c9c..580cdc5485d 100644 --- a/tests/lib/mirrors/declarations_type_test.dart +++ b/tests/lib/mirrors/declarations_type_test.dart @@ -15,21 +15,26 @@ main() { var classDeclarations = reflectClass(C).declarations; Expect.isTrue(classDeclarations is Map); Expect.isTrue(classDeclarations.values is Iterable); - Expect.isTrue(classDeclarations.values.where((x) => true) - is Iterable); + Expect.isTrue( + classDeclarations.values.where((x) => true) is Iterable, + ); Expect.isFalse(classDeclarations is Map); Expect.isFalse(classDeclarations.values is Iterable); Expect.isFalse( - classDeclarations.values.where((x) => true) is Iterable); + classDeclarations.values.where((x) => true) is Iterable, + ); var libraryDeclarations = (reflectClass(C).owner as LibraryMirror).declarations; Expect.isTrue(libraryDeclarations is Map); Expect.isTrue(libraryDeclarations.values is Iterable); - Expect.isTrue(libraryDeclarations.values.where((x) => true) - is Iterable); + Expect.isTrue( + libraryDeclarations.values.where((x) => true) + is Iterable, + ); Expect.isFalse(libraryDeclarations is Map); Expect.isFalse(libraryDeclarations.values is Iterable); Expect.isFalse( - libraryDeclarations.values.where((x) => true) is Iterable); + libraryDeclarations.values.where((x) => true) is Iterable, + ); } diff --git a/tests/lib/mirrors/deferred_mirrors_metadata_lib.dart b/tests/lib/mirrors/deferred_mirrors_metadata_lib.dart index 715628fe10b..5e4b76019bb 100644 --- a/tests/lib/mirrors/deferred_mirrors_metadata_lib.dart +++ b/tests/lib/mirrors/deferred_mirrors_metadata_lib.dart @@ -20,10 +20,9 @@ class E { String foo() { String c = reflectClass(E).metadata[0].invoke(#toString, []).reflectee; - String d = reflectClass(E) - .declarations[#f]! - .metadata[0] - .invoke(#toString, []).reflectee; + String d = reflectClass( + E, + ).declarations[#f]!.metadata[0].invoke(#toString, []).reflectee; InstanceMirror i = currentMirrorSystem().findLibrary(#main).metadata[0]; String a = i.invoke(#toString, []).reflectee; String b = i.getField(#b).invoke(#toString, []).reflectee; diff --git a/tests/lib/mirrors/delegate_call_through_getter_test.dart b/tests/lib/mirrors/delegate_call_through_getter_test.dart index 85040aef902..b1a19fa0382 100644 --- a/tests/lib/mirrors/delegate_call_through_getter_test.dart +++ b/tests/lib/mirrors/delegate_call_through_getter_test.dart @@ -19,9 +19,12 @@ class FakeFunctionNSM { class C { get fakeFunctionCall => new FakeFunctionCall(); get fakeFunctionNSM => new FakeFunctionNSM(); - get closure => (x, y) => '2 $this $x $y'; - get closureOpt => (x, y, [z, w]) => '3 $this $x $y $z $w'; - get closureNamed => (x, y, {z, w}) => '4 $this $x $y $z $w'; + get closure => + (x, y) => '2 $this $x $y'; + get closureOpt => + (x, y, [z, w]) => '3 $this $x $y $z $w'; + get closureNamed => + (x, y, {z, w}) => '4 $this $x $y $z $w'; get notAClosure => 'Not a closure'; noSuchMethod(msg) => 'DNU'; diff --git a/tests/lib/mirrors/dynamic_load_test.dart b/tests/lib/mirrors/dynamic_load_test.dart index dddb1ac23dd..d62821b90aa 100644 --- a/tests/lib/mirrors/dynamic_load_test.dart +++ b/tests/lib/mirrors/dynamic_load_test.dart @@ -11,8 +11,9 @@ main() async { IsolateMirror isolate = currentMirrorSystem().isolate; print(isolate); - LibraryMirror success = - await isolate.loadUri(Uri.parse("dynamic_load_success.dart")); + LibraryMirror success = await isolate.loadUri( + Uri.parse("dynamic_load_success.dart"), + ); print(success); InstanceMirror result = success.invoke(#advanceCounter, []); print(result); @@ -21,8 +22,9 @@ main() async { print(result); Expect.equals(2, result.reflectee); - LibraryMirror success2 = - await isolate.loadUri(Uri.parse("dynamic_load_success.dart")); + LibraryMirror success2 = await isolate.loadUri( + Uri.parse("dynamic_load_success.dart"), + ); print(success2); Expect.equals(success, success2); result = success2.invoke(#advanceCounter, []); @@ -42,10 +44,12 @@ main() async { error = e; } print(error); - Expect.isTrue(error.toString().contains("Cannot open file") || - error.toString().contains("file not found") || - error.toString().contains("No such file or directory") || - error.toString().contains("The system cannot find the file specified")); + Expect.isTrue( + error.toString().contains("Cannot open file") || + error.toString().contains("file not found") || + error.toString().contains("No such file or directory") || + error.toString().contains("The system cannot find the file specified"), + ); Expect.isTrue(error.toString().contains("DOES_NOT_EXIST")); Future bad_load2 = isolate.loadUri(Uri.parse("dart:_builtin")); @@ -60,16 +64,18 @@ main() async { Expect.isTrue(error2.toString().contains("dart:_builtin")); // Check error is not sticky. - LibraryMirror success3 = - await isolate.loadUri(Uri.parse("dynamic_load_success.dart")); + LibraryMirror success3 = await isolate.loadUri( + Uri.parse("dynamic_load_success.dart"), + ); print(success3); Expect.equals(success, success3); result = success3.invoke(#advanceCounter, []); print(result); Expect.equals(4, result.reflectee); // Same library, same state. - Future bad_load3 = - isolate.loadUri(Uri.parse("dynamic_load_error.dart")); + Future bad_load3 = isolate.loadUri( + Uri.parse("dynamic_load_error.dart"), + ); var error3; try { await bad_load3; @@ -77,7 +83,9 @@ main() async { error3 = e; } print(error3); - Expect.isTrue(error3.toString().contains("library url expected") || - error3.toString().contains("Error: Expected a String")); + Expect.isTrue( + error3.toString().contains("library url expected") || + error3.toString().contains("Error: Expected a String"), + ); Expect.isTrue(error3.toString().contains("dynamic_load_error.dart")); } diff --git a/tests/lib/mirrors/enum_test.dart b/tests/lib/mirrors/enum_test.dart index 318bfe63711..580067c29a8 100644 --- a/tests/lib/mirrors/enum_test.dart +++ b/tests/lib/mirrors/enum_test.dart @@ -18,17 +18,17 @@ main() { Expect.isTrue(reflectClass(Suite).isEnum); Expect.isFalse(reflectClass(Suite).isAbstract); Expect.equals( - 0, - reflectClass(Suite) - .declarations - .values - .where((d) => d is MethodMirror && d.isConstructor) - .length); + 0, + reflectClass(Suite).declarations.values + .where((d) => d is MethodMirror && d.isConstructor) + .length, + ); Expect.equals( - reflectClass(Suite), - (reflectClass(C).owner as LibraryMirror).declarations[#Suite], - "found in library"); + reflectClass(Suite), + (reflectClass(C).owner as LibraryMirror).declarations[#Suite], + "found in library", + ); Expect.equals(reflectClass(Suite), reflect(Suite.CLUBS).type); @@ -38,28 +38,35 @@ main() { Expect.equals(3, reflect(Suite.HEARTS).getField(#index).reflectee); Expect.equals( - "Suite.CLUBS", reflect(Suite.CLUBS).invoke(#toString, []).reflectee); - Expect.equals("Suite.DIAMONDS", - reflect(Suite.DIAMONDS).invoke(#toString, []).reflectee); + "Suite.CLUBS", + reflect(Suite.CLUBS).invoke(#toString, []).reflectee, + ); Expect.equals( - "Suite.SPADES", reflect(Suite.SPADES).invoke(#toString, []).reflectee); + "Suite.DIAMONDS", + reflect(Suite.DIAMONDS).invoke(#toString, []).reflectee, + ); Expect.equals( - "Suite.HEARTS", reflect(Suite.HEARTS).invoke(#toString, []).reflectee); + "Suite.SPADES", + reflect(Suite.SPADES).invoke(#toString, []).reflectee, + ); + Expect.equals( + "Suite.HEARTS", + reflect(Suite.HEARTS).invoke(#toString, []).reflectee, + ); Expect.setEquals( - [ - 'Variable(s(index) in s(Suite), final)', - 'Variable(s(CLUBS) in s(Suite), static, final)', - 'Variable(s(DIAMONDS) in s(Suite), static, final)', - 'Variable(s(SPADES) in s(Suite), static, final)', - 'Variable(s(HEARTS) in s(Suite), static, final)', - 'Variable(s(values) in s(Suite), static, final)', - 'Method(s(hashCode) in s(Suite), getter)', - 'Method(s(toString) in s(Suite))' - ], - reflectClass(Suite) - .declarations - .values - .where((d) => !d.isPrivate) - .map(stringify)); + [ + 'Variable(s(index) in s(Suite), final)', + 'Variable(s(CLUBS) in s(Suite), static, final)', + 'Variable(s(DIAMONDS) in s(Suite), static, final)', + 'Variable(s(SPADES) in s(Suite), static, final)', + 'Variable(s(HEARTS) in s(Suite), static, final)', + 'Variable(s(values) in s(Suite), static, final)', + 'Method(s(hashCode) in s(Suite), getter)', + 'Method(s(toString) in s(Suite))', + ], + reflectClass( + Suite, + ).declarations.values.where((d) => !d.isPrivate).map(stringify), + ); } diff --git a/tests/lib/mirrors/equality_test.dart b/tests/lib/mirrors/equality_test.dart index 56fd42da978..ee4a2ff2dcf 100644 --- a/tests/lib/mirrors/equality_test.dart +++ b/tests/lib/mirrors/equality_test.dart @@ -34,14 +34,20 @@ checkEquality(List> equivalenceClasses) { equivalenceClass.forEach((otherName, otherMember) { // Reflexivity, symmetry and transitivity. Expect.equals(member, otherMember, "$name == $otherName"); - Expect.equals(member.hashCode, otherMember.hashCode, - "$name.hashCode == $otherName.hashCode"); + Expect.equals( + member.hashCode, + otherMember.hashCode, + "$name.hashCode == $otherName.hashCode", + ); }); for (var otherEquivalenceClass in equivalenceClasses) { if (otherEquivalenceClass == equivalenceClass) continue; otherEquivalenceClass.forEach((otherName, otherMember) { Expect.notEquals( - member, otherMember, "$name != $otherName"); // Exclusion. + member, + otherMember, + "$name != $otherName", + ); // Exclusion. // Hash codes may or may not be equal. }); } @@ -52,8 +58,9 @@ checkEquality(List> equivalenceClasses) { void subroutine() {} main() { - LibraryMirror thisLibrary = currentMirrorSystem() - .findLibrary(const Symbol('test.class_equality_test')); + LibraryMirror thisLibrary = currentMirrorSystem().findLibrary( + const Symbol('test.class_equality_test'), + ); var o1 = new Object(); var o2 = new Object(); @@ -66,51 +73,54 @@ main() { {'reflect(o2)': reflect(o2), 'reflect(o2), again': reflect(o2)}, { 'reflect(badEqualityHash1)': reflect(badEqualityHash1), - 'reflect(badEqualityHash1), again': reflect(badEqualityHash1) + 'reflect(badEqualityHash1), again': reflect(badEqualityHash1), }, { 'reflect(badEqualityHash2)': reflect(badEqualityHash2), - 'reflect(badEqualityHash2), again': reflect(badEqualityHash2) + 'reflect(badEqualityHash2), again': reflect(badEqualityHash2), }, {'reflect(true)': reflect(true), 'reflect(true), again': reflect(true)}, {'reflect(false)': reflect(false), 'reflect(false), again': reflect(false)}, {'reflect(null)': reflect(null), 'reflect(null), again': reflect(null)}, { 'reflect(3.5+4.5)': reflect(3.5 + 4.5), - 'reflect(6.5+1.5)': reflect(6.5 + 1.5) + 'reflect(6.5+1.5)': reflect(6.5 + 1.5), }, {'reflect(3+4)': reflect(3 + 4), 'reflect(6+1)': reflect(6 + 1)}, {'reflect("foo")': reflect("foo"), 'reflect("foo"), again': reflect("foo")}, { 'currentMirrorSystem().voidType': currentMirrorSystem().voidType, 'thisLibrary.declarations[#subroutine].returnType': - (thisLibrary.declarations[#subroutine] as MethodMirror).returnType + (thisLibrary.declarations[#subroutine] as MethodMirror).returnType, }, { 'currentMirrorSystem().dynamicType': currentMirrorSystem().dynamicType, 'thisLibrary.declarations[#main].returnType': - (thisLibrary.declarations[#main] as MethodMirror).returnType + (thisLibrary.declarations[#main] as MethodMirror).returnType, }, { 'reflectClass(A)': reflectClass(A), 'thisLibrary.declarations[#A]': thisLibrary.declarations[#A], - 'reflect(new A()).type.originalDeclaration': - reflect(new A()).type.originalDeclaration + 'reflect(new A()).type.originalDeclaration': reflect( + new A(), + ).type.originalDeclaration, }, { 'reflectClass(B).superclass': reflectClass(B).superclass, - 'reflect(new A()).type': reflect(new A()).type + 'reflect(new A()).type': reflect(new A()).type, }, { 'reflectClass(B)': reflectClass(B), 'thisLibrary.declarations[#B]': thisLibrary.declarations[#B], - 'reflect(new B()).type': reflect(new B()).type + 'reflect(new B()).type': reflect(new B()).type, }, { - 'reflectClass(BadEqualityHash).declarations[#==]': - reflectClass(BadEqualityHash).declarations[#==], - 'reflect(new BadEqualityHash()).type.declarations[#==]': - reflect(new BadEqualityHash()).type.declarations[#==] + 'reflectClass(BadEqualityHash).declarations[#==]': reflectClass( + BadEqualityHash, + ).declarations[#==], + 'reflect(new BadEqualityHash()).type.declarations[#==]': reflect( + new BadEqualityHash(), + ).type.declarations[#==], }, { 'reflectClass(BadEqualityHash).declarations[#==].parameters[0]': @@ -119,18 +129,20 @@ main() { 'reflect(new BadEqualityHash()).type.declarations[#==].parameters[0]': (reflect(new BadEqualityHash()).type.declarations[#==] as MethodMirror) - .parameters[0] + .parameters[0], }, { - 'reflectClass(BadEqualityHash).declarations[#count]': - reflectClass(BadEqualityHash).declarations[#count], - 'reflect(new BadEqualityHash()).type.declarations[#count]': - reflect(new BadEqualityHash()).type.declarations[#count] + 'reflectClass(BadEqualityHash).declarations[#count]': reflectClass( + BadEqualityHash, + ).declarations[#count], + 'reflect(new BadEqualityHash()).type.declarations[#count]': reflect( + new BadEqualityHash(), + ).type.declarations[#count], }, { 'reflectType(Predicate)': reflectType(Predicate), 'thisLibrary.declarations[#somePredicate].type': - (thisLibrary.declarations[#somePredicate] as VariableMirror).type + (thisLibrary.declarations[#somePredicate] as VariableMirror).type, }, { 'reflectType(Predicate).referent': @@ -138,13 +150,14 @@ main() { 'thisLibrary.declarations[#somePredicate].type.referent': ((thisLibrary.declarations[#somePredicate] as VariableMirror).type as TypedefMirror) - .referent + .referent, }, { - 'reflectClass(A).typeVariables.single': - reflectClass(A).typeVariables.single, + 'reflectClass(A).typeVariables.single': reflectClass( + A, + ).typeVariables.single, 'reflect(new A()).type.originalDeclaration.typeVariables.single': - reflect(new A()).type.originalDeclaration.typeVariables.single + reflect(new A()).type.originalDeclaration.typeVariables.single, }, {'currentMirrorSystem()': currentMirrorSystem()}, {'currentMirrorSystem().isolate': currentMirrorSystem().isolate}, @@ -153,7 +166,7 @@ main() { 'reflectClass(A).owner': reflectClass(A).owner, 'reflectClass(B).owner': reflectClass(B).owner, 'reflect(new A()).type.owner': reflect(new A()).type.owner, - 'reflect(new B()).type.owner': reflect(new B()).type.owner + 'reflect(new B()).type.owner': reflect(new B()).type.owner, }, ]); } diff --git a/tests/lib/mirrors/fake_function_with_call_test.dart b/tests/lib/mirrors/fake_function_with_call_test.dart index 43522bcc8c5..5d81260d197 100644 --- a/tests/lib/mirrors/fake_function_with_call_test.dart +++ b/tests/lib/mirrors/fake_function_with_call_test.dart @@ -27,8 +27,10 @@ main() { Expect.equals(7, cm.invoke(#call, [3, 4]).reflectee); Expect.throwsNoSuchMethodError(() => cm.invoke(#call, [3]), "Wrong arity"); Expect.equals(49, cm.invoke(#method, [7]).reflectee); - Expect.throwsNoSuchMethodError(() => cm.invoke(#method, [3, 4]), - "Wrong arity"); + Expect.throwsNoSuchMethodError( + () => cm.invoke(#method, [3, 4]), + "Wrong arity", + ); Expect.equals(7, cm.apply([3, 4]).reflectee); Expect.throwsNoSuchMethodError(() => cm.apply([3]), "Wrong arity"); diff --git a/tests/lib/mirrors/generic_class_declaration_test.dart b/tests/lib/mirrors/generic_class_declaration_test.dart index 2a2e4c6da48..084e82ef68f 100644 --- a/tests/lib/mirrors/generic_class_declaration_test.dart +++ b/tests/lib/mirrors/generic_class_declaration_test.dart @@ -31,54 +31,61 @@ class A { main() { ClassMirror cm = reflect(new A()).type; - Expect.setEquals([ - 'Variable(s(_instanceVariable) in s(A), private)', - 'Variable(s(_staticVariable) in s(A), private, static)', - 'Variable(s(instanceVariable) in s(A))', - 'Variable(s(staticVariable) in s(A), static)' - ], cm.declarations.values.where((dm) => dm is VariableMirror).map(stringify), - 'variables'); + Expect.setEquals( + [ + 'Variable(s(_instanceVariable) in s(A), private)', + 'Variable(s(_staticVariable) in s(A), private, static)', + 'Variable(s(instanceVariable) in s(A))', + 'Variable(s(staticVariable) in s(A), static)', + ], + cm.declarations.values.where((dm) => dm is VariableMirror).map(stringify), + 'variables', + ); Expect.setEquals( - [ - 'Method(s(_instanceGetter) in s(A), private, getter)', - 'Method(s(_staticGetter) in s(A), private, static, getter)', - 'Method(s(instanceGetter) in s(A), getter)', - 'Method(s(staticGetter) in s(A), static, getter)' - ], - cm.declarations.values - .where((dm) => dm is MethodMirror && dm.isGetter) - .map(stringify), - 'getters'); + [ + 'Method(s(_instanceGetter) in s(A), private, getter)', + 'Method(s(_staticGetter) in s(A), private, static, getter)', + 'Method(s(instanceGetter) in s(A), getter)', + 'Method(s(staticGetter) in s(A), static, getter)', + ], + cm.declarations.values + .where((dm) => dm is MethodMirror && dm.isGetter) + .map(stringify), + 'getters', + ); Expect.setEquals( - [ - 'Method(s(_instanceSetter=) in s(A), private, setter)', - 'Method(s(_staticSetter=) in s(A), private, static, setter)', - 'Method(s(instanceSetter=) in s(A), setter)', - 'Method(s(staticSetter=) in s(A), static, setter)' - ], - cm.declarations.values - .where((dm) => dm is MethodMirror && dm.isSetter) - .map(stringify), - 'setters'); + [ + 'Method(s(_instanceSetter=) in s(A), private, setter)', + 'Method(s(_staticSetter=) in s(A), private, static, setter)', + 'Method(s(instanceSetter=) in s(A), setter)', + 'Method(s(staticSetter=) in s(A), static, setter)', + ], + cm.declarations.values + .where((dm) => dm is MethodMirror && dm.isSetter) + .map(stringify), + 'setters', + ); Expect.setEquals( - [ - 'Method(s(_instanceMethod) in s(A), private)', - 'Method(s(_staticMethod) in s(A), private, static)', - 'Method(s(instanceMethod) in s(A))', - 'Method(s(staticMethod) in s(A), static)' - ], - cm.declarations.values - .where((dm) => dm is MethodMirror && dm.isRegularMethod) - .map(stringify), - 'methods'); + [ + 'Method(s(_instanceMethod) in s(A), private)', + 'Method(s(_staticMethod) in s(A), private, static)', + 'Method(s(instanceMethod) in s(A))', + 'Method(s(staticMethod) in s(A), static)', + ], + cm.declarations.values + .where((dm) => dm is MethodMirror && dm.isRegularMethod) + .map(stringify), + 'methods', + ); Expect.setEquals( - ['Method(s(A) in s(A), constructor)'], - cm.declarations.values - .where((dm) => dm is MethodMirror && dm.isConstructor) - .map(stringify), - 'constructors'); + ['Method(s(A) in s(A), constructor)'], + cm.declarations.values + .where((dm) => dm is MethodMirror && dm.isConstructor) + .map(stringify), + 'constructors', + ); } diff --git a/tests/lib/mirrors/generic_f_bounded_mixin_application_test.dart b/tests/lib/mirrors/generic_f_bounded_mixin_application_test.dart index f3fdfe0d20c..08da6bebd90 100644 --- a/tests/lib/mirrors/generic_f_bounded_mixin_application_test.dart +++ b/tests/lib/mirrors/generic_f_bounded_mixin_application_test.dart @@ -36,17 +36,21 @@ main() { ClassMirror collectionDecl = reflectClass(Collection); ClassMirror serializableDecl = reflectClass(Serializable); ClassMirror orderedCollectionDecl = reflectClass(OrderedCollection); - ClassMirror abstractOrderedCollectionDecl = - reflectClass(AbstractOrderedCollection); - ClassMirror customOrderedCollectionDecl = - reflectClass(CustomOrderedCollection); + ClassMirror abstractOrderedCollectionDecl = reflectClass( + AbstractOrderedCollection, + ); + ClassMirror customOrderedCollectionDecl = reflectClass( + CustomOrderedCollection, + ); ClassMirror orderedIntegerCollection = reflectClass(OrderedIntegerCollection); - ClassMirror customOrderedIntegerCollection = - reflectClass(CustomOrderedIntegerCollection); + ClassMirror customOrderedIntegerCollection = reflectClass( + CustomOrderedIntegerCollection, + ); ClassMirror serializerDecl = reflectClass(Serializer); ClassMirror collectionSerializerDecl = reflectClass(CollectionSerializer); - ClassMirror orderedCollectionSerializerDecl = - reflectClass(OrderedCollectionSerializer); + ClassMirror orderedCollectionSerializerDecl = reflectClass( + OrderedCollectionSerializer, + ); ClassMirror orderedCollectionOfInt = orderedIntegerCollection.superclass!; ClassMirror customOrderedCollectionOfInt = @@ -55,8 +59,9 @@ main() { ClassMirror serializerOfOrderedCollection = orderedCollectionSerializerDecl.superclass!; ClassMirror collectionOfDynamic = reflect(new Collection()).type; - ClassMirror orderedCollectionOfDynamic = - reflect(new OrderedCollection()).type; + ClassMirror orderedCollectionOfDynamic = reflect( + new OrderedCollection(), + ).type; ClassMirror collectionWithSerializableOfOrderedCollection = orderedCollectionDecl.superclass!; @@ -77,7 +82,8 @@ main() { Expect.isFalse(serializerOfOrderedCollection.isOriginalDeclaration); Expect.isFalse(collectionOfDynamic.isOriginalDeclaration); Expect.isFalse( - collectionWithSerializableOfOrderedCollection.isOriginalDeclaration); + collectionWithSerializableOfOrderedCollection.isOriginalDeclaration, + ); TypeVariableMirror rFromSerializer = serializerDecl.typeVariables.single; ClassMirror serializableOfR = rFromSerializer.upperBound as ClassMirror; diff --git a/tests/lib/mirrors/generic_function_typedef_test.dart b/tests/lib/mirrors/generic_function_typedef_test.dart index bee4310e301..83c17147017 100644 --- a/tests/lib/mirrors/generic_function_typedef_test.dart +++ b/tests/lib/mirrors/generic_function_typedef_test.dart @@ -34,15 +34,18 @@ main() { TypedefMirror transformOfR = (reflectClass(C).declarations[#transformOfR] as VariableMirror).type as TypedefMirror; - TypedefMirror transformOfDouble = (reflect(new C()) - .type - .declarations[#transformOfR] as VariableMirror) - .type as TypedefMirror; + TypedefMirror transformOfDouble = + (reflect(new C()).type.declarations[#transformOfR] + as VariableMirror) + .type + as TypedefMirror; - TypeVariableMirror tFromGenericPredicate = - reflectTypeDeclaration(GenericPredicate).typeVariables[0]; - TypeVariableMirror sFromGenericTransform = - reflectTypeDeclaration(GenericTransform).typeVariables[0]; + TypeVariableMirror tFromGenericPredicate = reflectTypeDeclaration( + GenericPredicate, + ).typeVariables[0]; + TypeVariableMirror sFromGenericTransform = reflectTypeDeclaration( + GenericTransform, + ).typeVariables[0]; TypeVariableMirror rFromC = reflectClass(C).typeVariables[0]; // Typedefs. @@ -63,7 +66,8 @@ main() { typeArguments(transformOfDouble, [reflectClass(double)]); Expect.isTrue( - reflectTypeDeclaration(NonGenericPredicate).isOriginalDeclaration); + reflectTypeDeclaration(NonGenericPredicate).isOriginalDeclaration, + ); Expect.isTrue(reflectTypeDeclaration(GenericPredicate).isOriginalDeclaration); Expect.isTrue(reflectTypeDeclaration(GenericTransform).isOriginalDeclaration); Expect.isFalse(predicateOfNum.isOriginalDeclaration); @@ -89,38 +93,56 @@ main() { typeArguments(transformOfDouble.referent, []); // Function types are always non-generic. Only the typedef is generic. - Expect.isTrue(reflectTypeDeclaration(NonGenericPredicate) - .referent - .isOriginalDeclaration); Expect.isTrue( - reflectTypeDeclaration(GenericPredicate).referent.isOriginalDeclaration); + reflectTypeDeclaration(NonGenericPredicate).referent.isOriginalDeclaration, + ); Expect.isTrue( - reflectTypeDeclaration(GenericTransform).referent.isOriginalDeclaration); + reflectTypeDeclaration(GenericPredicate).referent.isOriginalDeclaration, + ); + Expect.isTrue( + reflectTypeDeclaration(GenericTransform).referent.isOriginalDeclaration, + ); Expect.isTrue(predicateOfNum.referent.isOriginalDeclaration); Expect.isTrue(transformOfString.referent.isOriginalDeclaration); Expect.isTrue(transformOfR.referent.isOriginalDeclaration); Expect.isTrue(transformOfDouble.referent.isOriginalDeclaration); - Expect.equals(reflectClass(num), - reflectTypeDeclaration(NonGenericPredicate).referent.parameters[0].type); - Expect.equals(tFromGenericPredicate, - reflectTypeDeclaration(GenericPredicate).referent.parameters[0].type); - Expect.equals(sFromGenericTransform, - reflectTypeDeclaration(GenericTransform).referent.parameters[0].type); + Expect.equals( + reflectClass(num), + reflectTypeDeclaration(NonGenericPredicate).referent.parameters[0].type, + ); + Expect.equals( + tFromGenericPredicate, + reflectTypeDeclaration(GenericPredicate).referent.parameters[0].type, + ); + Expect.equals( + sFromGenericTransform, + reflectTypeDeclaration(GenericTransform).referent.parameters[0].type, + ); Expect.equals(reflectClass(num), predicateOfNum.referent.parameters[0].type); Expect.equals( - reflectClass(String), transformOfString.referent.parameters[0].type); + reflectClass(String), + transformOfString.referent.parameters[0].type, + ); Expect.equals(rFromC, transformOfR.referent.parameters[0].type); Expect.equals( - reflectClass(double), transformOfDouble.referent.parameters[0].type); + reflectClass(double), + transformOfDouble.referent.parameters[0].type, + ); - Expect.equals(reflectClass(bool), - reflectTypeDeclaration(NonGenericPredicate).referent.returnType); - Expect.equals(reflectClass(bool), - reflectTypeDeclaration(GenericPredicate).referent.returnType); - Expect.equals(sFromGenericTransform, - reflectTypeDeclaration(GenericTransform).referent.returnType); + Expect.equals( + reflectClass(bool), + reflectTypeDeclaration(NonGenericPredicate).referent.returnType, + ); + Expect.equals( + reflectClass(bool), + reflectTypeDeclaration(GenericPredicate).referent.returnType, + ); + Expect.equals( + sFromGenericTransform, + reflectTypeDeclaration(GenericTransform).referent.returnType, + ); Expect.equals(reflectClass(bool), predicateOfNum.referent.returnType); Expect.equals(reflectClass(String), transformOfString.referent.returnType); Expect.equals(rFromC, transformOfR.referent.returnType); diff --git a/tests/lib/mirrors/generics_helper.dart b/tests/lib/mirrors/generics_helper.dart index da10962e44d..0139b5a7e7c 100644 --- a/tests/lib/mirrors/generics_helper.dart +++ b/tests/lib/mirrors/generics_helper.dart @@ -8,7 +8,9 @@ import 'package:expect/expect.dart'; typeParameters(mirror, parameterNames) { Expect.listEquals( - parameterNames, mirror.typeVariables.map((v) => v.simpleName).toList()); + parameterNames, + mirror.typeVariables.map((v) => v.simpleName).toList(), + ); } typeArguments(mirror, argumentMirrors) { diff --git a/tests/lib/mirrors/hierarchy_invariants_test.dart b/tests/lib/mirrors/hierarchy_invariants_test.dart index 2ff3dc846c0..3d3188500fd 100644 --- a/tests/lib/mirrors/hierarchy_invariants_test.dart +++ b/tests/lib/mirrors/hierarchy_invariants_test.dart @@ -17,15 +17,19 @@ checkClass(classMirror) { Expect.notEquals(null, classMirror.owner); Expect.isTrue(classMirror.owner is LibraryMirror); if (!isAnonymousMixinApplication(classMirror)) { - Expect.equals(classMirror.originalDeclaration, - classMirror.owner.declarations[classMirror.simpleName]); + Expect.equals( + classMirror.originalDeclaration, + classMirror.owner.declarations[classMirror.simpleName], + ); } else { Expect.isNull(classMirror.owner.declarations[classMirror.simpleName]); } Expect.isTrue(classMirror.superinterfaces is List); if (classMirror.superclass == null) { - Expect.isTrue((reflectClass(Object) == classMirror) || - (classMirror.toString() == "ClassMirror on 'FutureOr'")); + Expect.isTrue( + (reflectClass(Object) == classMirror) || + (classMirror.toString() == "ClassMirror on 'FutureOr'"), + ); } else { checkClass(classMirror.superclass); } diff --git a/tests/lib/mirrors/hot_get_field_test.dart b/tests/lib/mirrors/hot_get_field_test.dart index 65cf2818ac4..73623d5322c 100644 --- a/tests/lib/mirrors/hot_get_field_test.dart +++ b/tests/lib/mirrors/hot_get_field_test.dart @@ -39,7 +39,9 @@ testPrivateWrongLibrary() { var c = new C(); var im = reflect(c); var selector = MirrorSystem.getSymbol( - '_field', reflectClass(Mirror).owner as LibraryMirror); + '_field', + reflectClass(Mirror).owner as LibraryMirror, + ); for (int i = 0; i < (2 * optimizationThreshold); i++) { Expect.throwsNoSuchMethodError(() => im.getField(selector)); diff --git a/tests/lib/mirrors/hot_set_field_test.dart b/tests/lib/mirrors/hot_set_field_test.dart index cd084d30722..819cac5cb5e 100644 --- a/tests/lib/mirrors/hot_set_field_test.dart +++ b/tests/lib/mirrors/hot_set_field_test.dart @@ -38,7 +38,9 @@ testPrivateWrongLibrary() { var c = new C(); var im = reflect(c); var selector = MirrorSystem.getSymbol( - '_field', reflectClass(Mirror).owner as LibraryMirror); + '_field', + reflectClass(Mirror).owner as LibraryMirror, + ); for (int i = 0; i < (2 * optimizationThreshold); i++) { Expect.throwsNoSuchMethodError(() => im.setField(selector, i)); diff --git a/tests/lib/mirrors/inherit_field_test.dart b/tests/lib/mirrors/inherit_field_test.dart index d8590ed81ef..f904fe8753b 100644 --- a/tests/lib/mirrors/inherit_field_test.dart +++ b/tests/lib/mirrors/inherit_field_test.dart @@ -18,6 +18,8 @@ class Bar extends Foo {} void main() { expect( - 'Variable(s(field) in s(Foo))', reflectClass(Foo).declarations[#field]); + 'Variable(s(field) in s(Foo))', + reflectClass(Foo).declarations[#field], + ); expect('', reflectClass(Bar).declarations[#field]); } diff --git a/tests/lib/mirrors/instance_members_unimplemented_interface_test.dart b/tests/lib/mirrors/instance_members_unimplemented_interface_test.dart index 5c264105505..bfad8bc514a 100644 --- a/tests/lib/mirrors/instance_members_unimplemented_interface_test.dart +++ b/tests/lib/mirrors/instance_members_unimplemented_interface_test.dart @@ -21,7 +21,12 @@ main() { ClassMirror cm = reflectClass(C); // N.B.: Does not include #implementMe. - Expect.setEquals([#hashCode, #runtimeType, #==, #noSuchMethod, #toString], - selectKeys(cm.instanceMembers, (dm) => !dm.isPrivate)); + Expect.setEquals([ + #hashCode, + #runtimeType, + #==, + #noSuchMethod, + #toString, + ], selectKeys(cm.instanceMembers, (dm) => !dm.isPrivate)); // Filter out private to avoid implementation-specific members of Object. } diff --git a/tests/lib/mirrors/instance_members_with_override_test.dart b/tests/lib/mirrors/instance_members_with_override_test.dart index 6e1b960080d..1cde246b769 100644 --- a/tests/lib/mirrors/instance_members_with_override_test.dart +++ b/tests/lib/mirrors/instance_members_with_override_test.dart @@ -22,7 +22,8 @@ abstract class C extends S { method() {} get getter {} set setter(x) {} - /* abstract */ notOverridden(); + /* abstract */ + notOverridden(); } selectKeys(Map map, bool Function(V) predicate) { @@ -45,18 +46,22 @@ main() { #runtimeType, #==, #noSuchMethod, - #toString + #toString, ], selectKeys(sMirror.instanceMembers, (dynamic dm) => !dm.isPrivate)); // Filter out private to avoid implementation-specific members of Object. Expect.equals(sMirror, sMirror.instanceMembers[#field]!.owner); Expect.equals( - sMirror, sMirror.instanceMembers[const Symbol('field=')]!.owner); + sMirror, + sMirror.instanceMembers[const Symbol('field=')]!.owner, + ); Expect.equals(sMirror, sMirror.instanceMembers[#finalField]!.owner); Expect.equals(sMirror, sMirror.instanceMembers[#method]!.owner); Expect.equals(sMirror, sMirror.instanceMembers[#getter]!.owner); Expect.equals( - sMirror, sMirror.instanceMembers[const Symbol('setter=')]!.owner); + sMirror, + sMirror.instanceMembers[const Symbol('setter=')]!.owner, + ); Expect.setEquals([ #field, @@ -70,18 +75,22 @@ main() { #runtimeType, #==, #noSuchMethod, - #toString + #toString, ], selectKeys(cMirror.instanceMembers, (dynamic dm) => !dm.isPrivate)); // Filter out private to avoid implementation-specific members of Object. Expect.equals(cMirror, cMirror.instanceMembers[#field]!.owner); Expect.equals( - cMirror, cMirror.instanceMembers[const Symbol('field=')]!.owner); + cMirror, + cMirror.instanceMembers[const Symbol('field=')]!.owner, + ); Expect.equals(cMirror, cMirror.instanceMembers[#finalField]!.owner); Expect.equals(cMirror, cMirror.instanceMembers[#method]!.owner); Expect.equals(cMirror, cMirror.instanceMembers[#getter]!.owner); Expect.equals( - cMirror, cMirror.instanceMembers[const Symbol('setter=')]!.owner); + cMirror, + cMirror.instanceMembers[const Symbol('setter=')]!.owner, + ); Expect.equals(sMirror, sMirror.instanceMembers[#notOverridden]!.owner); Expect.equals(sMirror, cMirror.instanceMembers[#notOverridden]!.owner); diff --git a/tests/lib/mirrors/instantiate_abstract_class_test.dart b/tests/lib/mirrors/instantiate_abstract_class_test.dart index 0737cf39cdf..b0b0478adc3 100644 --- a/tests/lib/mirrors/instantiate_abstract_class_test.dart +++ b/tests/lib/mirrors/instantiate_abstract_class_test.dart @@ -13,9 +13,10 @@ assertInstantiationErrorOnGenerativeConstructors(classMirror) { if (!decl.isGenerativeConstructor) return; var args = new List.filled(decl.parameters.length, null); Expect.throws( - () => classMirror.newInstance(decl.constructorName, args), - (e) => e is AbstractClassInstantiationError, - '${decl.qualifiedName} should have failed'); + () => classMirror.newInstance(decl.constructorName, args), + (e) => e is AbstractClassInstantiationError, + '${decl.qualifiedName} should have failed', + ); }); } diff --git a/tests/lib/mirrors/invoke_call_on_closure_test.dart b/tests/lib/mirrors/invoke_call_on_closure_test.dart index bb08c379a34..59285b9fb04 100644 --- a/tests/lib/mirrors/invoke_call_on_closure_test.dart +++ b/tests/lib/mirrors/invoke_call_on_closure_test.dart @@ -19,9 +19,12 @@ class FakeFunctionNSM { class C { get fakeFunctionCall => new FakeFunctionCall(); get fakeFunctionNSM => new FakeFunctionNSM(); - get closure => (x, y) => '2 $this $x $y'; - get closureOpt => (x, y, [z, w]) => '3 $this $x $y $z $w'; - get closureNamed => (x, y, {z, w}) => '4 $this $x $y $z $w'; + get closure => + (x, y) => '2 $this $x $y'; + get closureOpt => + (x, y, [z, w]) => '3 $this $x $y $z $w'; + get closureNamed => + (x, y, {z, w}) => '4 $this $x $y $z $w'; tearOff(x, y) => '22 $this $x $y'; tearOffOpt(x, y, [z, w]) => '33 $this $x $y $z $w'; tearOffNamed(x, y, {z, w}) => '44 $this $x $y $z $w'; @@ -49,7 +52,9 @@ main() { im = reflect(c.closureNamed); Expect.equals( - '4 C 14 15 null 16', im.invoke(#call, [14, 15], {#w: 16}).reflectee); + '4 C 14 15 null 16', + im.invoke(#call, [14, 15], {#w: 16}).reflectee, + ); im = reflect(c.tearOff); Expect.equals('22 C 9 10', im.invoke(#call, [9, 10]).reflectee); @@ -59,5 +64,7 @@ main() { im = reflect(c.tearOffNamed); Expect.equals( - '44 C 14 15 null 16', im.invoke(#call, [14, 15], {#w: 16}).reflectee); + '44 C 14 15 null 16', + im.invoke(#call, [14, 15], {#w: 16}).reflectee, + ); } diff --git a/tests/lib/mirrors/invoke_call_through_implicit_getter_test.dart b/tests/lib/mirrors/invoke_call_through_implicit_getter_test.dart index fd0b481a53a..603e7eb50af 100644 --- a/tests/lib/mirrors/invoke_call_through_implicit_getter_test.dart +++ b/tests/lib/mirrors/invoke_call_through_implicit_getter_test.dart @@ -53,9 +53,13 @@ testInstanceReflective() { Expect.equals('7, 8', im.invoke(#fakeFunctionNSM, [7, 8]).reflectee); Expect.equals('2 C 9 10', im.invoke(#closure, [9, 10]).reflectee); Expect.equals( - '3 C 11 12 13 null', im.invoke(#closureOpt, [11, 12, 13]).reflectee); - Expect.equals('4 C 14 15 null 16', - im.invoke(#closureNamed, [14, 15], {#w: 16}).reflectee); + '3 C 11 12 13 null', + im.invoke(#closureOpt, [11, 12, 13]).reflectee, + ); + Expect.equals( + '4 C 14 15 null 16', + im.invoke(#closureNamed, [14, 15], {#w: 16}).reflectee, + ); Expect.equals('DNU', im.invoke(#doesNotExist, [17, 18]).reflectee); Expect.throwsNoSuchMethodError(() => im.invoke(#closure, ['wrong arity'])); Expect.throwsNoSuchMethodError(() => im.invoke(#notAClosure, [])); @@ -85,9 +89,13 @@ testClassReflective() { Expect.equals('7, 8', cm.invoke(#fakeFunctionNSM, [7, 8]).reflectee); Expect.equals('2 9 10', cm.invoke(#closure, [9, 10]).reflectee); Expect.equals( - '3 11 12 13 null', cm.invoke(#closureOpt, [11, 12, 13]).reflectee); - Expect.equals('4 14 15 null 16', - cm.invoke(#closureNamed, [14, 15], {#w: 16}).reflectee); + '3 11 12 13 null', + cm.invoke(#closureOpt, [11, 12, 13]).reflectee, + ); + Expect.equals( + '4 14 15 null 16', + cm.invoke(#closureNamed, [14, 15], {#w: 16}).reflectee, + ); Expect.throwsNoSuchMethodError(() => cm.invoke(#closure, ['wrong arity'])); } @@ -113,9 +121,13 @@ testLibraryReflective() { Expect.equals('7, 8', lm.invoke(#fakeFunctionNSM, [7, 8]).reflectee); Expect.equals('2 9 10', lm.invoke(#closure, [9, 10]).reflectee); Expect.equals( - '3 11 12 13 null', lm.invoke(#closureOpt, [11, 12, 13]).reflectee); - Expect.equals('4 14 15 null 16', - lm.invoke(#closureNamed, [14, 15], {#w: 16}).reflectee); + '3 11 12 13 null', + lm.invoke(#closureOpt, [11, 12, 13]).reflectee, + ); + Expect.equals( + '4 14 15 null 16', + lm.invoke(#closureNamed, [14, 15], {#w: 16}).reflectee, + ); Expect.throwsNoSuchMethodError(() => lm.invoke(#closure, ['wrong arity'])); } diff --git a/tests/lib/mirrors/invoke_closurization2_test.dart b/tests/lib/mirrors/invoke_closurization2_test.dart index dec73572596..b6710acd649 100644 --- a/tests/lib/mirrors/invoke_closurization2_test.dart +++ b/tests/lib/mirrors/invoke_closurization2_test.dart @@ -84,19 +84,29 @@ main() { // Now the same thing through mirrors and mirror-invocation. f = getAMirror().getField(#codeUnitAt); Expect.equals( - "codeUnitAt-42", f.invoke(#call, [42], {}).reflectee); + "codeUnitAt-42", + f.invoke(#call, [42], {}).reflectee, + ); f = getAMirror().getField(#toUpperCase); Expect.equals( - "toUpperCase", f.invoke(#call, [], {}).reflectee); + "toUpperCase", + f.invoke(#call, [], {}).reflectee, + ); f = getAMirror().getField(#indexOf); Expect.equals( - "indexOf-499", f.invoke(#call, [499], {}).reflectee); + "indexOf-499", + f.invoke(#call, [499], {}).reflectee, + ); f = getAMirror().getField(#lastIndexOf); Expect.equals( - "lastIndexOf-FOO,BAR", f.invoke(#call, ["FOO", "BAR"]).reflectee); + "lastIndexOf-FOO,BAR", + f.invoke(#call, ["FOO", "BAR"]).reflectee, + ); f = getAMirror().getField(#splitMapJoin); - Expect.equals("splitMapJoin-1,2,3", - f.invoke(#call, [1], {#onMatch: 2, #onNonMatch: 3}).reflectee); + Expect.equals( + "splitMapJoin-1,2,3", + f.invoke(#call, [1], {#onMatch: 2, #onNonMatch: 3}).reflectee, + ); f = getAMirror().getField(#trim); Expect.equals("trim-true", f.invoke(#call, [], {#named: true}).reflectee); @@ -118,16 +128,24 @@ main() { f = getAMirror().getField(#endsWith); Expect.equals( - "endsWith-42", f.invoke(#call, [42], {}).reflectee); + "endsWith-42", + f.invoke(#call, [42], {}).reflectee, + ); f = getAMirror().getField(#toLowerCase); Expect.equals( - "toLowerCase", f.invoke(#call, [], {}).reflectee); + "toLowerCase", + f.invoke(#call, [], {}).reflectee, + ); f = getAMirror().getField(#indexOf); Expect.equals( - "indexOf-499", f.invoke(#call, [499], {}).reflectee); + "indexOf-499", + f.invoke(#call, [499], {}).reflectee, + ); f = getAMirror().getField(#matchAsPrefix); Expect.equals( - "matchAsPrefix-FOO,BAR", f.invoke(#call, ["FOO", "BAR"]).reflectee); + "matchAsPrefix-FOO,BAR", + f.invoke(#call, ["FOO", "BAR"]).reflectee, + ); f = getAMirror().getField(#toList); Expect.equals("toList-1", f.invoke(#call, [], {#growable: 1}).reflectee); f = getAMirror().getField(#toSet); diff --git a/tests/lib/mirrors/invoke_import_test.dart b/tests/lib/mirrors/invoke_import_test.dart index 7b41c551cc7..ef202065d82 100644 --- a/tests/lib/mirrors/invoke_import_test.dart +++ b/tests/lib/mirrors/invoke_import_test.dart @@ -10,26 +10,32 @@ import 'package:expect/expect.dart'; import 'other_library.dart'; main() { - LibraryMirror thisLibrary = - currentMirrorSystem().findLibrary(#test.invoke_import_test); + LibraryMirror thisLibrary = currentMirrorSystem().findLibrary( + #test.invoke_import_test, + ); Expect.throwsNoSuchMethodError( - () => thisLibrary.invoke(#topLevelMethod, []), - 'Should not invoke imported method #topLevelMethod'); + () => thisLibrary.invoke(#topLevelMethod, []), + 'Should not invoke imported method #topLevelMethod', + ); Expect.throwsNoSuchMethodError( - () => thisLibrary.getField(#topLevelGetter), - 'Should not invoke imported getter #topLevelGetter'); + () => thisLibrary.getField(#topLevelGetter), + 'Should not invoke imported getter #topLevelGetter', + ); Expect.throwsNoSuchMethodError( - () => thisLibrary.getField(#topLevelField), - 'Should not invoke imported field #topLevelField'); + () => thisLibrary.getField(#topLevelField), + 'Should not invoke imported field #topLevelField', + ); Expect.throwsNoSuchMethodError( - () => thisLibrary.setField(#topLevelSetter, 23), - 'Should not invoke imported setter #topLevelSetter'); + () => thisLibrary.setField(#topLevelSetter, 23), + 'Should not invoke imported setter #topLevelSetter', + ); Expect.throwsNoSuchMethodError( - () => thisLibrary.setField(#topLevelField, 23), - 'Should not invoke imported field #topLevelField'); + () => thisLibrary.setField(#topLevelField, 23), + 'Should not invoke imported field #topLevelField', + ); } diff --git a/tests/lib/mirrors/invoke_private_wrong_library_test.dart b/tests/lib/mirrors/invoke_private_wrong_library_test.dart index b3fd966408f..6defe9a2a37 100644 --- a/tests/lib/mirrors/invoke_private_wrong_library_test.dart +++ b/tests/lib/mirrors/invoke_private_wrong_library_test.dart @@ -32,7 +32,8 @@ main() { LibraryMirror lm = cm.owner as LibraryMirror; Expect.throwsNoSuchMethodError( - () => lm.invoke(#_libraryFunction, [':', ')'])); + () => lm.invoke(#_libraryFunction, [':', ')']), + ); Expect.throwsNoSuchMethodError(() => lm.getField(#_libraryGetter)); Expect.throwsNoSuchMethodError(() => lm.getField(#_libraryField)); Expect.throwsNoSuchMethodError(() => lm.setField(#_librarySetter, 'lfoo')); diff --git a/tests/lib/mirrors/invoke_test.dart b/tests/lib/mirrors/invoke_test.dart index fd5215fd6ec..187e8ca01bb 100644 --- a/tests/lib/mirrors/invoke_test.dart +++ b/tests/lib/mirrors/invoke_test.dart @@ -71,9 +71,13 @@ testSync() { result = cm.invoke(const Symbol('staticFunction'), [3, 4]); Expect.equals('(3,4)', result.reflectee); Expect.throwsNoSuchMethodError( - () => cm.invoke(const Symbol('doesntExist'), [3, 4]), 'Not defined'); + () => cm.invoke(const Symbol('doesntExist'), [3, 4]), + 'Not defined', + ); Expect.throwsNoSuchMethodError( - () => cm.invoke(const Symbol('staticFunction'), [3]), 'Wrong arity'); + () => cm.invoke(const Symbol('staticFunction'), [3]), + 'Wrong arity', + ); // ClassMirror invokeGetter result = cm.getField(const Symbol('staticGetter')); @@ -81,20 +85,26 @@ testSync() { result = cm.getField(const Symbol('staticField')); Expect.equals('initial', result.reflectee); Expect.throwsNoSuchMethodError( - () => cm.getField(const Symbol('doesntExist')), 'Not defined'); + () => cm.getField(const Symbol('doesntExist')), + 'Not defined', + ); // ClassMirror invokeSetter result = cm.setField(const Symbol('staticSetter'), 'sfoo'); Expect.equals('sfoo', result.reflectee); Expect.equals('sset sfoo', C.staticField); Expect.equals( - 'sset sfoo', cm.getField(const Symbol('staticField')).reflectee); + 'sset sfoo', + cm.getField(const Symbol('staticField')).reflectee, + ); result = cm.setField(const Symbol('staticField'), 'sbar'); Expect.equals('sbar', result.reflectee); Expect.equals('sbar', C.staticField); Expect.equals('sbar', cm.getField(const Symbol('staticField')).reflectee); Expect.throwsNoSuchMethodError( - () => cm.setField(const Symbol('doesntExist'), 'sbar'), 'Not defined'); + () => cm.setField(const Symbol('doesntExist'), 'sbar'), + 'Not defined', + ); // ClassMirror invokeConstructor result = cm.newInstance(Symbol.empty, []); @@ -104,19 +114,26 @@ testSync() { Expect.isTrue(result.reflectee is C); Expect.equals('my value', result.reflectee.field); Expect.throwsNoSuchMethodError( - () => cm.newInstance(const Symbol('doesntExist'), ['my value']), - 'Not defined'); + () => cm.newInstance(const Symbol('doesntExist'), ['my value']), + 'Not defined', + ); Expect.throwsNoSuchMethodError( - () => cm.newInstance(const Symbol('named'), []), 'Wrong arity'); + () => cm.newInstance(const Symbol('named'), []), + 'Wrong arity', + ); // LibraryMirror invoke LibraryMirror lm = cm.owner as LibraryMirror; result = lm.invoke(const Symbol('libraryFunction'), [':', ')']); Expect.equals(':)', result.reflectee); Expect.throwsNoSuchMethodError( - () => lm.invoke(const Symbol('doesntExist'), [':', ')']), 'Not defined'); + () => lm.invoke(const Symbol('doesntExist'), [':', ')']), + 'Not defined', + ); Expect.throwsNoSuchMethodError( - () => lm.invoke(const Symbol('libraryFunction'), [':']), 'Wrong arity'); + () => lm.invoke(const Symbol('libraryFunction'), [':']), + 'Wrong arity', + ); // LibraryMirror invokeGetter result = lm.getField(const Symbol('libraryGetter')); @@ -124,20 +141,26 @@ testSync() { result = lm.getField(const Symbol('libraryField')); Expect.equals('a priori', result.reflectee); Expect.throwsNoSuchMethodError( - () => lm.getField(const Symbol('doesntExist')), 'Not defined'); + () => lm.getField(const Symbol('doesntExist')), + 'Not defined', + ); // LibraryMirror invokeSetter result = lm.setField(const Symbol('librarySetter'), 'lfoo'); Expect.equals('lfoo', result.reflectee); Expect.equals('lset lfoo', libraryField); Expect.equals( - 'lset lfoo', lm.getField(const Symbol('libraryField')).reflectee); + 'lset lfoo', + lm.getField(const Symbol('libraryField')).reflectee, + ); result = lm.setField(const Symbol('libraryField'), 'lbar'); Expect.equals('lbar', result.reflectee); Expect.equals('lbar', libraryField); Expect.equals('lbar', lm.getField(const Symbol('libraryField')).reflectee); Expect.throwsNoSuchMethodError( - () => lm.setField(const Symbol('doesntExist'), 'lbar'), 'Not defined'); + () => lm.setField(const Symbol('doesntExist'), 'lbar'), + 'Not defined', + ); } main() { diff --git a/tests/lib/mirrors/issue21079_test.dart b/tests/lib/mirrors/issue21079_test.dart index f4914835a08..bab9a34e95e 100644 --- a/tests/lib/mirrors/issue21079_test.dart +++ b/tests/lib/mirrors/issue21079_test.dart @@ -8,7 +8,8 @@ import "package:expect/expect.dart"; void main() { Expect.isTrue( - reflectClass(MyException).superclass!.reflectedType == FormatException); + reflectClass(MyException).superclass!.reflectedType == FormatException, + ); Expect.isTrue(reflectClass(FormatException).reflectedType == FormatException); } diff --git a/tests/lib/mirrors/lazy_static_test.dart b/tests/lib/mirrors/lazy_static_test.dart index 65ac90929d9..67dfea8c8c1 100644 --- a/tests/lib/mirrors/lazy_static_test.dart +++ b/tests/lib/mirrors/lazy_static_test.dart @@ -11,15 +11,14 @@ import 'package:expect/expect.dart'; import 'stringify.dart'; class Foo { - static dynamic hello = { - 'a': 'b', - 'c': 'd', - }; + static dynamic hello = {'a': 'b', 'c': 'd'}; } void main() { - expect('Variable(s(hello) in s(Foo), static)', - reflectClass(Foo).declarations[#hello]); + expect( + 'Variable(s(hello) in s(Foo), static)', + reflectClass(Foo).declarations[#hello], + ); var reflectee = reflectClass(Foo).getField(#hello).reflectee; Expect.stringEquals('a, c', reflectee.keys.join(', ')); // Call the lazy getter twice as different things probably happen in the diff --git a/tests/lib/mirrors/libraries_test.dart b/tests/lib/mirrors/libraries_test.dart index 80d47363633..cf37b0bd31c 100644 --- a/tests/lib/mirrors/libraries_test.dart +++ b/tests/lib/mirrors/libraries_test.dart @@ -19,8 +19,9 @@ main() { LibraryMirror? mirrorsLibrary = libraries[Uri.parse('dart:mirrors')]; if (mirrorsLibrary == null) { // In minified mode we don't preserve the URIs. - mirrorsLibrary = libraries.values - .firstWhere((LibraryMirror lm) => lm.simpleName == #dart.mirrors); + mirrorsLibrary = libraries.values.firstWhere( + (LibraryMirror lm) => lm.simpleName == #dart.mirrors, + ); Uri uri = mirrorsLibrary.uri; Expect.equals("https", uri.scheme); Expect.equals("dartlang.org", uri.host); diff --git a/tests/lib/mirrors/library_enumeration_deferred_loading_test.dart b/tests/lib/mirrors/library_enumeration_deferred_loading_test.dart index 8025483ab9a..a75dbc230d8 100644 --- a/tests/lib/mirrors/library_enumeration_deferred_loading_test.dart +++ b/tests/lib/mirrors/library_enumeration_deferred_loading_test.dart @@ -12,8 +12,11 @@ import 'other_library.dart' deferred as other; main() { var ms = currentMirrorSystem(); - Expect.throws(() => ms.findLibrary(#test.other_library), (e) => true, - "should not be loaded yet"); + Expect.throws( + () => ms.findLibrary(#test.other_library), + (e) => true, + "should not be loaded yet", + ); asyncStart(); other.loadLibrary().then((_) { diff --git a/tests/lib/mirrors/library_exports_hidden_test.dart b/tests/lib/mirrors/library_exports_hidden_test.dart index e69fef4e431..0abc44801c2 100644 --- a/tests/lib/mirrors/library_exports_hidden_test.dart +++ b/tests/lib/mirrors/library_exports_hidden_test.dart @@ -16,17 +16,21 @@ test(MirrorSystem mirrors) { LibraryMirror b = mirrors.findLibrary(#library_imports_b); LibraryMirror core = mirrors.findLibrary(#dart.core); - Expect.setEquals( - [a, b, core], hidden.libraryDependencies.map((dep) => dep.targetLibrary)); + Expect.setEquals([ + a, + b, + core, + ], hidden.libraryDependencies.map((dep) => dep.targetLibrary)); Expect.stringEquals( - 'import dart.core\n' - 'export library_imports_a\n' - ' hide somethingFromA\n' - ' hide somethingFromBoth\n' - 'export library_imports_b\n' - ' hide somethingFromB\n', - stringifyDependencies(hidden)); + 'import dart.core\n' + 'export library_imports_a\n' + ' hide somethingFromA\n' + ' hide somethingFromBoth\n' + 'export library_imports_b\n' + ' hide somethingFromB\n', + stringifyDependencies(hidden), + ); } main() { diff --git a/tests/lib/mirrors/library_exports_shown_test.dart b/tests/lib/mirrors/library_exports_shown_test.dart index 003de2fce05..31155623f3e 100644 --- a/tests/lib/mirrors/library_exports_shown_test.dart +++ b/tests/lib/mirrors/library_exports_shown_test.dart @@ -17,17 +17,21 @@ test(MirrorSystem mirrors) { LibraryMirror core = mirrors.findLibrary(#dart.core); - Expect.setEquals( - [a, b, core], shown.libraryDependencies.map((dep) => dep.targetLibrary)); + Expect.setEquals([ + a, + b, + core, + ], shown.libraryDependencies.map((dep) => dep.targetLibrary)); Expect.stringEquals( - 'import dart.core\n' - 'export library_imports_a\n' - ' show somethingFromA\n' - ' show somethingFromBoth\n' - 'export library_imports_b\n' - ' show somethingFromB\n', - stringifyDependencies(shown)); + 'import dart.core\n' + 'export library_imports_a\n' + ' show somethingFromA\n' + ' show somethingFromBoth\n' + 'export library_imports_b\n' + ' show somethingFromB\n', + stringifyDependencies(shown), + ); } main() { diff --git a/tests/lib/mirrors/library_import_deferred_loading_test.dart b/tests/lib/mirrors/library_import_deferred_loading_test.dart index e713d441f6a..8c8ef87777f 100644 --- a/tests/lib/mirrors/library_import_deferred_loading_test.dart +++ b/tests/lib/mirrors/library_import_deferred_loading_test.dart @@ -14,8 +14,9 @@ import 'other_library.dart' deferred as other; main() { var ms = currentMirrorSystem(); LibraryMirror thisLibrary = ms.findLibrary(#library_loading_deferred_loading); - LibraryDependencyMirror dep = - thisLibrary.libraryDependencies.singleWhere((d) => d.prefix == #other); + LibraryDependencyMirror dep = thisLibrary.libraryDependencies.singleWhere( + (d) => d.prefix == #other, + ); Expect.isNull(dep.targetLibrary, "should not be loaded yet"); asyncStart(); diff --git a/tests/lib/mirrors/library_imports_deferred_test.dart b/tests/lib/mirrors/library_imports_deferred_test.dart index 1d28248cc75..ba850928c45 100644 --- a/tests/lib/mirrors/library_imports_deferred_test.dart +++ b/tests/lib/mirrors/library_imports_deferred_test.dart @@ -12,29 +12,34 @@ import 'dart:math' as eagermath; import 'dart:math' deferred as lazymath; test(MirrorSystem mirrors) { - LibraryMirror thisLibrary = - mirrors.findLibrary(#test.library_imports_deferred); + LibraryMirror thisLibrary = mirrors.findLibrary( + #test.library_imports_deferred, + ); LibraryMirror math = mirrors.findLibrary(#dart.math); var importsOfCollection = thisLibrary.libraryDependencies .where((dep) => dep.targetLibrary == math) .toList(); Expect.equals(2, importsOfCollection.length); - Expect.notEquals(importsOfCollection[0].isDeferred, - importsOfCollection[1].isDeferred); // One deferred, one not. + Expect.notEquals( + importsOfCollection[0].isDeferred, + importsOfCollection[1].isDeferred, + ); // One deferred, one not. // Only math is defer-imported. - LibraryDependencyMirror dep = - thisLibrary.libraryDependencies.singleWhere((dep) => dep.isDeferred); + LibraryDependencyMirror dep = thisLibrary.libraryDependencies.singleWhere( + (dep) => dep.isDeferred, + ); Expect.equals(math, dep.targetLibrary); Expect.stringEquals( - 'import dart.math as eagermath\n' - 'import dart.math deferred as lazymath\n' - 'import dart.mirrors\n' - 'import expect\n' - 'import test.stringify\n', - stringifyDependencies(thisLibrary)); + 'import dart.math as eagermath\n' + 'import dart.math deferred as lazymath\n' + 'import dart.mirrors\n' + 'import expect\n' + 'import test.stringify\n', + stringifyDependencies(thisLibrary), + ); } main() { diff --git a/tests/lib/mirrors/library_imports_hidden_test.dart b/tests/lib/mirrors/library_imports_hidden_test.dart index edc19e077aa..1655ca400aa 100644 --- a/tests/lib/mirrors/library_imports_hidden_test.dart +++ b/tests/lib/mirrors/library_imports_hidden_test.dart @@ -16,17 +16,21 @@ test(MirrorSystem mirrors) { LibraryMirror b = mirrors.findLibrary(#library_imports_b); LibraryMirror core = mirrors.findLibrary(#dart.core); - Expect.setEquals( - [a, b, core], hidden.libraryDependencies.map((dep) => dep.targetLibrary)); + Expect.setEquals([ + a, + b, + core, + ], hidden.libraryDependencies.map((dep) => dep.targetLibrary)); Expect.stringEquals( - 'import dart.core\n' - 'import library_imports_a\n' - ' hide somethingFromA\n' - ' hide somethingFromBoth\n' - 'import library_imports_b\n' - ' hide somethingFromB\n', - stringifyDependencies(hidden)); + 'import dart.core\n' + 'import library_imports_a\n' + ' hide somethingFromA\n' + ' hide somethingFromBoth\n' + 'import library_imports_b\n' + ' hide somethingFromB\n', + stringifyDependencies(hidden), + ); } main() { diff --git a/tests/lib/mirrors/library_imports_metadata_test.dart b/tests/lib/mirrors/library_imports_metadata_test.dart index ab1c15d66a2..613e4fad50d 100644 --- a/tests/lib/mirrors/library_imports_metadata_test.dart +++ b/tests/lib/mirrors/library_imports_metadata_test.dart @@ -11,46 +11,57 @@ import 'stringify.dart'; import 'library_imports_metadata.dart'; main() { - LibraryMirror lib = - currentMirrorSystem().findLibrary(#library_imports_metadata); + LibraryMirror lib = currentMirrorSystem().findLibrary( + #library_imports_metadata, + ); LibraryMirror core = currentMirrorSystem().findLibrary(#dart.core); LibraryMirror mirrors = currentMirrorSystem().findLibrary(#dart.mirrors); - LibraryMirror collection = - currentMirrorSystem().findLibrary(#dart.collection); + LibraryMirror collection = currentMirrorSystem().findLibrary( + #dart.collection, + ); LibraryMirror async = currentMirrorSystem().findLibrary(#dart.async); - Expect.setEquals([core, mirrors, collection, async], - lib.libraryDependencies.map((dep) => dep.targetLibrary)); + Expect.setEquals([ + core, + mirrors, + collection, + async, + ], lib.libraryDependencies.map((dep) => dep.targetLibrary)); Expect.stringEquals( - 'import dart.async\n' - 'import dart.collection\n' - 'import dart.core\n' - 'import dart.mirrors as mirrors\n', - stringifyDependencies(lib)); + 'import dart.async\n' + 'import dart.collection\n' + 'import dart.core\n' + 'import dart.mirrors as mirrors\n', + stringifyDependencies(lib), + ); Expect.listEquals( - [].map(reflect).toList(), - lib.libraryDependencies - .singleWhere((dep) => dep.targetLibrary == core) - .metadata); + [].map(reflect).toList(), + lib.libraryDependencies + .singleWhere((dep) => dep.targetLibrary == core) + .metadata, + ); Expect.listEquals( - [m1].map(reflect).toList(), - lib.libraryDependencies - .singleWhere((dep) => dep.targetLibrary == mirrors) - .metadata); + [m1].map(reflect).toList(), + lib.libraryDependencies + .singleWhere((dep) => dep.targetLibrary == mirrors) + .metadata, + ); Expect.listEquals( - [m2, m3].map(reflect).toList(), - lib.libraryDependencies - .singleWhere((dep) => dep.targetLibrary == collection) - .metadata); + [m2, m3].map(reflect).toList(), + lib.libraryDependencies + .singleWhere((dep) => dep.targetLibrary == collection) + .metadata, + ); Expect.listEquals( - [].map(reflect).toList(), - lib.libraryDependencies - .singleWhere((dep) => dep.targetLibrary == async) - .metadata); + [].map(reflect).toList(), + lib.libraryDependencies + .singleWhere((dep) => dep.targetLibrary == async) + .metadata, + ); } diff --git a/tests/lib/mirrors/library_imports_prefixed_show_hide_test.dart b/tests/lib/mirrors/library_imports_prefixed_show_hide_test.dart index a4089c0c81e..ec8bb285d1f 100644 --- a/tests/lib/mirrors/library_imports_prefixed_show_hide_test.dart +++ b/tests/lib/mirrors/library_imports_prefixed_show_hide_test.dart @@ -11,22 +11,27 @@ import 'stringify.dart'; import 'library_imports_prefixed_show_hide.dart'; test(MirrorSystem mirrors) { - LibraryMirror prefixed_show_hide = - mirrors.findLibrary(#library_imports_prefixed_show_hide); + LibraryMirror prefixed_show_hide = mirrors.findLibrary( + #library_imports_prefixed_show_hide, + ); LibraryMirror a = mirrors.findLibrary(#library_imports_a); LibraryMirror b = mirrors.findLibrary(#library_imports_b); LibraryMirror core = mirrors.findLibrary(#dart.core); - Expect.setEquals([a, b, core], - prefixed_show_hide.libraryDependencies.map((dep) => dep.targetLibrary)); + Expect.setEquals([ + a, + b, + core, + ], prefixed_show_hide.libraryDependencies.map((dep) => dep.targetLibrary)); Expect.stringEquals( - 'import dart.core\n' - 'import library_imports_a as prefixa\n' - ' show somethingFromA\n' - 'import library_imports_b as prefixb\n' - ' hide somethingFromB\n', - stringifyDependencies(prefixed_show_hide)); + 'import dart.core\n' + 'import library_imports_a as prefixa\n' + ' show somethingFromA\n' + 'import library_imports_b as prefixb\n' + ' hide somethingFromB\n', + stringifyDependencies(prefixed_show_hide), + ); } main() { diff --git a/tests/lib/mirrors/library_imports_prefixed_test.dart b/tests/lib/mirrors/library_imports_prefixed_test.dart index 7915fae49ed..bc9e1ea37b4 100644 --- a/tests/lib/mirrors/library_imports_prefixed_test.dart +++ b/tests/lib/mirrors/library_imports_prefixed_test.dart @@ -16,14 +16,18 @@ test(MirrorSystem mirrors) { LibraryMirror b = mirrors.findLibrary(#library_imports_b); LibraryMirror core = mirrors.findLibrary(#dart.core); - Expect.setEquals([a, b, core], - prefixed.libraryDependencies.map((dep) => dep.targetLibrary)); + Expect.setEquals([ + a, + b, + core, + ], prefixed.libraryDependencies.map((dep) => dep.targetLibrary)); Expect.stringEquals( - 'import dart.core\n' - 'import library_imports_a as prefixa\n' - 'import library_imports_b as prefixb\n', - stringifyDependencies(prefixed)); + 'import dart.core\n' + 'import library_imports_a as prefixa\n' + 'import library_imports_b as prefixb\n', + stringifyDependencies(prefixed), + ); } main() { diff --git a/tests/lib/mirrors/library_imports_shown_test.dart b/tests/lib/mirrors/library_imports_shown_test.dart index 44086e21f8b..d641aec8803 100644 --- a/tests/lib/mirrors/library_imports_shown_test.dart +++ b/tests/lib/mirrors/library_imports_shown_test.dart @@ -16,17 +16,21 @@ test(MirrorSystem mirrors) { LibraryMirror b = mirrors.findLibrary(#library_imports_b); LibraryMirror core = mirrors.findLibrary(#dart.core); - Expect.setEquals( - [a, b, core], shown.libraryDependencies.map((dep) => dep.targetLibrary)); + Expect.setEquals([ + a, + b, + core, + ], shown.libraryDependencies.map((dep) => dep.targetLibrary)); Expect.stringEquals( - 'import dart.core\n' - 'import library_imports_a\n' - ' show somethingFromA\n' - ' show somethingFromBoth\n' - 'import library_imports_b\n' - ' show somethingFromB\n', - stringifyDependencies(shown)); + 'import dart.core\n' + 'import library_imports_a\n' + ' show somethingFromA\n' + ' show somethingFromBoth\n' + 'import library_imports_b\n' + ' show somethingFromB\n', + stringifyDependencies(shown), + ); } main() { diff --git a/tests/lib/mirrors/library_metadata_test.dart b/tests/lib/mirrors/library_metadata_test.dart index 2a85166806c..72bedd0114d 100644 --- a/tests/lib/mirrors/library_metadata_test.dart +++ b/tests/lib/mirrors/library_metadata_test.dart @@ -12,7 +12,9 @@ import 'metadata_test.dart'; main() { MirrorSystem mirrors = currentMirrorSystem(); - checkMetadata( - mirrors.findLibrary(#test.library_metadata_test), [string, symbol]); + checkMetadata(mirrors.findLibrary(#test.library_metadata_test), [ + string, + symbol, + ]); checkMetadata(mirrors.findLibrary(#test.metadata_test), []); } diff --git a/tests/lib/mirrors/library_uri_io_test.dart b/tests/lib/mirrors/library_uri_io_test.dart index a4010c1636b..88f88189eff 100644 --- a/tests/lib/mirrors/library_uri_io_test.dart +++ b/tests/lib/mirrors/library_uri_io_test.dart @@ -24,8 +24,10 @@ main() { var mirrors = currentMirrorSystem(); test("Test current library uri", () { if (!Platform.script.toString().endsWith('.dart')) { - print("Skipping library uri test as not running from source " - "(Platform.script = ${Platform.script})"); + print( + "Skipping library uri test as not running from source " + "(Platform.script = ${Platform.script})", + ); return; } Uri uri = Uri.base.resolveUri(Platform.script); diff --git a/tests/lib/mirrors/library_uri_package_test.dart b/tests/lib/mirrors/library_uri_package_test.dart index 9dabf4fca29..6a32d4ef73b 100644 --- a/tests/lib/mirrors/library_uri_package_test.dart +++ b/tests/lib/mirrors/library_uri_package_test.dart @@ -26,6 +26,8 @@ main() { var mirrors = currentMirrorSystem(); test("Test package library uri", () { testLibraryUri( - ExpectException(""), Uri.parse('package:expect/expect.dart')); + ExpectException(""), + Uri.parse('package:expect/expect.dart'), + ); }); } diff --git a/tests/lib/mirrors/load_library_test.dart b/tests/lib/mirrors/load_library_test.dart index b06bc5f2ac4..db8324f42ed 100644 --- a/tests/lib/mirrors/load_library_test.dart +++ b/tests/lib/mirrors/load_library_test.dart @@ -13,8 +13,9 @@ import 'other_library.dart' deferred as other; main() { var ms = currentMirrorSystem(); LibraryMirror thisLibrary = ms.findLibrary(#load_library); - var dep = - thisLibrary.libraryDependencies.singleWhere((d) => d.prefix == #other); + var dep = thisLibrary.libraryDependencies.singleWhere( + (d) => d.prefix == #other, + ); Expect.isNull(dep.targetLibrary, "should not be loaded yet"); asyncStart(); diff --git a/tests/lib/mirrors/local_function_is_static_test.dart b/tests/lib/mirrors/local_function_is_static_test.dart index 131fb757507..e32fe5987c2 100644 --- a/tests/lib/mirrors/local_function_is_static_test.dart +++ b/tests/lib/mirrors/local_function_is_static_test.dart @@ -8,13 +8,16 @@ import 'dart:mirrors'; import 'package:expect/expect.dart'; topLevel() => 1; -topLevelLocal() => () => 2; +topLevelLocal() => + () => 2; class C { static klass() => 3; - static klassLocal() => () => 4; + static klassLocal() => + () => 4; instance() => 5; - instanceLocal() => () => 6; + instanceLocal() => + () => 6; } main() { diff --git a/tests/lib/mirrors/method_mirror_extension_type_test.dart b/tests/lib/mirrors/method_mirror_extension_type_test.dart index 601ee3d4a9c..68d0209f14b 100644 --- a/tests/lib/mirrors/method_mirror_extension_type_test.dart +++ b/tests/lib/mirrors/method_mirror_extension_type_test.dart @@ -27,7 +27,10 @@ checkIsExtensionTypeMember(closure, kind, simpleName) { var methodMirror = closureMirror.function; Expect.equals(Symbol(simpleName), methodMirror.simpleName); Expect.equals( - kind, methodMirror.isExtensionTypeMember, "isExtensionTypeMember"); + kind, + methodMirror.isExtensionTypeMember, + "isExtensionTypeMember", + ); } String? getExtensionTypeName(sym) { @@ -46,21 +49,34 @@ void testExtensionTypeMembers(sym, mirror) { final methodMirror = mirror as MethodMirror; if (extensionTypeName != null) { Expect.equals( - true, methodMirror.isExtensionTypeMember, "isExtensionTypeMember"); + true, + methodMirror.isExtensionTypeMember, + "isExtensionTypeMember", + ); Expect.isTrue( - methodMirror.simpleName.toString().contains('$extensionTypeName.')); + methodMirror.simpleName.toString().contains('$extensionTypeName.'), + ); } else { Expect.equals( - false, methodMirror.isExtensionTypeMember, "isExtensionTypeMember"); + false, + methodMirror.isExtensionTypeMember, + "isExtensionTypeMember", + ); } } else if (mirror is VariableMirror) { var variableMirror = mirror as VariableMirror; if (extensionTypeName != null) { Expect.equals( - true, variableMirror.isExtensionTypeMember, "isExtensionTypeMember"); + true, + variableMirror.isExtensionTypeMember, + "isExtensionTypeMember", + ); } else { Expect.equals( - false, variableMirror.isExtensionTypeMember, "isExtensionTypeMember"); + false, + variableMirror.isExtensionTypeMember, + "isExtensionTypeMember", + ); } } } diff --git a/tests/lib/mirrors/method_mirror_location_other.dart b/tests/lib/mirrors/method_mirror_location_other.dart index 3643cdfa7ed..c79b9bc108b 100644 --- a/tests/lib/mirrors/method_mirror_location_other.dart +++ b/tests/lib/mirrors/method_mirror_location_other.dart @@ -2,6 +2,9 @@ // 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. +// Don't let the formatter change the location of things. +// dart format off + part of test.method_location; class ClassInOtherFile { diff --git a/tests/lib/mirrors/method_mirror_location_test.dart b/tests/lib/mirrors/method_mirror_location_test.dart index b4d833fb46a..6be98f9d2b7 100644 --- a/tests/lib/mirrors/method_mirror_location_test.dart +++ b/tests/lib/mirrors/method_mirror_location_test.dart @@ -2,6 +2,9 @@ // 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. +// Don't let the formatter change the location of things. +// dart format off + library test.method_location; import "dart:mirrors"; @@ -21,13 +24,15 @@ expectLocation(Mirror mirror, String uriSuffix, int line, int column) { Expect.isTrue(methodMirror is MethodMirror); final location = methodMirror.location!; final uri = location.sourceUri; - Expect.isTrue(uri.toString().endsWith(uriSuffix), "Expected suffix $uriSuffix in $uri"); + Expect.isTrue( + uri.toString().endsWith(uriSuffix), + "Expected suffix $uriSuffix in $uri", + ); Expect.equals(line, location.line, "line"); Expect.equals(column, location.column, "column"); } class ClassInMainFile { - ClassInMainFile(); method() {} @@ -50,28 +55,47 @@ main() { String otherSuffix = 'method_mirror_location_other.dart'; // This file. - expectLocation(reflectClass(ClassInMainFile).declarations[#ClassInMainFile]!, - mainSuffix, 31, 3); expectLocation( - reflectClass(ClassInMainFile).declarations[#method]!, mainSuffix, 33, 3); - expectLocation(reflect(topLevelInMainFile), mainSuffix, 36, 1); - expectLocation(reflect(spaceIndentedInMainFile), mainSuffix, 37, 3); - expectLocation(reflect(tabIndentedInMainFile), mainSuffix, 38, 2); - expectLocation(reflect(localFunction), mainSuffix, 45, 3); + reflectClass(ClassInMainFile).declarations[#ClassInMainFile]!, + mainSuffix, + 36, + 3, + ); + expectLocation( + reflectClass(ClassInMainFile).declarations[#method]!, + mainSuffix, + 38, + 3, + ); + expectLocation(reflect(topLevelInMainFile), mainSuffix, 41, 1); + expectLocation(reflect(spaceIndentedInMainFile), mainSuffix, 42, 3); + expectLocation(reflect(tabIndentedInMainFile), mainSuffix, 43, 2); + expectLocation(reflect(localFunction), mainSuffix, 50, 3); // Another part. - expectLocation(reflectClass(ClassInOtherFile).declarations[#ClassInOtherFile]!, - otherSuffix, 8, 3); expectLocation( - reflectClass(ClassInOtherFile).declarations[#method]!, otherSuffix, 10, 3); - expectLocation(reflect(topLevelInOtherFile), otherSuffix, 13, 1); - expectLocation(reflect(spaceIndentedInOtherFile), otherSuffix, 15, 3); - expectLocation(reflect(tabIndentedInOtherFile), otherSuffix, 17, 2); + reflectClass(ClassInOtherFile).declarations[#ClassInOtherFile]!, + otherSuffix, + 11, + 3, + ); + expectLocation( + reflectClass(ClassInOtherFile).declarations[#method]!, + otherSuffix, + 13, + 3, + ); + expectLocation(reflect(topLevelInOtherFile), otherSuffix, 16, 1); + expectLocation(reflect(spaceIndentedInOtherFile), otherSuffix, 18, 3); + expectLocation(reflect(tabIndentedInOtherFile), otherSuffix, 20, 2); // Synthetic methods. - Expect.isNull(reflectClass(HasImplicitConstructor) - .declarations[#HasImplicitConstructor]! - .location); Expect.isNull( - (reflectType(Predicate) as TypedefMirror).referent.callMethod.location); + reflectClass( + HasImplicitConstructor, + ).declarations[#HasImplicitConstructor]!.location, + ); + Expect.isNull( + (reflectType(Predicate) as TypedefMirror).referent.callMethod.location, + ); } diff --git a/tests/lib/mirrors/method_mirror_name_test.dart b/tests/lib/mirrors/method_mirror_name_test.dart index c428da72f3b..ff937526d39 100644 --- a/tests/lib/mirrors/method_mirror_name_test.dart +++ b/tests/lib/mirrors/method_mirror_name_test.dart @@ -15,5 +15,7 @@ main() { // Regression test for http://www.dartbug.com/6335 var closureMirror = reflect(doNothing42) as ClosureMirror; Expect.equals( - stringifySymbol(closureMirror.function.simpleName), "s(doNothing42)"); + stringifySymbol(closureMirror.function.simpleName), + "s(doNothing42)", + ); } diff --git a/tests/lib/mirrors/method_mirror_properties_test.dart b/tests/lib/mirrors/method_mirror_properties_test.dart index e84c85786ea..24fd4059308 100644 --- a/tests/lib/mirrors/method_mirror_properties_test.dart +++ b/tests/lib/mirrors/method_mirror_properties_test.dart @@ -51,30 +51,85 @@ main() { var closureMirror = reflect(doNothing42) as ClosureMirror; checkKinds(closureMirror.function, [true, false, false, false, false]); var libraryMirror = reflectClass(C).owner as LibraryMirror; - checkKinds(libraryMirror.declarations[#topGetter], - [true, false, true, false, false]); - checkKinds(libraryMirror.declarations[const Symbol("topSetter=")], - [true, false, false, true, false]); + checkKinds(libraryMirror.declarations[#topGetter], [ + true, + false, + true, + false, + false, + ]); + checkKinds(libraryMirror.declarations[const Symbol("topSetter=")], [ + true, + false, + false, + true, + false, + ]); var classMirror; classMirror = reflectClass(C); - checkKinds( - classMirror.declarations[#foo], [true, false, false, false, false]); - checkKinds( - classMirror.declarations[#priv], [false, false, true, false, false]); - checkKinds(classMirror.declarations[const Symbol("priv=")], - [false, false, false, true, false]); + checkKinds(classMirror.declarations[#foo], [ + true, + false, + false, + false, + false, + ]); + checkKinds(classMirror.declarations[#priv], [ + false, + false, + true, + false, + false, + ]); + checkKinds(classMirror.declarations[const Symbol("priv=")], [ + false, + false, + false, + true, + false, + ]); checkKinds(classMirror.declarations[#C], [false, false, false, false, true]); - checkKinds( - classMirror.declarations[#C.other], [false, false, false, false, true]); - checkKinds( - classMirror.declarations[#C.other2], [false, false, false, false, true]); + checkKinds(classMirror.declarations[#C.other], [ + false, + false, + false, + false, + true, + ]); + checkKinds(classMirror.declarations[#C.other2], [ + false, + false, + false, + false, + true, + ]); classMirror = reflectClass(AbstractC); - checkKinds( - classMirror.declarations[#AbstractC], [false, false, false, false, true]); - checkKinds( - classMirror.declarations[#bar], [false, true, false, false, false]); - checkKinds( - classMirror.declarations[#priv], [false, true, true, false, false]); - checkKinds(classMirror.declarations[const Symbol("priv=")], - [false, true, false, true, false]); + checkKinds(classMirror.declarations[#AbstractC], [ + false, + false, + false, + false, + true, + ]); + checkKinds(classMirror.declarations[#bar], [ + false, + true, + false, + false, + false, + ]); + checkKinds(classMirror.declarations[#priv], [ + false, + true, + true, + false, + false, + ]); + checkKinds(classMirror.declarations[const Symbol("priv=")], [ + false, + true, + false, + true, + false, + ]); } diff --git a/tests/lib/mirrors/method_mirror_source_line_ending_test.dart b/tests/lib/mirrors/method_mirror_source_line_ending_test.dart index 735151afa0b..4259367cbc4 100644 --- a/tests/lib/mirrors/method_mirror_source_line_ending_test.dart +++ b/tests/lib/mirrors/method_mirror_source_line_ending_test.dart @@ -21,11 +21,17 @@ main() { // Source includes line breaks. Expect.stringEquals( - 'multiLineLF(y) {\n return y + 1;\n}', sourceOf(multiLineLF)); + 'multiLineLF(y) {\n return y + 1;\n}', + sourceOf(multiLineLF), + ); Expect.stringEquals( - 'multiLineCR(y) {\r return y + 1;\r}', sourceOf(multiLineCR)); + 'multiLineCR(y) {\r return y + 1;\r}', + sourceOf(multiLineCR), + ); Expect.stringEquals( - 'multiLineCRLF(y) {\r\n return y + 1;\r\n}', sourceOf(multiLineCRLF)); + 'multiLineCRLF(y) {\r\n return y + 1;\r\n}', + sourceOf(multiLineCRLF), + ); // First and last characters separated from middle by line breaks. Expect.stringEquals('a\n(){\n}', sourceOf(a)); diff --git a/tests/lib/mirrors/method_mirror_source_test.dart b/tests/lib/mirrors/method_mirror_source_test.dart index 5657efa96bb..7e59f3a2aa4 100644 --- a/tests/lib/mirrors/method_mirror_source_test.dart +++ b/tests/lib/mirrors/method_mirror_source_test.dart @@ -23,18 +23,15 @@ foo1() {} doSomething(e) => e; int get x => 42; -set x(value) { } +set x(value) {} class S {} class C extends S { - var _x; var _y; - C(this._x, y) - : _y = y, - super(); + C(this._x, y) : _y = y, super(); factory C.other(num z) => C(z, z); factory C.other2() => C(0, 0); @@ -46,65 +43,79 @@ class C extends S { // Some comment. - void bar() { /* Not so happy bar. */ } + void bar() { + /* Not so happy bar. */ + } - num get someX => - 181; + num get someX => 181; set someX(v) { // Discard this one. } } - main() { // Top-level members LibraryMirror lib = reflectClass(C).owner as LibraryMirror; - expectSource(lib.declarations[#foo1]!, - "foo1() {}"); - expectSource(lib.declarations[#x]!, - "int get x => 42;"); - expectSource(lib.declarations[const Symbol("x=")]!, - "set x(value) { }"); + expectSource(lib.declarations[#foo1]!, "foo1() {}"); + expectSource(lib.declarations[#x]!, "int get x => 42;"); + expectSource(lib.declarations[const Symbol("x=")]!, "set x(value) {}"); // Class members ClassMirror cm = reflectClass(C); - expectSource(cm.declarations[#foo]!, - "static dynamic foo() {\n" - " // Happy foo.\n" - " }"); - expectSource(cm.declarations[#bar]!, - "void bar() { /* Not so happy bar. */ }"); - expectSource(cm.declarations[#someX]!, - "num get someX =>\n" - " 181;"); - expectSource(cm.declarations[const Symbol("someX=")]!, - "set someX(v) {\n" - " // Discard this one.\n" - " }"); - expectSource(cm.declarations[#C]!, - "C(this._x, y)\n" - " : _y = y,\n" - " super();"); - expectSource(cm.declarations[#C.other]!, - "factory C.other(num z) => C(z, z);"); - expectSource(cm.declarations[#C.other3]!, - "factory C.other3() = C.other2;"); + expectSource( + cm.declarations[#foo]!, + "static dynamic foo() {\n" + " // Happy foo.\n" + " }", + ); + expectSource( + cm.declarations[#bar]!, + "void bar() {\n" + " /* Not so happy bar. */\n" + " }", + ); + expectSource( + cm.declarations[#someX]!, + "num get someX => 181;", + ); + expectSource( + cm.declarations[const Symbol("someX=")]!, + "set someX(v) {\n" + " // Discard this one.\n" + " }", + ); + expectSource( + cm.declarations[#C]!, + "C(this._x, y) : _y = y, super();", + ); + expectSource( + cm.declarations[#C.other]!, + "factory C.other(num z) => C(z, z);", + ); + expectSource(cm.declarations[#C.other3]!, "factory C.other3() = C.other2;"); // Closures - expectSource(reflect((){}), "(){}"); - expectSource(reflect((x,y,z) { return x*y*z; }), "(x,y,z) { return x*y*z; }"); + expectSource(reflect(() {}), "() {}"); + expectSource( + reflect((x, y, z) { + return x * y * z; + }), + "(x, y, z) {\n" + " return x * y * z;\n" + " }", + ); expectSource(reflect((e) => doSomething(e)), "(e) => doSomething(e)"); - namedClosure(x,y,z) => 1; + namedClosure(x, y, z) => 1; var a = () {}; - expectSource(reflect(namedClosure), "namedClosure(x,y,z) => 1;"); + expectSource(reflect(namedClosure), "namedClosure(x, y, z) => 1;"); expectSource(reflect(a), "() {}"); // Function at first line. - LibraryMirror otherLib = reflectClass(SomethingInOther).owner as LibraryMirror; - expectSource(otherLib.declarations[#main]!, -"""main() { + LibraryMirror otherLib = + reflectClass(SomethingInOther).owner as LibraryMirror; + expectSource(otherLib.declarations[#main]!, """main() { print("Blah"); }"""); } diff --git a/tests/lib/mirrors/mirrors_nsm_mismatch_test.dart b/tests/lib/mirrors/mirrors_nsm_mismatch_test.dart index 2a3637bbdbe..c7baf30685c 100644 --- a/tests/lib/mirrors/mirrors_nsm_mismatch_test.dart +++ b/tests/lib/mirrors/mirrors_nsm_mismatch_test.dart @@ -19,34 +19,48 @@ class C { main() { var mirrors = currentMirrorSystem(); var libMirror = mirrors.findLibrary(#test.mirrors_nsm_mismatch); - expectMatchingErrors(() => libMirror.invoke(#topLevelMethod, [], {#extra: 1}), - () => topLevelMethod(extra: 1)); - expectMatchingErrors(() => libMirror.invoke(#topLevelMethod, ['positional']), - () => topLevelMethod('positional')); + expectMatchingErrors( + () => libMirror.invoke(#topLevelMethod, [], {#extra: 1}), + () => topLevelMethod(extra: 1), + ); + expectMatchingErrors( + () => libMirror.invoke(#topLevelMethod, ['positional']), + () => topLevelMethod('positional'), + ); var classMirror = reflectClass(C); expectMatchingErrors( - () => classMirror.newInstance(#constructor, [], {#extra: 1}), - () => new C.constructor(extra: 1)); + () => classMirror.newInstance(#constructor, [], {#extra: 1}), + () => new C.constructor(extra: 1), + ); expectMatchingErrors( - () => classMirror.newInstance(#redirecting, [], {#extra: 1}), - () => new C.redirecting(extra: 1)); - expectMatchingErrors(() => classMirror.invoke(#staticMethod, [], {#extra: 1}), - () => C.staticMethod(extra: 1)); + () => classMirror.newInstance(#redirecting, [], {#extra: 1}), + () => new C.redirecting(extra: 1), + ); expectMatchingErrors( - () => classMirror.newInstance(#constructor, ['positional']), - () => new C.constructor('positional')); + () => classMirror.invoke(#staticMethod, [], {#extra: 1}), + () => C.staticMethod(extra: 1), + ); expectMatchingErrors( - () => classMirror.newInstance(#redirecting, ['positional']), - () => new C.redirecting('positional')); - expectMatchingErrors(() => classMirror.invoke(#staticMethod, ['positional']), - () => C.staticMethod('positional')); + () => classMirror.newInstance(#constructor, ['positional']), + () => new C.constructor('positional'), + ); + expectMatchingErrors( + () => classMirror.newInstance(#redirecting, ['positional']), + () => new C.redirecting('positional'), + ); + expectMatchingErrors( + () => classMirror.invoke(#staticMethod, ['positional']), + () => C.staticMethod('positional'), + ); var instanceMirror = reflect(new C.constructor()); expectMatchingErrors( - () => instanceMirror.invoke(#instanceMethod, [], {#extra: 1}), - () => instanceMirror.reflectee.instanceMethod(extra: 1)); + () => instanceMirror.invoke(#instanceMethod, [], {#extra: 1}), + () => instanceMirror.reflectee.instanceMethod(extra: 1), + ); expectMatchingErrors( - () => instanceMirror.invoke(#instanceMethod, ['positional']), - () => instanceMirror.reflectee.instanceMethod('positional')); + () => instanceMirror.invoke(#instanceMethod, ['positional']), + () => instanceMirror.reflectee.instanceMethod('positional'), + ); } diff --git a/tests/lib/mirrors/mirrors_reader.dart b/tests/lib/mirrors/mirrors_reader.dart index 3e7ccfafc60..d8bef40fee9 100644 --- a/tests/lib/mirrors/mirrors_reader.dart +++ b/tests/lib/mirrors/mirrors_reader.dart @@ -68,8 +68,12 @@ class MirrorsReader extends MirrorsVisitor { errors.add(new ReadError(errorTag, exception, stackTrace)); } - visitUnsupported(var receiver, String tag, UnsupportedError? exception, - StackTrace stackTrace) { + visitUnsupported( + var receiver, + String tag, + UnsupportedError? exception, + StackTrace stackTrace, + ) { if (verbose) print('visitUnsupported:$receiver.$tag:$exception'); if (!expectUnsupported(receiver, tag, exception) && !allowUnsupported(receiver, tag, exception)) { @@ -79,13 +83,17 @@ class MirrorsReader extends MirrorsVisitor { /// Override to specify that access is expected to be unsupported. bool expectUnsupported( - var receiver, String tag, UnsupportedError? exception) => - false; + var receiver, + String tag, + UnsupportedError? exception, + ) => false; /// Override to allow unsupported access. bool allowUnsupported( - var receiver, String tag, UnsupportedError? exception) => - false; + var receiver, + String tag, + UnsupportedError? exception, + ) => false; /// Evaluates the function [f]. Subclasses can override this to handle /// specific exceptions. @@ -150,8 +158,11 @@ class MirrorsReader extends MirrorsVisitor { visitClassMirror(ClassMirror mirror) { super.visitClassMirror(mirror); visit(mirror, 'declarations', () => mirror.declarations); - bool hasReflectedType = - visit(mirror, 'hasReflectedType', () => mirror.hasReflectedType); + bool hasReflectedType = visit( + mirror, + 'hasReflectedType', + () => mirror.hasReflectedType, + ); visit(mirror, 'instanceMembers', () => mirror.instanceMembers); visit(mirror, 'mixin', () => mirror.mixin); if (hasReflectedType) { @@ -182,8 +193,11 @@ class MirrorsReader extends MirrorsVisitor { visitInstanceMirror(InstanceMirror mirror) { super.visitInstanceMirror(mirror); - bool hasReflectee = - visit(mirror, 'hasReflectee', () => mirror.hasReflectee); + bool hasReflectee = visit( + mirror, + 'hasReflectee', + () => mirror.hasReflectee, + ); if (hasReflectee) { visit(mirror, 'reflectee', () => mirror.reflectee); } @@ -203,12 +217,18 @@ class MirrorsReader extends MirrorsVisitor { visit(mirror, 'isConstConstructor', () => mirror.isConstConstructor); visit(mirror, 'isConstructor', () => mirror.isConstructor); visit(mirror, 'isFactoryConstructor', () => mirror.isFactoryConstructor); - visit(mirror, 'isGenerativeConstructor', - () => mirror.isGenerativeConstructor); + visit( + mirror, + 'isGenerativeConstructor', + () => mirror.isGenerativeConstructor, + ); visit(mirror, 'isGetter', () => mirror.isGetter); visit(mirror, 'isOperator', () => mirror.isOperator); - visit(mirror, 'isRedirectingConstructor', - () => mirror.isRedirectingConstructor); + visit( + mirror, + 'isRedirectingConstructor', + () => mirror.isRedirectingConstructor, + ); visit(mirror, 'isRegularMethod', () => mirror.isRegularMethod); visit(mirror, 'isSetter', () => mirror.isSetter); visit(mirror, 'isStatic', () => mirror.isStatic); @@ -220,8 +240,11 @@ class MirrorsReader extends MirrorsVisitor { visitParameterMirror(ParameterMirror mirror) { super.visitParameterMirror(mirror); - bool hasDefaultValue = - visit(mirror, 'hasDefaultValue', () => mirror.hasDefaultValue); + bool hasDefaultValue = visit( + mirror, + 'hasDefaultValue', + () => mirror.hasDefaultValue, + ); if (hasDefaultValue) { visit(mirror, 'defaultValue', () => mirror.defaultValue); } diff --git a/tests/lib/mirrors/mirrors_reader_test.dart b/tests/lib/mirrors/mirrors_reader_test.dart index 5835e0cf982..875cfb7e9f2 100644 --- a/tests/lib/mirrors/mirrors_reader_test.dart +++ b/tests/lib/mirrors/mirrors_reader_test.dart @@ -14,11 +14,13 @@ class RuntimeMirrorsReader extends MirrorsReader { final MirrorSystem mirrorSystem; final String mirrorSystemType; - RuntimeMirrorsReader(MirrorSystem mirrorSystem, - {bool verbose = false, bool includeStackTrace = false}) - : this.mirrorSystem = mirrorSystem, - this.mirrorSystemType = '${mirrorSystem.runtimeType}', - super(verbose: verbose, includeStackTrace: includeStackTrace); + RuntimeMirrorsReader( + MirrorSystem mirrorSystem, { + bool verbose = false, + bool includeStackTrace = false, + }) : this.mirrorSystem = mirrorSystem, + this.mirrorSystemType = '${mirrorSystem.runtimeType}', + super(verbose: verbose, includeStackTrace: includeStackTrace); visitLibraryMirror(LibraryMirror mirror) { super.visitLibraryMirror(mirror); @@ -46,7 +48,10 @@ class RuntimeMirrorsReader extends MirrorsReader { } bool expectUnsupported( - var receiver, String tag, UnsupportedError? exception) { + var receiver, + String tag, + UnsupportedError? exception, + ) { // [DeclarationMirror.location] is intentionally not supported in runtime // mirrors. @@ -64,8 +69,10 @@ class RuntimeMirrorsReader extends MirrorsReader { void main([List arguments = const []]) { MirrorSystem mirrors = currentMirrorSystem(); - MirrorsReader reader = new RuntimeMirrorsReader(mirrors, - verbose: arguments.contains('-v'), - includeStackTrace: arguments.contains('-s')); + MirrorsReader reader = new RuntimeMirrorsReader( + mirrors, + verbose: arguments.contains('-v'), + includeStackTrace: arguments.contains('-s'), + ); reader.checkMirrorSystem(mirrors); } diff --git a/tests/lib/mirrors/mirrors_test.dart b/tests/lib/mirrors/mirrors_test.dart index bbf9c5b7d1c..8e05dfb1d44 100644 --- a/tests/lib/mirrors/mirrors_test.dart +++ b/tests/lib/mirrors/mirrors_test.dart @@ -41,20 +41,26 @@ testInvoke(mirrors) { var instance = new Class(); var instMirror = reflect(instance); - expect(instMirror.invoke(#m, ['A', 'B', instance]).reflectee, - equals({"a": 'A', "b": 'B', "c": instance})); + expect( + instMirror.invoke(#m, ['A', 'B', instance]).reflectee, + equals({"a": 'A', "b": 'B', "c": instance}), + ); expect(instMirror.invoke(#notDefined, []).reflectee, equals("DNU")); expect(instMirror.invoke(#m, []).reflectee, equals("DNU")); // Wrong arity. var classMirror = instMirror.type; - expect(classMirror.invoke(#s, ['A', 'B', instance]).reflectee, - equals({"a": 'A', "b": 'B', "c": instance})); + expect( + classMirror.invoke(#s, ['A', 'B', instance]).reflectee, + equals({"a": 'A', "b": 'B', "c": instance}), + ); expect(() => classMirror.invoke(#notDefined, []).reflectee, throws); expect(() => classMirror.invoke(#s, []).reflectee, throws); // Wrong arity. var libMirror = classMirror.owner as LibraryMirror; - expect(libMirror.invoke(#u, ['A', 'B', instance]).reflectee, - equals({"a": 'A', "b": 'B', "c": instance})); + expect( + libMirror.invoke(#u, ['A', 'B', instance]).reflectee, + equals({"a": 'A', "b": 'B', "c": instance}), + ); expect(() => libMirror.invoke(#notDefined, []).reflectee, throws); expect(() => libMirror.invoke(#u, []).reflectee, throws); // Wrong arity. } @@ -77,12 +83,15 @@ testIntercepted(mirrors) { expect(instance.length, equals(44)); expect( - instMirror.invoke(#toString, []).reflectee, - equals('[null, null, null, null, null, null, null, null, null, null,' - ' null, null, null, null, null, null, null, null, null, null,' - ' null, null, null, null, null, null, null, null, null, null,' - ' null, null, null, null, null, null, null, null, null, null,' - ' null, null, null, null]')); + instMirror.invoke(#toString, []).reflectee, + equals( + '[null, null, null, null, null, null, null, null, null, null,' + ' null, null, null, null, null, null, null, null, null, null,' + ' null, null, null, null, null, null, null, null, null, null,' + ' null, null, null, null, null, null, null, null, null, null,' + ' null, null, null, null]', + ), + ); } testFieldAccess(mirrors) { @@ -148,8 +157,9 @@ testReflectClass(mirrors) { var classMirror = reflectClass(Class); expect(classMirror is ClassMirror, equals(true)); var symbolClassMirror = reflectClass(Symbol); - var symbolMirror = - symbolClassMirror.newInstance(Symbol.empty, ['withInitialValue']); + var symbolMirror = symbolClassMirror.newInstance(Symbol.empty, [ + 'withInitialValue', + ]); var objectMirror = classMirror.newInstance(symbolMirror.reflectee, [1234]); expect(objectMirror.reflectee is Class, equals(true)); expect(objectMirror.reflectee.field, equals(1234)); @@ -171,27 +181,37 @@ testNames(mirrors) { TypeVariableMirror typeVariable = classMirror.typeVariables.single; expect(typeVariable.simpleName, equals(#T)); expect( - typeVariable.qualifiedName, equals(const Symbol('MirrorsTest.Class.T'))); + typeVariable.qualifiedName, + equals(const Symbol('MirrorsTest.Class.T')), + ); if (!isDart2js) { // TODO(ahe): Implement this in dart2js. expect(typedefMirror.simpleName, equals(#Typedef)); - expect(typedefMirror.qualifiedName, - equals(const Symbol('MirrorsTest.Typedef'))); + expect( + typedefMirror.qualifiedName, + equals(const Symbol('MirrorsTest.Typedef')), + ); var typedefMirrorDeNovo = reflectType(Typedef); expect(typedefMirrorDeNovo.simpleName, equals(#Typedef)); - expect(typedefMirrorDeNovo.qualifiedName, - equals(const Symbol('MirrorsTest.Typedef'))); + expect( + typedefMirrorDeNovo.qualifiedName, + equals(const Symbol('MirrorsTest.Typedef')), + ); } expect(methodMirror.simpleName, equals(#testNames)); - expect(methodMirror.qualifiedName, - equals(const Symbol('MirrorsTest.testNames'))); + expect( + methodMirror.qualifiedName, + equals(const Symbol('MirrorsTest.testNames')), + ); expect(variableMirror.simpleName, equals(#field)); - expect(variableMirror.qualifiedName, - equals(const Symbol('MirrorsTest.Class.field'))); + expect( + variableMirror.qualifiedName, + equals(const Symbol('MirrorsTest.Class.field')), + ); } testLibraryUri(var value, bool check(Uri uri)) { @@ -225,10 +245,11 @@ main() { }); test("Test current library uri", () { testLibraryUri( - new Class(), - // TODO(floitsch): change this to "/mirrors_test.dart" when - // dart2js_mirrors_test.dart has been removed. - (Uri uri) => uri.path.endsWith('mirrors_test.dart')); + new Class(), + // TODO(floitsch): change this to "/mirrors_test.dart" when + // dart2js_mirrors_test.dart has been removed. + (Uri uri) => uri.path.endsWith('mirrors_test.dart'), + ); }); test("Test dart library uri", () { testLibraryUri("test", (Uri uri) { diff --git a/tests/lib/mirrors/mirrors_visitor.dart b/tests/lib/mirrors/mirrors_visitor.dart index a78b7ec1208..6875caeeb39 100644 --- a/tests/lib/mirrors/mirrors_visitor.dart +++ b/tests/lib/mirrors/mirrors_visitor.dart @@ -36,7 +36,8 @@ abstract class MirrorsVisitor { visitDeclarationMirror(mirror); } else { throw new StateError( - 'Unexpected mirror kind ${mirror.runtimeType}: $mirror'); + 'Unexpected mirror kind ${mirror.runtimeType}: $mirror', + ); } } diff --git a/tests/lib/mirrors/new_instance_optional_arguments_test.dart b/tests/lib/mirrors/new_instance_optional_arguments_test.dart index 3d50f040472..9d566c31940 100644 --- a/tests/lib/mirrors/new_instance_optional_arguments_test.dart +++ b/tests/lib/mirrors/new_instance_optional_arguments_test.dart @@ -11,27 +11,19 @@ import 'package:expect/expect.dart'; class A { var req1, opt1, opt2; A.a0([opt1]) : this.opt1 = opt1; - A.b0([opt1, opt2]) - : this.opt1 = opt1, - this.opt2 = opt2; + A.b0([opt1, opt2]) : this.opt1 = opt1, this.opt2 = opt2; A.c0([opt1 = 499]) : this.opt1 = opt1; - A.d0([opt1 = 499, opt2 = 42]) - : this.opt1 = opt1, - this.opt2 = opt2; - A.a1(req1, [opt1]) - : this.req1 = req1, - this.opt1 = opt1; + A.d0([opt1 = 499, opt2 = 42]) : this.opt1 = opt1, this.opt2 = opt2; + A.a1(req1, [opt1]) : this.req1 = req1, this.opt1 = opt1; A.b1(req1, [opt1, opt2]) - : this.req1 = req1, - this.opt1 = opt1, - this.opt2 = opt2; - A.c1(req1, [opt1 = 499]) - : this.req1 = req1, - this.opt1 = opt1; + : this.req1 = req1, + this.opt1 = opt1, + this.opt2 = opt2; + A.c1(req1, [opt1 = 499]) : this.req1 = req1, this.opt1 = opt1; A.d1(req1, [opt1 = 499, opt2 = 42]) - : this.req1 = req1, - this.opt1 = opt1, - this.opt2 = opt2; + : this.req1 = req1, + this.opt1 = opt1, + this.opt2 = opt2; } main() { diff --git a/tests/lib/mirrors/new_instance_with_type_arguments_test.dart b/tests/lib/mirrors/new_instance_with_type_arguments_test.dart index 820f47c3674..0e38d78066b 100644 --- a/tests/lib/mirrors/new_instance_with_type_arguments_test.dart +++ b/tests/lib/mirrors/new_instance_with_type_arguments_test.dart @@ -38,8 +38,9 @@ main() { Expect.equals(String, c_string.s); Expect.equals(dynamic, c_dynamic.s); - dynamic reflective_a_int = - cmB.superclass!.newInstance(Symbol.empty, []).reflectee; + dynamic reflective_a_int = cmB.superclass! + .newInstance(Symbol.empty, []) + .reflectee; dynamic reflective_a_dynamic = cmA.newInstance(Symbol.empty, []).reflectee; dynamic reflective_b = cmB.newInstance(Symbol.empty, []).reflectee; dynamic reflective_c_dynamic = cmC.newInstance(Symbol.empty, []).reflectee; diff --git a/tests/lib/mirrors/null_test.dart b/tests/lib/mirrors/null_test.dart index 7eceb98fbb4..f95087e0cb5 100644 --- a/tests/lib/mirrors/null_test.dart +++ b/tests/lib/mirrors/null_test.dart @@ -20,8 +20,10 @@ void test() { InstanceMirror im1 = reflect(null); Expect.equals(cm, im1.type); if (!unsoundNullSafety) { - Expect.throwsTypeError(() => im1.invoke(const Symbol("=="), [null]), - 'null not assignable to Object'); + Expect.throwsTypeError( + () => im1.invoke(const Symbol("=="), [null]), + 'null not assignable to Object', + ); } else { Expect.isTrue(im1.invoke(const Symbol("=="), [null]).reflectee); } @@ -31,8 +33,10 @@ void test() { InstanceMirror im2 = reflect(obj); Expect.equals(cm, im2.type); if (!unsoundNullSafety) { - Expect.throwsTypeError(() => im2.invoke(const Symbol("=="), [null]), - 'null not assignable to Object'); + Expect.throwsTypeError( + () => im2.invoke(const Symbol("=="), [null]), + 'null not assignable to Object', + ); } else { Expect.isTrue(im2.invoke(const Symbol("=="), [null]).reflectee); } @@ -44,14 +48,18 @@ void test() { Expect.equals('Null', nullMirror.getField(#runtimeType).reflectee.toString()); if (!unsoundNullSafety) { Expect.throwsTypeError( - () => nullMirror.invoke(#==, [null]), 'null not assignable to Object'); + () => nullMirror.invoke(#==, [null]), + 'null not assignable to Object', + ); } else { Expect.isTrue(nullMirror.invoke(#==, [null]).reflectee); } Expect.isFalse(nullMirror.invoke(#==, [new Object()]).reflectee); Expect.equals('null', nullMirror.invoke(#toString, []).reflectee); Expect.throwsNoSuchMethodError( - () => nullMirror.invoke(#notDefined, []), 'noSuchMethod'); + () => nullMirror.invoke(#notDefined, []), + 'noSuchMethod', + ); ClassMirror NullMirror = nullMirror.type; Expect.equals(reflectClass(Null), NullMirror); @@ -63,8 +71,9 @@ void test() { LibraryMirror? coreLibrary = libraries[Uri.parse('dart:core')]; if (coreLibrary == null) { // In minified mode we don't preserve the URIs. - coreLibrary = libraries.values - .firstWhere((LibraryMirror lm) => lm.simpleName == #dart.core); + coreLibrary = libraries.values.firstWhere( + (LibraryMirror lm) => lm.simpleName == #dart.core, + ); Uri uri = coreLibrary.uri; Expect.equals("https", uri.scheme); Expect.equals("dartlang.org", uri.host); diff --git a/tests/lib/mirrors/operator_test.dart b/tests/lib/mirrors/operator_test.dart index c4667755ce3..a0c290e9193 100644 --- a/tests/lib/mirrors/operator_test.dart +++ b/tests/lib/mirrors/operator_test.dart @@ -61,7 +61,8 @@ void main() { expect(RETURN_TYPES, returnTypes); } -const String OPERATORS = '{' +const String OPERATORS = + '{' '%: Method(s(%) in s(Foo)), ' '&: Method(s(&) in s(Foo)), ' '*: Method(s(*) in s(Foo)), ' @@ -92,7 +93,8 @@ const String INT = 'Class(s(int) in s(dart.core), top-level)'; const String BOOL = 'Class(s(bool) in s(dart.core), top-level)'; -const String PARAMETERS = '{' +const String PARAMETERS = + '{' '%: [Parameter(s(a) in s(%), type = $FOO)], ' '&: [Parameter(s(a) in s(&), type = $FOO)], ' '*: [Parameter(s(a) in s(*), type = $FOO)], ' @@ -116,7 +118,8 @@ const String PARAMETERS = '{' '~/: [Parameter(s(a) in s(~/), type = $FOO)]' '}'; -const String RETURN_TYPES = '{' +const String RETURN_TYPES = + '{' '%: $FOO, ' '&: $FOO, ' '*: $FOO, ' diff --git a/tests/lib/mirrors/other_declarations_location_test.dart b/tests/lib/mirrors/other_declarations_location_test.dart index 9c1c85e7b8b..08693ef4244 100644 --- a/tests/lib/mirrors/other_declarations_location_test.dart +++ b/tests/lib/mirrors/other_declarations_location_test.dart @@ -24,11 +24,17 @@ class C { // We only check for a suffix of the uri because the test might be run from // any number of absolute paths. expectLocation( - DeclarationMirror mirror, String uriSuffix, int line, int column) { + DeclarationMirror mirror, + String uriSuffix, + int line, + int column, +) { SourceLocation location = mirror.location!; Uri uri = location.sourceUri; Expect.isTrue( - uri.toString().endsWith(uriSuffix), "Expected suffix $uriSuffix in $uri"); + uri.toString().endsWith(uriSuffix), + "Expected suffix $uriSuffix in $uri", + ); Expect.equals(line, location.line, "line"); Expect.equals(column, location.column, "column"); } @@ -50,8 +56,16 @@ main() { // Libraries. expectLocation(reflectClass(C).owner!, mainSuffix, 5, 1); - expectLocation(reflectClass(ClassInLibraryWithoutDeclaration).owner!, - "library_without_declaration.dart", 1, 1); - expectLocation(reflectClass(ClassInLibraryWithAnnotatedDeclaration).owner!, - "library_with_annotated_declaration.dart", 5, 1); + expectLocation( + reflectClass(ClassInLibraryWithoutDeclaration).owner!, + "library_without_declaration.dart", + 1, + 1, + ); + expectLocation( + reflectClass(ClassInLibraryWithAnnotatedDeclaration).owner!, + "library_with_annotated_declaration.dart", + 5, + 1, + ); } diff --git a/tests/lib/mirrors/parameter_abstract_test.dart b/tests/lib/mirrors/parameter_abstract_test.dart index 30a9e4a134f..f01dedb3d4c 100644 --- a/tests/lib/mirrors/parameter_abstract_test.dart +++ b/tests/lib/mirrors/parameter_abstract_test.dart @@ -21,12 +21,15 @@ main() { MethodMirror foo1 = cm.declarations[#foo1] as MethodMirror; expect('Method(s(foo1) in s(C), abstract)', foo1); expect( - 'Parameter(s(x) in s(foo1), optional, named, type = Class(s(int) in s(dart.core), top-level))', - foo1.parameters[0]); + 'Parameter(s(x) in s(foo1), optional, named, type = Class(s(int) in s(dart.core), top-level))', + foo1.parameters[0], + ); expect( - 'Parameter(s(y) in s(foo1), optional, named, type = Class(s(int) in s(dart.core), top-level))', - foo1.parameters[1]); + 'Parameter(s(y) in s(foo1), optional, named, type = Class(s(int) in s(dart.core), top-level))', + foo1.parameters[1], + ); expect( - 'Parameter(s(z) in s(foo1), optional, named, type = Class(s(int) in s(dart.core), top-level))', - foo1.parameters[2]); + 'Parameter(s(z) in s(foo1), optional, named, type = Class(s(int) in s(dart.core), top-level))', + foo1.parameters[2], + ); } diff --git a/tests/lib/mirrors/parameter_annotation_mirror_test.dart b/tests/lib/mirrors/parameter_annotation_mirror_test.dart index ff4aaa6b4ae..e639a29dc2c 100644 --- a/tests/lib/mirrors/parameter_annotation_mirror_test.dart +++ b/tests/lib/mirrors/parameter_annotation_mirror_test.dart @@ -15,7 +15,9 @@ class Foo { Foo(@ParameterAnnotation("vogel") p) {} Foo.named(@ParameterAnnotation("hamster") p) {} Foo.named2( - @ParameterAnnotation("hamster") p, @ParameterAnnotation("wurm") p2) {} + @ParameterAnnotation("hamster") p, + @ParameterAnnotation("wurm") p2, + ) {} f1(@ParameterAnnotation("hest") p) {} f2(@ParameterAnnotation("hest") @ParameterAnnotation("fisk") p) {} @@ -28,18 +30,26 @@ class Foo { } expectAnnotations( - Type type, Symbol method, int parameterIndex, List expectedValues) { + Type type, + Symbol method, + int parameterIndex, + List expectedValues, +) { MethodMirror mirror = reflectClass(type).declarations[method] as MethodMirror; ParameterMirror parameter = mirror.parameters[parameterIndex]; List annotations = parameter.metadata; - Expect.equals(annotations.length, expectedValues.length, - "wrong number of parameter annotations"); + Expect.equals( + annotations.length, + expectedValues.length, + "wrong number of parameter annotations", + ); for (int i = 0; i < annotations.length; i++) { Expect.equals( - expectedValues[i], - annotations[i].reflectee.value, - "annotation #$i of parameter #$parameterIndex " - "of $type.$method."); + expectedValues[i], + annotations[i].reflectee.value, + "annotation #$i of parameter #$parameterIndex " + "of $type.$method.", + ); } } diff --git a/tests/lib/mirrors/parameter_optional_order_test.dart b/tests/lib/mirrors/parameter_optional_order_test.dart index ea2b490bcc7..ca696ed5d65 100644 --- a/tests/lib/mirrors/parameter_optional_order_test.dart +++ b/tests/lib/mirrors/parameter_optional_order_test.dart @@ -27,38 +27,47 @@ testPositional() { MethodMirror positional1 = cm.declarations[#positional1] as MethodMirror; expect('Method(s(positional1) in s(C))', positional1); expect( - 'Parameter(s(x) in s(positional1), optional, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', - positional1.parameters[3]); + 'Parameter(s(x) in s(positional1), optional, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', + positional1.parameters[3], + ); expect( - 'Parameter(s(y) in s(positional1), optional, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', - positional1.parameters[4]); + 'Parameter(s(y) in s(positional1), optional, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', + positional1.parameters[4], + ); expect( - 'Parameter(s(z) in s(positional1), optional, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', - positional1.parameters[5]); + 'Parameter(s(z) in s(positional1), optional, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', + positional1.parameters[5], + ); MethodMirror positional2 = cm.declarations[#positional2] as MethodMirror; expect('Method(s(positional2) in s(C))', positional2); expect( - 'Parameter(s(y) in s(positional2), optional, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', - positional2.parameters[3]); + 'Parameter(s(y) in s(positional2), optional, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', + positional2.parameters[3], + ); expect( - 'Parameter(s(z) in s(positional2), optional, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', - positional2.parameters[4]); + 'Parameter(s(z) in s(positional2), optional, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', + positional2.parameters[4], + ); expect( - 'Parameter(s(x) in s(positional2), optional, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', - positional2.parameters[5]); + 'Parameter(s(x) in s(positional2), optional, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', + positional2.parameters[5], + ); MethodMirror positional3 = cm.declarations[#positional3] as MethodMirror; expect('Method(s(positional3) in s(C))', positional3); expect( - 'Parameter(s(z) in s(positional3), optional, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', - positional3.parameters[3]); + 'Parameter(s(z) in s(positional3), optional, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', + positional3.parameters[3], + ); expect( - 'Parameter(s(x) in s(positional3), optional, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', - positional3.parameters[4]); + 'Parameter(s(x) in s(positional3), optional, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', + positional3.parameters[4], + ); expect( - 'Parameter(s(y) in s(positional3), optional, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', - positional3.parameters[5]); + 'Parameter(s(y) in s(positional3), optional, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', + positional3.parameters[5], + ); } testNamed() { @@ -67,38 +76,47 @@ testNamed() { MethodMirror named1 = cm.declarations[#named1] as MethodMirror; expect('Method(s(named1) in s(C))', named1); expect( - 'Parameter(s(x) in s(named1), optional, named, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', - named1.parameters[3]); + 'Parameter(s(x) in s(named1), optional, named, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', + named1.parameters[3], + ); expect( - 'Parameter(s(y) in s(named1), optional, named, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', - named1.parameters[4]); + 'Parameter(s(y) in s(named1), optional, named, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', + named1.parameters[4], + ); expect( - 'Parameter(s(z) in s(named1), optional, named, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', - named1.parameters[5]); + 'Parameter(s(z) in s(named1), optional, named, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', + named1.parameters[5], + ); MethodMirror named2 = cm.declarations[#named2] as MethodMirror; expect('Method(s(named2) in s(C))', named2); expect( - 'Parameter(s(y) in s(named2), optional, named, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', - named2.parameters[3]); + 'Parameter(s(y) in s(named2), optional, named, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', + named2.parameters[3], + ); expect( - 'Parameter(s(z) in s(named2), optional, named, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', - named2.parameters[4]); + 'Parameter(s(z) in s(named2), optional, named, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', + named2.parameters[4], + ); expect( - 'Parameter(s(x) in s(named2), optional, named, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', - named2.parameters[5]); + 'Parameter(s(x) in s(named2), optional, named, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', + named2.parameters[5], + ); MethodMirror named3 = cm.declarations[#named3] as MethodMirror; expect('Method(s(named3) in s(C))', named3); expect( - 'Parameter(s(z) in s(named3), optional, named, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', - named3.parameters[3]); + 'Parameter(s(z) in s(named3), optional, named, value = Instance(value = 1), type = Class(s(int) in s(dart.core), top-level))', + named3.parameters[3], + ); expect( - 'Parameter(s(x) in s(named3), optional, named, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', - named3.parameters[4]); + 'Parameter(s(x) in s(named3), optional, named, value = Instance(value = 2), type = Class(s(int) in s(dart.core), top-level))', + named3.parameters[4], + ); expect( - 'Parameter(s(y) in s(named3), optional, named, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', - named3.parameters[5]); + 'Parameter(s(y) in s(named3), optional, named, value = Instance(value = 3), type = Class(s(int) in s(dart.core), top-level))', + named3.parameters[5], + ); } main() { diff --git a/tests/lib/mirrors/parameter_test.dart b/tests/lib/mirrors/parameter_test.dart index 1c60ccd0603..e47bf872745 100644 --- a/tests/lib/mirrors/parameter_test.dart +++ b/tests/lib/mirrors/parameter_test.dart @@ -52,85 +52,105 @@ main() { #B.foo, #B.quux, #B.qux, - #B.corge + #B.corge, ]; Expect.setEquals(constructorKeys, constructors.keys); MethodMirror unnamedConstructor = constructors[#B] as MethodMirror; expect('Method(s(B) in s(B), constructor)', unnamedConstructor); expect('[]', unnamedConstructor.parameters); - expect('Class(s(B) in s(test.parameter_test), top-level)', - unnamedConstructor.returnType); + expect( + 'Class(s(B) in s(test.parameter_test), top-level)', + unnamedConstructor.returnType, + ); MethodMirror fooConstructor = constructors[#B.foo] as MethodMirror; expect('Method(s(B.foo) in s(B), constructor)', fooConstructor); expect( - '[Parameter(s(x) in s(B.foo),' - ' type = Class(s(int) in s(dart.core), top-level))]', - fooConstructor.parameters); - expect('Class(s(B) in s(test.parameter_test), top-level)', - fooConstructor.returnType); + '[Parameter(s(x) in s(B.foo),' + ' type = Class(s(int) in s(dart.core), top-level))]', + fooConstructor.parameters, + ); + expect( + 'Class(s(B) in s(test.parameter_test), top-level)', + fooConstructor.returnType, + ); MethodMirror barConstructor = constructors[#B.bar] as MethodMirror; expect('Method(s(B.bar) in s(B), constructor)', barConstructor); expect( - '[Parameter(s(z) in s(B.bar),' - ' type = Class(s(int) in s(dart.core), top-level)), ' - 'Parameter(s(x) in s(B.bar),' - ' type = Type(s(dynamic), top-level))]', - barConstructor.parameters); - expect('Class(s(B) in s(test.parameter_test), top-level)', - barConstructor.returnType); + '[Parameter(s(z) in s(B.bar),' + ' type = Class(s(int) in s(dart.core), top-level)), ' + 'Parameter(s(x) in s(B.bar),' + ' type = Type(s(dynamic), top-level))]', + barConstructor.parameters, + ); + expect( + 'Class(s(B) in s(test.parameter_test), top-level)', + barConstructor.returnType, + ); MethodMirror bazConstructor = constructors[#B.baz] as MethodMirror; expect('Method(s(B.baz) in s(B), constructor)', bazConstructor); expect( - '[Parameter(s(x) in s(B.baz), final,' - ' type = Class(s(int) in s(dart.core), top-level)), ' - 'Parameter(s(y) in s(B.baz),' - ' type = Class(s(int) in s(dart.core), top-level)), ' - 'Parameter(s(z) in s(B.baz), final,' - ' type = Class(s(int) in s(dart.core), top-level))]', - bazConstructor.parameters); - expect('Class(s(B) in s(test.parameter_test), top-level)', - bazConstructor.returnType); + '[Parameter(s(x) in s(B.baz), final,' + ' type = Class(s(int) in s(dart.core), top-level)), ' + 'Parameter(s(y) in s(B.baz),' + ' type = Class(s(int) in s(dart.core), top-level)), ' + 'Parameter(s(z) in s(B.baz), final,' + ' type = Class(s(int) in s(dart.core), top-level))]', + bazConstructor.parameters, + ); + expect( + 'Class(s(B) in s(test.parameter_test), top-level)', + bazConstructor.returnType, + ); MethodMirror quxConstructor = constructors[#B.qux] as MethodMirror; expect('Method(s(B.qux) in s(B), constructor)', quxConstructor); expect( - '[Parameter(s(x) in s(B.qux),' - ' type = Class(s(int) in s(dart.core), top-level)), ' - 'Parameter(s(y) in s(B.qux), optional,' - ' value = Instance(value = 4),' - ' type = Class(s(int) in s(dart.core), top-level))]', - quxConstructor.parameters); - expect('Class(s(B) in s(test.parameter_test), top-level)', - quxConstructor.returnType); + '[Parameter(s(x) in s(B.qux),' + ' type = Class(s(int) in s(dart.core), top-level)), ' + 'Parameter(s(y) in s(B.qux), optional,' + ' value = Instance(value = 4),' + ' type = Class(s(int) in s(dart.core), top-level))]', + quxConstructor.parameters, + ); + expect( + 'Class(s(B) in s(test.parameter_test), top-level)', + quxConstructor.returnType, + ); MethodMirror quuxConstructor = constructors[#B.quux] as MethodMirror; expect('Method(s(B.quux) in s(B), constructor)', quuxConstructor); expect( - '[Parameter(s(x) in s(B.quux),' - ' type = Class(s(int) in s(dart.core), top-level)), ' - 'Parameter(s(str) in s(B.quux), optional, named,' - ' value = Instance(value = foo),' - ' type = Class(s(String) in s(dart.core), top-level))]', - quuxConstructor.parameters); - expect('Class(s(B) in s(test.parameter_test), top-level)', - quuxConstructor.returnType); + '[Parameter(s(x) in s(B.quux),' + ' type = Class(s(int) in s(dart.core), top-level)), ' + 'Parameter(s(str) in s(B.quux), optional, named,' + ' value = Instance(value = foo),' + ' type = Class(s(String) in s(dart.core), top-level))]', + quuxConstructor.parameters, + ); + expect( + 'Class(s(B) in s(test.parameter_test), top-level)', + quuxConstructor.returnType, + ); MethodMirror corgeConstructor = constructors[#B.corge] as MethodMirror; expect('Method(s(B.corge) in s(B), constructor)', corgeConstructor); expect( - '[Parameter(s(x) in s(B.corge), optional, named,' - ' value = Instance(value = 51),' - ' type = Class(s(int) in s(dart.core), top-level)), ' - 'Parameter(s(str) in s(B.corge), optional, named,' - ' value = Instance(value = bar),' - ' type = Class(s(String) in s(dart.core), top-level))]', - corgeConstructor.parameters); - expect('Class(s(B) in s(test.parameter_test), top-level)', - corgeConstructor.returnType); + '[Parameter(s(x) in s(B.corge), optional, named,' + ' value = Instance(value = 51),' + ' type = Class(s(int) in s(dart.core), top-level)), ' + 'Parameter(s(str) in s(B.corge), optional, named,' + ' value = Instance(value = bar),' + ' type = Class(s(String) in s(dart.core), top-level))]', + corgeConstructor.parameters, + ); + expect( + 'Class(s(B) in s(test.parameter_test), top-level)', + corgeConstructor.returnType, + ); MethodMirror xGetter = cm.declarations[#x] as MethodMirror; expect('Method(s(x) in s(B), getter)', xGetter); @@ -139,32 +159,36 @@ main() { MethodMirror xSetter = cm.declarations[const Symbol('x=')] as MethodMirror; expect('Method(s(x=) in s(B), setter)', xSetter); expect( - '[Parameter(s(value) in s(x=), final,' - ' type = Type(s(dynamic), top-level))]', - xSetter.parameters); + '[Parameter(s(value) in s(x=), final,' + ' type = Type(s(dynamic), top-level))]', + xSetter.parameters, + ); MethodMirror grault = cm.declarations[#grault] as MethodMirror; expect('Method(s(grault) in s(B))', grault); expect( - '[Parameter(s(x) in s(grault), optional, value = Instance(value = 0),' - ' type = Class(s(int) in s(dart.core), top-level))]', - grault.parameters); + '[Parameter(s(x) in s(grault), optional, value = Instance(value = 0),' + ' type = Class(s(int) in s(dart.core), top-level))]', + grault.parameters, + ); expect('Instance(value = 0)', grault.parameters[0].defaultValue); MethodMirror garply = cm.declarations[#garply] as MethodMirror; expect('Method(s(garply) in s(B))', garply); expect( - '[Parameter(s(y) in s(garply), optional, named, value = Instance(value = 0),' - ' type = Class(s(int) in s(dart.core), top-level))]', - garply.parameters); + '[Parameter(s(y) in s(garply), optional, named, value = Instance(value = 0),' + ' type = Class(s(int) in s(dart.core), top-level))]', + garply.parameters, + ); expect('Instance(value = 0)', garply.parameters[0].defaultValue); MethodMirror waldo = cm.declarations[#waldo] as MethodMirror; expect('Method(s(waldo) in s(B))', waldo); expect( - '[Parameter(s(z) in s(waldo),' - ' type = Class(s(int) in s(dart.core), top-level))]', - waldo.parameters); + '[Parameter(s(z) in s(waldo),' + ' type = Class(s(int) in s(dart.core), top-level))]', + waldo.parameters, + ); expect('', waldo.parameters[0].defaultValue); cm = reflectClass(C); diff --git a/tests/lib/mirrors/proxy_type_test.dart b/tests/lib/mirrors/proxy_type_test.dart index 8c48dd902fb..64ad4f6c7cd 100644 --- a/tests/lib/mirrors/proxy_type_test.dart +++ b/tests/lib/mirrors/proxy_type_test.dart @@ -56,10 +56,11 @@ class CarolCaretaker implements Carol { CarolCaretaker(this._carol, this._gate); foo() { - if (!_gate()) throw new NoSuchMethodError.withInvocation( - this, - Invocation.method(#foo, [], {}), - ); + if (!_gate()) + throw new NoSuchMethodError.withInvocation( + this, + Invocation.method(#foo, [], {}), + ); return _carol.foo(); } @@ -73,8 +74,10 @@ main() { Alice alice2 = new Alice(); alice2.sayFooAttenuated(); - Expect.throwsNoSuchMethodError(() => alice2.sayBar(), - 'Authority should have been attenuated'); + Expect.throwsNoSuchMethodError( + () => alice2.sayBar(), + 'Authority should have been attenuated', + ); // At the base level, a caretaker for a Carol masquerades as a Carol. CarolCaretaker caretaker = new CarolCaretaker(new Carol(), () => true); diff --git a/tests/lib/mirrors/redirecting_factory_reflection_test.dart b/tests/lib/mirrors/redirecting_factory_reflection_test.dart index cf5d60b332f..de53500bd5f 100644 --- a/tests/lib/mirrors/redirecting_factory_reflection_test.dart +++ b/tests/lib/mirrors/redirecting_factory_reflection_test.dart @@ -19,6 +19,8 @@ main() { ClassMirror m = reflectClass(A); var i = m.newInstance(Symbol.empty, []).reflectee; var s = i.t.toString(); - Expect.isTrue(s == 'A' || s == 'A', - 'mirrors should create the correct reified generic type'); + Expect.isTrue( + s == 'A' || s == 'A', + 'mirrors should create the correct reified generic type', + ); } diff --git a/tests/lib/mirrors/reflect_model_test.dart b/tests/lib/mirrors/reflect_model_test.dart index 416f041b099..2c3e46e67a6 100644 --- a/tests/lib/mirrors/reflect_model_test.dart +++ b/tests/lib/mirrors/reflect_model_test.dart @@ -77,44 +77,55 @@ main() { Expect.equals(89, fieldC); expect( - '{accessor: Method(s(accessor) in s(A), getter)' - '}', - gettersOf(aClass)); + '{accessor: Method(s(accessor) in s(A), getter)' + '}', + gettersOf(aClass), + ); expect( - '{accessor: Method(s(accessor) in s(B), getter)' - ', field: Method(s(field) in s(B), getter)}', - gettersOf(bClass)); + '{accessor: Method(s(accessor) in s(B), getter)' + ', field: Method(s(field) in s(B), getter)}', + gettersOf(bClass), + ); expect('{accessor: Method(s(accessor) in s(C), getter)}', gettersOf(cClass)); expect( - '{accessor=: Method(s(accessor=) in s(A), setter)' - '}', - settersOf(aClass)); + '{accessor=: Method(s(accessor=) in s(A), setter)' + '}', + settersOf(aClass), + ); expect( - '{accessor=: Method(s(accessor=) in s(B), setter)}', settersOf(bClass)); + '{accessor=: Method(s(accessor=) in s(B), setter)}', + settersOf(bClass), + ); expect( - '{accessor=: Method(s(accessor=) in s(C), setter)' - ', field=: Method(s(field=) in s(C), setter)}', - settersOf(cClass)); + '{accessor=: Method(s(accessor=) in s(C), setter)' + ', field=: Method(s(field=) in s(C), setter)}', + settersOf(cClass), + ); Expect.equals('A:instanceMethod(7)', a.invoke(instanceMethod, [7]).reflectee); Expect.equals('B:instanceMethod(9)', b.invoke(instanceMethod, [9]).reflectee); Expect.equals( - 'C:instanceMethod(13)', c.invoke(instanceMethod, [13]).reflectee); + 'C:instanceMethod(13)', + c.invoke(instanceMethod, [13]).reflectee, + ); expect( - '{aMethod: Method(s(aMethod) in s(A))' - ', instanceMethod: Method(s(instanceMethod) in s(A))}', - methodsOf(aClass)); + '{aMethod: Method(s(aMethod) in s(A))' + ', instanceMethod: Method(s(instanceMethod) in s(A))}', + methodsOf(aClass), + ); expect( - '{bMethod: Method(s(bMethod) in s(B))' - ', instanceMethod: Method(s(instanceMethod) in s(B))}', - methodsOf(bClass)); + '{bMethod: Method(s(bMethod) in s(B))' + ', instanceMethod: Method(s(instanceMethod) in s(B))}', + methodsOf(bClass), + ); expect( - '{cMethod: Method(s(cMethod) in s(C))' - ', instanceMethod: Method(s(instanceMethod) in s(C))}', - methodsOf(cClass)); + '{cMethod: Method(s(cMethod) in s(C))' + ', instanceMethod: Method(s(instanceMethod) in s(C))}', + methodsOf(cClass), + ); Expect.equals('A:get accessor', a.getField(accessor).reflectee); Expect.equals('B:get accessor', b.getField(accessor).reflectee); diff --git a/tests/lib/mirrors/reflect_runtime_type_test.dart b/tests/lib/mirrors/reflect_runtime_type_test.dart index a5e96b67aa1..f037b865e90 100644 --- a/tests/lib/mirrors/reflect_runtime_type_test.dart +++ b/tests/lib/mirrors/reflect_runtime_type_test.dart @@ -20,5 +20,6 @@ main() { print(field); } -publicFields(ClassMirror mirror) => mirror.declarations.values - .where((x) => x is VariableMirror && !(x.isPrivate || x.isStatic)); +publicFields(ClassMirror mirror) => mirror.declarations.values.where( + (x) => x is VariableMirror && !(x.isPrivate || x.isStatic), +); diff --git a/tests/lib/mirrors/reflect_uninstantiated_class_test.dart b/tests/lib/mirrors/reflect_uninstantiated_class_test.dart index bfbdadb3c41..00d2e22babe 100644 --- a/tests/lib/mirrors/reflect_uninstantiated_class_test.dart +++ b/tests/lib/mirrors/reflect_uninstantiated_class_test.dart @@ -20,5 +20,6 @@ main() { print(field); } -publicFields(ClassMirror mirror) => mirror.declarations.values - .where((x) => x is VariableMirror && !(x.isPrivate || x.isStatic)); +publicFields(ClassMirror mirror) => mirror.declarations.values.where( + (x) => x is VariableMirror && !(x.isPrivate || x.isStatic), +); diff --git a/tests/lib/mirrors/reflected_type_helper.dart b/tests/lib/mirrors/reflected_type_helper.dart index 897dc6aa306..1005b00bc8e 100644 --- a/tests/lib/mirrors/reflected_type_helper.dart +++ b/tests/lib/mirrors/reflected_type_helper.dart @@ -10,8 +10,10 @@ import 'package:expect/expect.dart'; expectReflectedType(TypeMirror typeMirror, Type? expectedType) { if (expectedType == null) { Expect.isFalse(typeMirror.hasReflectedType); - Expect.throwsUnsupportedError(() => typeMirror.reflectedType, - "Should not have a reflected type"); + Expect.throwsUnsupportedError( + () => typeMirror.reflectedType, + "Should not have a reflected type", + ); } else { Expect.isTrue(typeMirror.hasReflectedType); Expect.equals(expectedType, typeMirror.reflectedType); diff --git a/tests/lib/mirrors/regress_26187_test.dart b/tests/lib/mirrors/regress_26187_test.dart index 6c381c78dfd..2800340f81c 100644 --- a/tests/lib/mirrors/regress_26187_test.dart +++ b/tests/lib/mirrors/regress_26187_test.dart @@ -23,7 +23,11 @@ main() { ParameterMirror gParamMirror = (reflectType(g) as TypedefMirror).referent.parameters[0]; Expect.equals( - '.A', MirrorSystem.getName(fParamMirror.metadata[0].type.qualifiedName)); + '.A', + MirrorSystem.getName(fParamMirror.metadata[0].type.qualifiedName), + ); Expect.equals( - '.B', MirrorSystem.getName(gParamMirror.metadata[0].type.qualifiedName)); + '.B', + MirrorSystem.getName(gParamMirror.metadata[0].type.qualifiedName), + ); } diff --git a/tests/lib/mirrors/regress_38035_test.dart b/tests/lib/mirrors/regress_38035_test.dart index 4e6c25a17db..a89025374e1 100644 --- a/tests/lib/mirrors/regress_38035_test.dart +++ b/tests/lib/mirrors/regress_38035_test.dart @@ -14,6 +14,8 @@ class A { } main() { - Expect.equals('([dynamic]) -> dart.core.bool', - MirrorSystem.getName(reflect(A._defaultCheck).type.simpleName)); + Expect.equals( + '([dynamic]) -> dart.core.bool', + MirrorSystem.getName(reflect(A._defaultCheck).type.simpleName), + ); } diff --git a/tests/lib/mirrors/return_type_test.dart b/tests/lib/mirrors/return_type_test.dart index 5a66dfee2ed..f6824b07134 100644 --- a/tests/lib/mirrors/return_type_test.dart +++ b/tests/lib/mirrors/return_type_test.dart @@ -31,11 +31,12 @@ main() { var methods = methodsOf(reflectClass(B)); expect( - '{f: Method(s(f) in s(B)), ' - 'g: Method(s(g) in s(B)), ' - 'h: Method(s(h) in s(B)), ' - 'i: Method(s(i) in s(B))}', - methods); + '{f: Method(s(f) in s(B)), ' + 'g: Method(s(g) in s(B)), ' + 'h: Method(s(h) in s(B)), ' + 'i: Method(s(i) in s(B))}', + methods, + ); var f = methods[#f]; var g = methods[#g]; diff --git a/tests/lib/mirrors/set_field_with_final_inheritance_test.dart b/tests/lib/mirrors/set_field_with_final_inheritance_test.dart index 42812279015..ea9d01c7be2 100644 --- a/tests/lib/mirrors/set_field_with_final_inheritance_test.dart +++ b/tests/lib/mirrors/set_field_with_final_inheritance_test.dart @@ -80,7 +80,8 @@ main() { c = new C(); im = reflect(c); Expect.throwsNoSuchMethodError( - () => im.setField(#finalWithInheritedFinal, 23)); + () => im.setField(#finalWithInheritedFinal, 23), + ); Expect.equals(14, c.finalWithInheritedFinal); Expect.equals(5, c.superFinalWithInheritedFinal); Expect.equals(0, c.sideEffect); diff --git a/tests/lib/mirrors/static_members_easier_test.dart b/tests/lib/mirrors/static_members_easier_test.dart index 105a1c69ee8..6563758831c 100644 --- a/tests/lib/mirrors/static_members_easier_test.dart +++ b/tests/lib/mirrors/static_members_easier_test.dart @@ -26,6 +26,8 @@ main() { #staticMethod, ], selectKeys(cm.staticMembers, (dm) => true)); - Expect.setEquals([#staticVariable, const Symbol('staticVariable=')], - selectKeys(cm.staticMembers, (dynamic dm) => dm.isSynthetic)); + Expect.setEquals([ + #staticVariable, + const Symbol('staticVariable='), + ], selectKeys(cm.staticMembers, (dynamic dm) => dm.isSynthetic)); } diff --git a/tests/lib/mirrors/static_test.dart b/tests/lib/mirrors/static_test.dart index 483b473ab90..94978af0f24 100644 --- a/tests/lib/mirrors/static_test.dart +++ b/tests/lib/mirrors/static_test.dart @@ -19,15 +19,25 @@ class Foo { } void main() { - expect('Variable(s(aux) in s(Foo))', - reflectClass(Foo).declarations[new Symbol('aux')]); - expect('Method(s(baz) in s(Foo))', - reflectClass(Foo).declarations[new Symbol('baz')]); + expect( + 'Variable(s(aux) in s(Foo))', + reflectClass(Foo).declarations[new Symbol('aux')], + ); + expect( + 'Method(s(baz) in s(Foo))', + reflectClass(Foo).declarations[new Symbol('baz')], + ); expect('', reflectClass(Foo).declarations[new Symbol('aux=')]); - expect('Method(s(foo) in s(Foo), static)', - reflectClass(Foo).declarations[new Symbol('foo')]); - expect('Variable(s(bar) in s(Foo), static)', - reflectClass(Foo).declarations[new Symbol('bar')]); - expect('Variable(s(biz) in s(Foo), static, final, const)', - reflectClass(Foo).declarations[new Symbol('biz')]); + expect( + 'Method(s(foo) in s(Foo), static)', + reflectClass(Foo).declarations[new Symbol('foo')], + ); + expect( + 'Variable(s(bar) in s(Foo), static)', + reflectClass(Foo).declarations[new Symbol('bar')], + ); + expect( + 'Variable(s(biz) in s(Foo), static, final, const)', + reflectClass(Foo).declarations[new Symbol('biz')], + ); } diff --git a/tests/lib/mirrors/stringify.dart b/tests/lib/mirrors/stringify.dart index 2aa52209732..bc3aa3db46d 100644 --- a/tests/lib/mirrors/stringify.dart +++ b/tests/lib/mirrors/stringify.dart @@ -125,8 +125,9 @@ String stringifyDependencies(LibraryMirror l) { } return a.prefix == null ? 1 : -1; } - return n(a.targetLibrary.simpleName) - .compareTo(n(b.targetLibrary.simpleName)); + return n( + a.targetLibrary.simpleName, + ).compareTo(n(b.targetLibrary.simpleName)); } int compareCom(a, b) => n(a.identifier).compareTo(n(b.identifier)); diff --git a/tests/lib/mirrors/superclass_test.dart b/tests/lib/mirrors/superclass_test.dart index 19aada82089..02258afd237 100644 --- a/tests/lib/mirrors/superclass_test.dart +++ b/tests/lib/mirrors/superclass_test.dart @@ -15,6 +15,9 @@ main() { var superclass = cls.superclass; Expect.isNotNull(superclass, 'Failed to obtain superclass of MyClass.'); Expect.equals( - reflectClass(Object), superclass, 'Superclass of MyClass is not Object.'); + reflectClass(Object), + superclass, + 'Superclass of MyClass is not Object.', + ); Expect.isNull(superclass!.superclass, 'Superclass of Object is not null.'); } diff --git a/tests/lib/mirrors/synthetic_accessor_properties_test.dart b/tests/lib/mirrors/synthetic_accessor_properties_test.dart index cb32c8a7f12..ba39a5936a8 100644 --- a/tests/lib/mirrors/synthetic_accessor_properties_test.dart +++ b/tests/lib/mirrors/synthetic_accessor_properties_test.dart @@ -36,9 +36,10 @@ main() { Expect.equals(reflectClass(String), mm.returnType); pm = mm.parameters.single; expect( - 'Parameter(s(instanceField) in s(instanceField=), final,' - ' type = Class(s(String) in s(dart.core), top-level))', - pm); + 'Parameter(s(instanceField) in s(instanceField=), final,' + ' type = Class(s(String) in s(dart.core), top-level))', + pm, + ); mm = cm.instanceMembers[#finalInstanceField] as MethodMirror; expect('Method(s(finalInstanceField) in s(C), synthetic, getter)', mm); @@ -57,9 +58,10 @@ main() { Expect.equals(reflectClass(bool), mm.returnType); pm = mm.parameters.single; expect( - 'Parameter(s(staticField) in s(staticField=), final,' - ' type = Class(s(bool) in s(dart.core), top-level))', - pm); + 'Parameter(s(staticField) in s(staticField=), final,' + ' type = Class(s(bool) in s(dart.core), top-level))', + pm, + ); mm = cm.staticMembers[#finalStaticField] as MethodMirror; expect('Method(s(finalStaticField) in s(C), synthetic, static, getter)', mm); diff --git a/tests/lib/mirrors/to_string_test.dart b/tests/lib/mirrors/to_string_test.dart index 23a04990f6c..0246898612c 100644 --- a/tests/lib/mirrors/to_string_test.dart +++ b/tests/lib/mirrors/to_string_test.dart @@ -19,8 +19,10 @@ main() { var mirrors = currentMirrorSystem(); expect("TypeMirror on 'dynamic'", mirrors.dynamicType); expect("TypeMirror on 'void'", mirrors.voidType); - expect("LibraryMirror on 'test.to_string_test'", - mirrors.findLibrary(#test.to_string_test)); + expect( + "LibraryMirror on 'test.to_string_test'", + mirrors.findLibrary(#test.to_string_test), + ); expect("InstanceMirror on 1", reflect(1)); expect("ClassMirror on 'Foo'", reflectClass(Foo)); expect("VariableMirror on 'field'", reflectClass(Foo).declarations[#field]); diff --git a/tests/lib/mirrors/typearguments_mirror_test.dart b/tests/lib/mirrors/typearguments_mirror_test.dart index a5474d52b65..a61f5e155d9 100644 --- a/tests/lib/mirrors/typearguments_mirror_test.dart +++ b/tests/lib/mirrors/typearguments_mirror_test.dart @@ -36,39 +36,53 @@ main() { var cm3 = reflect(new Bar, Set>()).type; expect( - '[Class(s(List) in s(dart.core), top-level),' - ' Class(s(Set) in s(dart.core), top-level)]', - cm.typeArguments); + '[Class(s(List) in s(dart.core), top-level),' + ' Class(s(Set) in s(dart.core), top-level)]', + cm.typeArguments, + ); expect( - '[Class(s(List) in s(dart.core), top-level),' - ' Class(s(Set) in s(dart.core), top-level)]', - cm1.typeArguments); + '[Class(s(List) in s(dart.core), top-level),' + ' Class(s(Set) in s(dart.core), top-level)]', + cm1.typeArguments, + ); expect( - '[Class(s(List) in s(dart.core), top-level),' - ' Class(s(Set) in s(dart.core), top-level)]', - cm2.typeArguments); + '[Class(s(List) in s(dart.core), top-level),' + ' Class(s(Set) in s(dart.core), top-level)]', + cm2.typeArguments, + ); expect( - '[Class(s(List) in s(dart.core), top-level),' - ' Class(s(Set) in s(dart.core), top-level)]', - cm3.typeArguments); + '[Class(s(List) in s(dart.core), top-level),' + ' Class(s(Set) in s(dart.core), top-level)]', + cm3.typeArguments, + ); - expect('[Class(s(String) in s(dart.core), top-level)]', - cm1.typeArguments[1].typeArguments); - expect('[Class(s(String) in s(dart.core), top-level)]', - cm2.typeArguments[0].typeArguments); - expect('[Class(s(String) in s(dart.core), top-level)]', - cm3.typeArguments[0].typeArguments); - expect('[Class(s(String) in s(dart.core), top-level)]', - cm3.typeArguments[1].typeArguments); + expect( + '[Class(s(String) in s(dart.core), top-level)]', + cm1.typeArguments[1].typeArguments, + ); + expect( + '[Class(s(String) in s(dart.core), top-level)]', + cm2.typeArguments[0].typeArguments, + ); + expect( + '[Class(s(String) in s(dart.core), top-level)]', + cm3.typeArguments[0].typeArguments, + ); + expect( + '[Class(s(String) in s(dart.core), top-level)]', + cm3.typeArguments[1].typeArguments, + ); var cm4 = reflect(new Bar, String>()).type; expect( - '[Class(s(Bar) in s(lib), top-level),' - ' Class(s(String) in s(dart.core), top-level)]', - cm4.typeArguments); + '[Class(s(Bar) in s(lib), top-level),' + ' Class(s(String) in s(dart.core), top-level)]', + cm4.typeArguments, + ); expect( - '[Class(s(List) in s(dart.core), top-level), ' - 'Class(s(Set) in s(dart.core), top-level)]', - cm4.typeArguments[0].typeArguments); + '[Class(s(List) in s(dart.core), top-level), ' + 'Class(s(Set) in s(dart.core), top-level)]', + cm4.typeArguments[0].typeArguments, + ); }