Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(298)

Issues Search
    My Issues | Starred     Open | Closed | All

Unified Diff: pkg/analyzer/test/generated/compile_time_error_code_test.dart

Issue 682553002: Convert most of the EngineTestCase.createSource invocations into multi-line String literals. (Closed) Base URL: https://dart.googlecode.com/svn/branches/bleeding_edge/dart
Patch Set: Created 6 years, 2 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View side-by-side diff with in-line comments
Download patch
« no previous file with comments | « pkg/analyzer/test/generated/ast_test.dart ('k') | pkg/analyzer/test/generated/element_test.dart » ('j') | no next file with comments »
Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
Index: pkg/analyzer/test/generated/compile_time_error_code_test.dart
diff --git a/pkg/analyzer/test/generated/compile_time_error_code_test.dart b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
index 444f03df6c5bf37cb7b171fac10c504555ad0a1f..8ea16745d22ab5d335dfc94444a4e9ae7fb75475 100644
--- a/pkg/analyzer/test/generated/compile_time_error_code_test.dart
+++ b/pkg/analyzer/test/generated/compile_time_error_code_test.dart
@@ -10,24 +10,24 @@ import 'package:analyzer/src/generated/parser.dart' show ParserErrorCode;
import 'package:analyzer/src/generated/engine.dart';
import 'package:unittest/unittest.dart' as _ut;
import 'resolver_test.dart';
-import 'test_support.dart';
import '../reflective_tests.dart';
class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_compileTimeConstantRaisesException() {
- Source source = addSource(EngineTestCase.createSource([]));
+ Source source = addSource(r'''
+''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.COMPILE_TIME_CONSTANT_RAISES_EXCEPTION]);
verify([source]);
}
void fail_constEvalThrowsException() {
- Source source = addSource(EngineTestCase.createSource([
- "class C {",
- " const C();",
- "}",
- "f() { return const C(); }"]));
+ Source source = addSource(r'''
+class C {
+ const C();
+}
+f() { return const C(); }''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_THROWS_EXCEPTION]);
verify([source]);
@@ -36,12 +36,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_invalidIdentifierInAsync_async() {
// TODO(brianwilkerson) Report this error.
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() async {",
- " int async;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() async {
+ int async;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_IDENTIFIER_IN_ASYNC]);
verify([source]);
@@ -50,12 +50,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_invalidIdentifierInAsync_await() {
// TODO(brianwilkerson) Report this error.
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() async {",
- " int await;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() async {
+ int await;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_IDENTIFIER_IN_ASYNC]);
verify([source]);
@@ -64,23 +64,23 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_invalidIdentifierInAsync_yield() {
// TODO(brianwilkerson) Report this error.
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() async {",
- " int yield;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() async {
+ int yield;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_IDENTIFIER_IN_ASYNC]);
verify([source]);
}
void fail_mixinDeclaresConstructor() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A() {}",
- "}",
- "class B extends Object mixin A {}"]));
+ Source source = addSource(r'''
+class A {
+ A() {}
+}
+class B extends Object mixin A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
verify([source]);
@@ -88,39 +88,45 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_mixinOfNonClass() {
// TODO(brianwilkerson) Compare with MIXIN_WITH_NON_CLASS_SUPERCLASS.
- Source source = addSource(EngineTestCase.createSource(["var A;", "class B extends Object mixin A {}"]));
+ Source source = addSource(r'''
+var A;
+class B extends Object mixin A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
verify([source]);
}
void fail_objectCannotExtendAnotherClass() {
- Source source = addSource(EngineTestCase.createSource([]));
+ Source source = addSource(r'''
+''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.OBJECT_CANNOT_EXTEND_ANOTHER_CLASS]);
verify([source]);
}
void fail_recursiveCompileTimeConstant() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- " final m = const A();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+ final m = const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
verify([source]);
}
void fail_recursiveCompileTimeConstant_cycle() {
- Source source = addSource(EngineTestCase.createSource(["const x = y + 1;", "const y = x + 1;"]));
+ Source source = addSource(r'''
+const x = y + 1;
+const y = x + 1;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_COMPILE_TIME_CONSTANT]);
verify([source]);
}
void fail_superInitializerInObject() {
- Source source = addSource(EngineTestCase.createSource([]));
+ Source source = addSource(r'''
+''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_INITIALIZER_IN_OBJECT]);
verify([source]);
@@ -129,7 +135,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_yieldEachInNonGenerator_async() {
// TODO(brianwilkerson) We are currently parsing the yield statement as a binary expression.
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f() async {", " yield* 0;", "}"]));
+ Source source = addSource(r'''
+f() async {
+ yield* 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.YIELD_EACH_IN_NON_GENERATOR]);
verify([source]);
@@ -138,7 +147,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_yieldEachInNonGenerator_sync() {
// TODO(brianwilkerson) We are currently parsing the yield statement as a binary expression.
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f() {", " yield* 0;", "}"]));
+ Source source = addSource(r'''
+f() {
+ yield* 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.YIELD_IN_NON_GENERATOR]);
verify([source]);
@@ -147,7 +159,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_yieldInNonGenerator_async() {
// TODO(brianwilkerson) We are currently trying to parse the yield statement as a binary expression.
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f() async {", " yield 0;", "}"]));
+ Source source = addSource(r'''
+f() async {
+ yield 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.YIELD_IN_NON_GENERATOR]);
verify([source]);
@@ -156,7 +171,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void fail_yieldInNonGenerator_sync() {
// TODO(brianwilkerson) We are currently trying to parse the yield statement as a binary expression.
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f() {", " yield 0;", "}"]));
+ Source source = addSource(r'''
+f() {
+ yield 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.YIELD_EACH_IN_NON_GENERATOR]);
verify([source]);
@@ -166,30 +184,38 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
analysisOptions.enableEnum = true;
resetWithOptions(analysisOptions);
- Source source = addSource(EngineTestCase.createSource([
- "enum E { ONE }",
- "String name(E e) {",
- " return e._name;",
- "}"]));
+ Source source = addSource(r'''
+enum E { ONE }
+String name(E e) {
+ return e._name;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.ACCESS_PRIVATE_ENUM_FIELD]);
// Cannot verify because "_name" cannot be resolved.
}
void test_ambiguousExport() {
- Source source = addSource(EngineTestCase.createSource([
- "library L;",
- "export 'lib1.dart';",
- "export 'lib2.dart';"]));
- addNamedSource("/lib1.dart", EngineTestCase.createSource(["library lib1;", "class N {}"]));
- addNamedSource("/lib2.dart", EngineTestCase.createSource(["library lib2;", "class N {}"]));
+ Source source = addSource(r'''
+library L;
+export 'lib1.dart';
+export 'lib2.dart';''');
+ addNamedSource("/lib1.dart", r'''
+library lib1;
+class N {}''');
+ addNamedSource("/lib2.dart", r'''
+library lib2;
+class N {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.AMBIGUOUS_EXPORT]);
verify([source]);
}
void test_asyncForInWrongContext() {
- Source source = addSource(EngineTestCase.createSource(["f(list) {", " await for (var e in list) {", " }", "}"]));
+ Source source = addSource(r'''
+f(list) {
+ await for (var e in list) {
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.ASYNC_FOR_IN_WRONG_CONTEXT]);
verify([source]);
@@ -197,7 +223,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_awaitInWrongContext_sync() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f(x) {", " return await x;", "}"]));
+ Source source = addSource(r'''
+f(x) {
+ return await x;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT]);
verify([source]);
@@ -205,186 +234,226 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_awaitInWrongContext_syncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f(x) sync* {", " yield await x;", "}"]));
+ Source source = addSource(r'''
+f(x) sync* {
+ yield await x;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.AWAIT_IN_WRONG_CONTEXT]);
verify([source]);
}
void test_builtInIdentifierAsMixinName_classTypeAlias() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class B {}", "class as = A with B;"]));
+ Source source = addSource(r'''
+class A {}
+class B {}
+class as = A with B;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
verify([source]);
}
void test_builtInIdentifierAsType_formalParameter_field() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " var x;", " A(static this.x);", "}"]));
+ Source source = addSource(r'''
+class A {
+ var x;
+ A(static this.x);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
verify([source]);
}
void test_builtInIdentifierAsType_formalParameter_simple() {
- Source source = addSource(EngineTestCase.createSource(["f(static x) {", "}"]));
+ Source source = addSource(r'''
+f(static x) {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
verify([source]);
}
void test_builtInIdentifierAsType_variableDeclaration() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " typedef x;", "}"]));
+ Source source = addSource(r'''
+f() {
+ typedef x;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE]);
verify([source]);
}
void test_builtInIdentifierAsTypedefName_functionTypeAlias() {
- Source source = addSource(EngineTestCase.createSource(["typedef bool as();"]));
+ Source source = addSource("typedef bool as();");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPEDEF_NAME]);
verify([source]);
}
void test_builtInIdentifierAsTypeName() {
- Source source = addSource(EngineTestCase.createSource(["class as {}"]));
+ Source source = addSource("class as {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_NAME]);
verify([source]);
}
void test_builtInIdentifierAsTypeParameterName() {
- Source source = addSource(EngineTestCase.createSource(["class A<as> {}"]));
+ Source source = addSource("class A<as> {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.BUILT_IN_IDENTIFIER_AS_TYPE_PARAMETER_NAME]);
verify([source]);
}
void test_caseExpressionTypeImplementsEquals() {
- Source source = addSource(EngineTestCase.createSource([
- "class IntWrapper {",
- " final int value;",
- " const IntWrapper(this.value);",
- " bool operator ==(IntWrapper x) {",
- " return value == x.value;",
- " }",
- " get hashCode => value;",
- "}",
- "",
- "f(var a) {",
- " switch(a) {",
- " case(const IntWrapper(1)) : return 1;",
- " default: return 0;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class IntWrapper {
+ final int value;
+ const IntWrapper(this.value);
+ bool operator ==(IntWrapper x) {
+ return value == x.value;
+ }
+ get hashCode => value;
+}
+
+f(var a) {
+ switch(a) {
+ case(const IntWrapper(1)) : return 1;
+ default: return 0;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CASE_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
verify([source]);
}
void test_conflictingConstructorNameAndMember_field() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " A.x() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ A.x() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_FIELD]);
verify([source]);
}
void test_conflictingConstructorNameAndMember_method() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " const A.x();", " void x() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ const A.x();
+ void x() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_CONSTRUCTOR_NAME_AND_METHOD]);
verify([source]);
}
void test_conflictingGetterAndMethod_field_method() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final int m = 0;",
- "}",
- "class B extends A {",
- " m() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ final int m = 0;
+}
+class B extends A {
+ m() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
verify([source]);
}
void test_conflictingGetterAndMethod_getter_method() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " get m => 0;",
- "}",
- "class B extends A {",
- " m() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ get m => 0;
+}
+class B extends A {
+ m() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_GETTER_AND_METHOD]);
verify([source]);
}
void test_conflictingGetterAndMethod_method_field() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {}",
- "}",
- "class B extends A {",
- " int m;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+}
+class B extends A {
+ int m;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
verify([source]);
}
void test_conflictingGetterAndMethod_method_getter() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {}",
- "}",
- "class B extends A {",
- " get m => 0;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+}
+class B extends A {
+ get m => 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_METHOD_AND_GETTER]);
verify([source]);
}
void test_conflictingTypeVariableAndClass() {
- Source source = addSource(EngineTestCase.createSource(["class T<T> {", "}"]));
+ Source source = addSource(r'''
+class T<T> {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_CLASS]);
verify([source]);
}
void test_conflictingTypeVariableAndMember_field() {
- Source source = addSource(EngineTestCase.createSource(["class A<T> {", " var T;", "}"]));
+ Source source = addSource(r'''
+class A<T> {
+ var T;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
verify([source]);
}
void test_conflictingTypeVariableAndMember_getter() {
- Source source = addSource(EngineTestCase.createSource(["class A<T> {", " get T => null;", "}"]));
+ Source source = addSource(r'''
+class A<T> {
+ get T => null;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
verify([source]);
}
void test_conflictingTypeVariableAndMember_method() {
- Source source = addSource(EngineTestCase.createSource(["class A<T> {", " T() {}", "}"]));
+ Source source = addSource(r'''
+class A<T> {
+ T() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
verify([source]);
}
void test_conflictingTypeVariableAndMember_method_static() {
- Source source = addSource(EngineTestCase.createSource(["class A<T> {", " static T() {}", "}"]));
+ Source source = addSource(r'''
+class A<T> {
+ static T() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
verify([source]);
}
void test_conflictingTypeVariableAndMember_setter() {
- Source source = addSource(EngineTestCase.createSource(["class A<T> {", " set T(x) {}", "}"]));
+ Source source = addSource(r'''
+class A<T> {
+ set T(x) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONFLICTING_TYPE_VARIABLE_AND_MEMBER]);
verify([source]);
@@ -393,102 +462,102 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_consistentCaseExpressionTypes_dynamic() {
// Even though A.S and S have a static type of "dynamic", we should see
// that they match 'abc', because they are constant strings.
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static const S = 'A.S';",
- "}",
- "",
- "const S = 'S';",
- "",
- "foo(var p) {",
- " switch (p) {",
- " case S:",
- " break;",
- " case A.S:",
- " break;",
- " case 'abc':",
- " break;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static const S = 'A.S';
+}
+
+const S = 'S';
+
+foo(var p) {
+ switch (p) {
+ case S:
+ break;
+ case A.S:
+ break;
+ case 'abc':
+ break;
+ }
+}''');
resolve(source);
assertNoErrors(source);
verify([source]);
}
void test_constConstructorWithFieldInitializedByNonConst() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final int i = f();",
- " const A();",
- "}",
- "int f() {",
- " return 3;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ final int i = f();
+ const A();
+}
+int f() {
+ return 3;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_FIELD_INITIALIZED_BY_NON_CONST]);
verify([source]);
}
void test_constConstructorWithFieldInitializedByNonConst_static() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static final int i = f();",
- " const A();",
- "}",
- "int f() {",
- " return 3;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static final int i = f();
+ const A();
+}
+int f() {
+ return 3;
+}''');
resolve(source);
assertNoErrors(source);
verify([source]);
}
void test_constConstructorWithMixin() {
- Source source = addSource(EngineTestCase.createSource([
- "class M {",
- "}",
- "class A extends Object with M {",
- " const A();",
- "}"]));
+ Source source = addSource(r'''
+class M {
+}
+class A extends Object with M {
+ const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_MIXIN]);
verify([source]);
}
void test_constConstructorWithNonConstSuper_explicit() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A();",
- "}",
- "class B extends A {",
- " const B(): super();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A();
+}
+class B extends A {
+ const B(): super();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
verify([source]);
}
void test_constConstructorWithNonConstSuper_implicit() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A();",
- "}",
- "class B extends A {",
- " const B();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A();
+}
+class B extends A {
+ const B();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_CONST_SUPER]);
verify([source]);
}
void test_constConstructorWithNonFinalField_mixin() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " var a;",
- "}",
- "class B extends Object with A {",
- " const B();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ var a;
+}
+class B extends Object with A {
+ const B();
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_MIXIN,
@@ -497,13 +566,13 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_constConstructorWithNonFinalField_super() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " var a;",
- "}",
- "class B extends A {",
- " const B();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ var a;
+}
+class B extends A {
+ const B();
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD,
@@ -512,7 +581,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_constConstructorWithNonFinalField_this() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " const A();", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_CONSTRUCTOR_WITH_NON_FINAL_FIELD]);
verify([source]);
@@ -520,28 +593,40 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_constDeferredClass() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {", " const A();", "}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "main() {",
- " const a.A();",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {
+ const A();
+}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+main() {
+ const a.A();
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
}
void test_constDeferredClass_namedConstructor() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {", " const A.b();", "}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "main() {",
- " const a.A.b();",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {
+ const A.b();
+}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+main() {
+ const a.A.b();
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_DEFERRED_CLASS]);
}
void test_constEval_newInstance_constConstructor() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", "}", "const a = new A();"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+const a = new A();''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
verify([source]);
@@ -550,24 +635,24 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_constEval_newInstance_externalFactoryConstConstructor() {
// We can't evaluate "const A()" because its constructor is external. But
// the code is correct--we shouldn't report an error.
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " external factory const A();",
- "}",
- "const x = const A();"]));
+ Source source = addSource(r'''
+class A {
+ external factory const A();
+}
+const x = const A();''');
resolve(source);
assertNoErrors(source);
verify([source]);
}
void test_constEval_propertyExtraction_targetNotConst() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- " m() {}",
- "}",
- "final a = const A();",
- "const C = a.m;"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+ m() {}
+}
+final a = const A();
+const C = a.m;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
verify([source]);
@@ -627,28 +712,28 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_constEvalTypeBoolNumString_equal() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- "}",
- "class B {",
- " final a;",
- " const B(num p) : a = p == const A();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+class B {
+ final a;
+ const B(num p) : a = p == const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
verify([source]);
}
void test_constEvalTypeBoolNumString_notEqual() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- "}",
- "class B {",
- " final a;",
- " const B(String p) : a = p != const A();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+class B {
+ final a;
+ const B(String p) : a = p != const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL_NUM_STRING]);
verify([source]);
@@ -676,21 +761,28 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_constFormalParameter_fieldFormalParameter() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " var x;", " A(const this.x) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ var x;
+ A(const this.x) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
verify([source]);
}
void test_constFormalParameter_simpleFormalParameter() {
- Source source = addSource(EngineTestCase.createSource(["f(const x) {}"]));
+ Source source = addSource("f(const x) {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
verify([source]);
}
void test_constInitializedWithNonConstValue() {
- Source source = addSource(EngineTestCase.createSource(["f(p) {", " const C = p;", "}"]));
+ Source source = addSource(r'''
+f(p) {
+ const C = p;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
verify([source]);
@@ -712,38 +804,45 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_constInitializedWithNonConstValueFromDeferredClass() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const V = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "const B = a.V;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const V = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+const B = a.V;'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY]);
}
void test_constInitializedWithNonConstValueFromDeferredClass_nested() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const V = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "const B = a.V + 1;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const V = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+const B = a.V + 1;'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE_FROM_DEFERRED_LIBRARY]);
}
void test_constInstanceField() {
- Source source = addSource(EngineTestCase.createSource(["class C {", " const int f = 0;", "}"]));
+ Source source = addSource(r'''
+class C {
+ const int f = 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_INSTANCE_FIELD]);
verify([source]);
}
void test_constMapKeyTypeImplementsEquals_direct() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- " operator ==(other) => false;",
- "}",
- "main() {",
- " const {const A() : 0};",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+ operator ==(other) => false;
+}
+main() {
+ const {const A() : 0};
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
verify([source]);
@@ -753,134 +852,138 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
// Note: static type of B.a is "dynamic", but actual type of the const
// object is A. We need to make sure we examine the actual type when
// deciding whether there is a problem with operator==.
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- " operator ==(other) => false;",
- "}",
- "class B {",
- " static const a = const A();",
- "}",
- "main() {",
- " const {B.a : 0};",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+ operator ==(other) => false;
+}
+class B {
+ static const a = const A();
+}
+main() {
+ const {B.a : 0};
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
verify([source]);
}
void test_constMapKeyTypeImplementsEquals_factory() {
- Source source = addSource(EngineTestCase.createSource([
- "class A { const factory A() = B; }",
- "",
- "class B implements A {",
- " const B();",
- "",
- " operator ==(o) => true;",
- "}",
- "",
- "main() {",
- " var m = const { const A(): 42 };",
- "}"]));
+ Source source = addSource(r'''
+class A { const factory A() = B; }
+
+class B implements A {
+ const B();
+
+ operator ==(o) => true;
+}
+
+main() {
+ var m = const { const A(): 42 };
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
verify([source]);
}
void test_constMapKeyTypeImplementsEquals_super() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- " operator ==(other) => false;",
- "}",
- "class B extends A {",
- " const B();",
- "}",
- "main() {",
- " const {const B() : 0};",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+ operator ==(other) => false;
+}
+class B extends A {
+ const B();
+}
+main() {
+ const {const B() : 0};
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_MAP_KEY_EXPRESSION_TYPE_IMPLEMENTS_EQUALS]);
verify([source]);
}
void test_constWithInvalidTypeParameters() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- "}",
- "f() { return const A<A>(); }"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+f() { return const A<A>(); }''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
verify([source]);
}
void test_constWithInvalidTypeParameters_tooFew() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class C<K, V> {",
- " const C();",
- "}",
- "f(p) {",
- " return const C<A>();",
- "}"]));
+ Source source = addSource(r'''
+class A {}
+class C<K, V> {
+ const C();
+}
+f(p) {
+ return const C<A>();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
verify([source]);
}
void test_constWithInvalidTypeParameters_tooMany() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class C<E> {",
- " const C();",
- "}",
- "f(p) {",
- " return const C<A, A>();",
- "}"]));
+ Source source = addSource(r'''
+class A {}
+class C<E> {
+ const C();
+}
+f(p) {
+ return const C<A, A>();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_INVALID_TYPE_PARAMETERS]);
verify([source]);
}
void test_constWithNonConst() {
- Source source = addSource(EngineTestCase.createSource([
- "class T {",
- " T(a, b, {c, d}) {}",
- "}",
- "f() { return const T(0, 1, c: 2, d: 3); }"]));
+ Source source = addSource(r'''
+class T {
+ T(a, b, {c, d}) {}
+}
+f() { return const T(0, 1, c: 2, d: 3); }''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONST]);
verify([source]);
}
void test_constWithNonConstantArgument_annotation() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A(int p);",
- "}",
- "var v = 42;",
- "@A(v)",
- "main() {",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A(int p);
+}
+var v = 42;
+@A(v)
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
verify([source]);
}
void test_constWithNonConstantArgument_instanceCreation() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A(a);",
- "}",
- "f(p) { return const A(p); }"]));
+ Source source = addSource(r'''
+class A {
+ const A(a);
+}
+f(p) { return const A(p); }''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_CONSTANT_ARGUMENT]);
verify([source]);
}
void test_constWithNonType() {
- Source source = addSource(EngineTestCase.createSource(["int A;", "f() {", " return const A();", "}"]));
+ Source source = addSource(r'''
+int A;
+f() {
+ return const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
verify([source]);
@@ -888,11 +991,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_constWithNonType_fromLibrary() {
Source source1 = addNamedSource("lib.dart", "");
- Source source2 = addNamedSource("lib2.dart", EngineTestCase.createSource([
- "import 'lib.dart' as lib;",
- "void f() {",
- " const lib.A();",
- "}"]));
+ Source source2 = addNamedSource("lib2.dart", r'''
+import 'lib.dart' as lib;
+void f() {
+ const lib.A();
+}''');
resolve(source1);
resolve(source2);
assertErrors(source2, [CompileTimeErrorCode.CONST_WITH_NON_TYPE]);
@@ -900,11 +1003,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_constWithTypeParameters_direct() {
- Source source = addSource(EngineTestCase.createSource([
- "class A<T> {",
- " static const V = const A<T>();",
- " const A();",
- "}"]));
+ Source source = addSource(r'''
+class A<T> {
+ static const V = const A<T>();
+ const A();
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS,
@@ -913,11 +1016,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_constWithTypeParameters_indirect() {
- Source source = addSource(EngineTestCase.createSource([
- "class A<T> {",
- " static const V = const A<List<T>>();",
- " const A();",
- "}"]));
+ Source source = addSource(r'''
+class A<T> {
+ static const V = const A<List<T>>();
+ const A();
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_WITH_TYPE_PARAMETERS,
@@ -926,68 +1029,72 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_constWithUndefinedConstructor() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- "}",
- "f() {",
- " return const A.noSuchConstructor();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+f() {
+ return const A.noSuchConstructor();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR]);
// no verify(), 'noSuchConstructor' is not resolved
}
void test_constWithUndefinedConstructorDefault() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A.name();",
- "}",
- "f() {",
- " return const A();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A.name();
+}
+f() {
+ return const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_WITH_UNDEFINED_CONSTRUCTOR_DEFAULT]);
verify([source]);
}
void test_defaultValueInFunctionTypeAlias() {
- Source source = addSource(EngineTestCase.createSource(["typedef F([x = 0]);"]));
+ Source source = addSource("typedef F([x = 0]);");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPE_ALIAS]);
verify([source]);
}
void test_defaultValueInFunctionTypedParameter_named() {
- Source source = addSource(EngineTestCase.createSource(["f(g({p: null})) {}"]));
+ Source source = addSource("f(g({p: null})) {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
verify([source]);
}
void test_defaultValueInFunctionTypedParameter_optional() {
- Source source = addSource(EngineTestCase.createSource(["f(g([p = null])) {}"]));
+ Source source = addSource("f(g([p = null])) {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_FUNCTION_TYPED_PARAMETER]);
verify([source]);
}
void test_defaultValueInRedirectingFactoryConstructor() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " factory A([int x = 0]) = B;",
- "}",
- "",
- "class B implements A {",
- " B([int x = 1]) {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ factory A([int x = 0]) = B;
+}
+
+class B implements A {
+ B([int x = 1]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DEFAULT_VALUE_IN_REDIRECTING_FACTORY_CONSTRUCTOR]);
verify([source]);
}
void test_duplicateConstructorName_named() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A.a() {}", " A.a() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A.a() {}
+ A.a() {}
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_NAME,
@@ -996,7 +1103,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_duplicateConstructorName_unnamed() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() {}", " A() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() {}
+ A() {}
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.DUPLICATE_CONSTRUCTOR_DEFAULT,
@@ -1005,164 +1116,202 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_duplicateDefinition() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " int m = 0;", " m(a) {}", "}"]));
+ Source source = addSource(r'''
+f() {
+ int m = 0;
+ m(a) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([source]);
}
void test_duplicateDefinition_acrossLibraries() {
- Source librarySource = addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "", "part 'a.dart';", "part 'b.dart';"]));
- Source sourceA = addNamedSource("/a.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
- Source sourceB = addNamedSource("/b.dart", EngineTestCase.createSource(["part of lib;", "", "class A {}"]));
+ Source librarySource = addNamedSource("/lib.dart", r'''
+library lib;
+
+part 'a.dart';
+part 'b.dart';''');
+ Source sourceA = addNamedSource("/a.dart", r'''
+part of lib;
+
+class A {}''');
+ Source sourceB = addNamedSource("/b.dart", r'''
+part of lib;
+
+class A {}''');
resolve(librarySource);
assertErrors(sourceB, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([librarySource, sourceA, sourceB]);
}
void test_duplicateDefinition_classMembers_fields() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int a;", " int a;", "}"]));
+ Source source = addSource(r'''
+class A {
+ int a;
+ int a;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([source]);
}
void test_duplicateDefinition_classMembers_fields_oneStatic() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " static int x;", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ static int x;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([source]);
}
void test_duplicateDefinition_classMembers_methods() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " m() {}", " m() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+ m() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([source]);
}
void test_duplicateDefinition_localFields() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {",
- " int a;",
- " int a;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {
+ int a;
+ int a;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([source]);
}
void test_duplicateDefinition_parameterWithFunctionName_local() {
- Source source = addSource(EngineTestCase.createSource(["main() {", " f(f) {}", "}"]));
+ Source source = addSource(r'''
+main() {
+ f(f) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([source]);
}
void test_duplicateDefinition_parameterWithFunctionName_topLevel() {
- Source source = addSource(EngineTestCase.createSource(["main() {", " f(f) {}", "}"]));
+ Source source = addSource(r'''
+main() {
+ f(f) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION]);
verify([source]);
}
void test_duplicateDefinitionInheritance_instanceGetter_staticGetter() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " int get x => 0;",
- "}",
- "class B extends A {",
- " static int get x => 0;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ int get x => 0;
+}
+class B extends A {
+ static int get x => 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
verify([source]);
}
void test_duplicateDefinitionInheritance_instanceGetterAbstract_staticGetter() {
- Source source = addSource(EngineTestCase.createSource([
- "abstract class A {",
- " int get x;",
- "}",
- "class B extends A {",
- " static int get x => 0;",
- "}"]));
+ Source source = addSource(r'''
+abstract class A {
+ int get x;
+}
+class B extends A {
+ static int get x => 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
verify([source]);
}
void test_duplicateDefinitionInheritance_instanceMethod_staticMethod() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " x() {}",
- "}",
- "class B extends A {",
- " static x() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ x() {}
+}
+class B extends A {
+ static x() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
verify([source]);
}
void test_duplicateDefinitionInheritance_instanceMethodAbstract_staticMethod() {
- Source source = addSource(EngineTestCase.createSource([
- "abstract class A {",
- " x();",
- "}",
- "abstract class B extends A {",
- " static x() {}",
- "}"]));
+ Source source = addSource(r'''
+abstract class A {
+ x();
+}
+abstract class B extends A {
+ static x() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
verify([source]);
}
void test_duplicateDefinitionInheritance_instanceSetter_staticSetter() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " set x(value) {}",
- "}",
- "class B extends A {",
- " static set x(value) {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ set x(value) {}
+}
+class B extends A {
+ static set x(value) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
verify([source]);
}
void test_duplicateDefinitionInheritance_instanceSetterAbstract_staticSetter() {
- Source source = addSource(EngineTestCase.createSource([
- "abstract class A {",
- " set x(value);",
- "}",
- "class B extends A {",
- " static set x(value) {}",
- "}"]));
+ Source source = addSource(r'''
+abstract class A {
+ set x(value);
+}
+class B extends A {
+ static set x(value) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_DEFINITION_INHERITANCE]);
verify([source]);
}
void test_duplicateNamedArgument() {
- Source source = addSource(EngineTestCase.createSource(["f({a, b}) {}", "main() {", " f(a: 1, a: 2);", "}"]));
+ Source source = addSource(r'''
+f({a, b}) {}
+main() {
+ f(a: 1, a: 2);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.DUPLICATE_NAMED_ARGUMENT]);
verify([source]);
}
void test_exportInternalLibrary() {
- Source source = addSource(EngineTestCase.createSource(["export 'dart:_interceptors';"]));
+ Source source = addSource("export 'dart:_interceptors';");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXPORT_INTERNAL_LIBRARY]);
verify([source]);
}
void test_exportOfNonLibrary() {
- Source source = addSource(EngineTestCase.createSource(["library L;", "export 'lib1.dart';"]));
- addNamedSource("/lib1.dart", EngineTestCase.createSource(["part of lib;"]));
+ Source source = addSource(r'''
+library L;
+export 'lib1.dart';''');
+ addNamedSource("/lib1.dart", "part of lib;");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXPORT_OF_NON_LIBRARY]);
verify([source]);
@@ -1170,25 +1319,29 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_extendsDeferredClass() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class B extends a.A {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class B extends a.A {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
}
void test_extendsDeferredClass_classTypeAlias() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class M {}",
- "class C = a.A with M;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class M {}
+class C = a.A with M;'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.EXTENDS_DEFERRED_CLASS]);
}
void test_extendsDisallowedClass_class_bool() {
- Source source = addSource(EngineTestCase.createSource(["class A extends bool {}"]));
+ Source source = addSource("class A extends bool {}");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
@@ -1197,7 +1350,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_extendsDisallowedClass_class_double() {
- Source source = addSource(EngineTestCase.createSource(["class A extends double {}"]));
+ Source source = addSource("class A extends double {}");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
@@ -1206,7 +1359,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_extendsDisallowedClass_class_int() {
- Source source = addSource(EngineTestCase.createSource(["class A extends int {}"]));
+ Source source = addSource("class A extends int {}");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
@@ -1215,7 +1368,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_extendsDisallowedClass_class_Null() {
- Source source = addSource(EngineTestCase.createSource(["class A extends Null {}"]));
+ Source source = addSource("class A extends Null {}");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
@@ -1224,7 +1377,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_extendsDisallowedClass_class_num() {
- Source source = addSource(EngineTestCase.createSource(["class A extends num {}"]));
+ Source source = addSource("class A extends num {}");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
@@ -1233,7 +1386,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_extendsDisallowedClass_class_String() {
- Source source = addSource(EngineTestCase.createSource(["class A extends String {}"]));
+ Source source = addSource("class A extends String {}");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS,
@@ -1242,42 +1395,54 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_extendsDisallowedClass_classTypeAlias_bool() {
- Source source = addSource(EngineTestCase.createSource(["class M {}", "class C = bool with M;"]));
+ Source source = addSource(r'''
+class M {}
+class C = bool with M;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
verify([source]);
}
void test_extendsDisallowedClass_classTypeAlias_double() {
- Source source = addSource(EngineTestCase.createSource(["class M {}", "class C = double with M;"]));
+ Source source = addSource(r'''
+class M {}
+class C = double with M;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
verify([source]);
}
void test_extendsDisallowedClass_classTypeAlias_int() {
- Source source = addSource(EngineTestCase.createSource(["class M {}", "class C = int with M;"]));
+ Source source = addSource(r'''
+class M {}
+class C = int with M;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
verify([source]);
}
void test_extendsDisallowedClass_classTypeAlias_Null() {
- Source source = addSource(EngineTestCase.createSource(["class M {}", "class C = Null with M;"]));
+ Source source = addSource(r'''
+class M {}
+class C = Null with M;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
verify([source]);
}
void test_extendsDisallowedClass_classTypeAlias_num() {
- Source source = addSource(EngineTestCase.createSource(["class M {}", "class C = num with M;"]));
+ Source source = addSource(r'''
+class M {}
+class C = num with M;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
verify([source]);
}
void test_extendsDisallowedClass_classTypeAlias_String() {
- Source source = addSource(EngineTestCase.createSource(["class M {}", "class C = String with M;"]));
+ Source source = addSource(r'''
+class M {}
+class C = String with M;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_DISALLOWED_CLASS]);
verify([source]);
@@ -1287,65 +1452,73 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
analysisOptions.enableEnum = true;
resetWithOptions(analysisOptions);
- Source source = addSource(EngineTestCase.createSource(["enum E { ONE }", "class A extends E {}"]));
+ Source source = addSource(r'''
+enum E { ONE }
+class A extends E {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_ENUM]);
verify([source]);
}
void test_extendsNonClass_class() {
- Source source = addSource(EngineTestCase.createSource(["int A;", "class B extends A {}"]));
+ Source source = addSource(r'''
+int A;
+class B extends A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_NON_CLASS]);
verify([source]);
}
void test_extendsNonClass_dynamic() {
- Source source = addSource(EngineTestCase.createSource(["class B extends dynamic {}"]));
+ Source source = addSource("class B extends dynamic {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTENDS_NON_CLASS]);
verify([source]);
}
void test_extraPositionalArguments_const() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- "}",
- "main() {",
- " const A(0);",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+main() {
+ const A(0);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS]);
verify([source]);
}
void test_extraPositionalArguments_const_super() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- "}",
- "class B extends A {",
- " const B() : super(0);",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+class B extends A {
+ const B() : super(0);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.EXTRA_POSITIONAL_ARGUMENTS]);
verify([source]);
}
void test_fieldInitializedByMultipleInitializers() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " A() : x = 0, x = 1 {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ A() : x = 0, x = 1 {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
verify([source]);
}
void test_fieldInitializedByMultipleInitializers_multipleInits() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " int x;",
- " A() : x = 0, x = 1, x = 2 {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ A() : x = 0, x = 1, x = 2 {}
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
@@ -1354,12 +1527,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_fieldInitializedByMultipleInitializers_multipleNames() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " int x;",
- " int y;",
- " A() : x = 0, x = 1, y = 0, y = 1 {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ int y;
+ A() : x = 0, x = 1, y = 0, y = 1 {}
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS,
@@ -1368,14 +1541,22 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_fieldInitializedInParameterAndInitializer() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " A(this.x) : x = 1 {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ A(this.x) : x = 1 {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
verify([source]);
}
void test_fieldInitializerFactoryConstructor() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " factory A(this.x) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ factory A(this.x) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_FACTORY_CONSTRUCTOR]);
verify([source]);
@@ -1383,7 +1564,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_fieldInitializerOutsideConstructor() {
// TODO(brianwilkerson) Fix the duplicate error messages.
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " m(this.x) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ m(this.x) {}
+}''');
resolve(source);
assertErrors(source, [
ParserErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR,
@@ -1392,50 +1577,58 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_fieldInitializerOutsideConstructor_defaultParameter() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int x;", " m([this.x]) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ m([this.x]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_OUTSIDE_CONSTRUCTOR]);
verify([source]);
}
void test_fieldInitializerRedirectingConstructor_afterRedirection() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " int x;",
- " A.named() {}",
- " A() : this.named(), x = 42;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ A.named() {}
+ A() : this.named(), x = 42;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
verify([source]);
}
void test_fieldInitializerRedirectingConstructor_beforeRedirection() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " int x;",
- " A.named() {}",
- " A() : x = 42, this.named();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ A.named() {}
+ A() : x = 42, this.named();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
verify([source]);
}
void test_fieldInitializingFormalRedirectingConstructor() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " int x;",
- " A.named() {}",
- " A(this.x) : this.named();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ int x;
+ A.named() {}
+ A(this.x) : this.named();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZER_REDIRECTING_CONSTRUCTOR]);
verify([source]);
}
void test_finalInitializedMultipleTimes_initializers() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " final x;", " A() : x = 0, x = 0 {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ final x;
+ A() : x = 0, x = 0 {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_BY_MULTIPLE_INITIALIZERS]);
verify([source]);
@@ -1450,44 +1643,58 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
* FINAL_INITIALIZED_MULTIPLE_TIMES, since it more specific, we use it instead of the broader code
*/
void test_finalInitializedMultipleTimes_initializingFormal_initializer() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " final x;", " A(this.x) : x = 0 {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ final x;
+ A(this.x) : x = 0 {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FIELD_INITIALIZED_IN_PARAMETER_AND_INITIALIZER]);
verify([source]);
}
void test_finalInitializedMultipleTimes_initializingFormals() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " final x;", " A(this.x, this.x) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ final x;
+ A(this.x, this.x) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.FINAL_INITIALIZED_MULTIPLE_TIMES]);
verify([source]);
}
void test_finalNotInitialized_instanceField_const_static() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " static const F;", "}"]));
+ Source source = addSource(r'''
+class A {
+ static const F;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
verify([source]);
}
void test_finalNotInitialized_library_const() {
- Source source = addSource(EngineTestCase.createSource(["const F;"]));
+ Source source = addSource("const F;");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
verify([source]);
}
void test_finalNotInitialized_local_const() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " const int x;", "}"]));
+ Source source = addSource(r'''
+f() {
+ const int x;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.CONST_NOT_INITIALIZED]);
verify([source]);
}
void test_fromEnvironment_bool_badArgs() {
- Source source = addSource(EngineTestCase.createSource([
- "var b1 = const bool.fromEnvironment(1);",
- "var b2 = const bool.fromEnvironment('x', defaultValue: 1);"]));
+ Source source = addSource(r'''
+var b1 = const bool.fromEnvironment(1);
+var b2 = const bool.fromEnvironment('x', defaultValue: 1);''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
@@ -1501,7 +1708,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
// The type of the defaultValue needs to be correct even when the default value
// isn't used (because the variable is defined in the environment).
analysisContext2.declaredVariables.define("x", "true");
- Source source = addSource(EngineTestCase.createSource(["var b = const bool.fromEnvironment('x', defaultValue: 1);"]));
+ Source source = addSource("var b = const bool.fromEnvironment('x', defaultValue: 1);");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
@@ -1510,7 +1717,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_getterAndMethodWithSameName() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " x(y) {}", " get x => 0;", "}"]));
+ Source source = addSource(r'''
+class A {
+ x(y) {}
+ get x => 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.GETTER_AND_METHOD_WITH_SAME_NAME]);
verify([source]);
@@ -1518,68 +1729,72 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_implementsDeferredClass() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class B implements a.A {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class B implements a.A {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
}
void test_implementsDeferredClass_classTypeAlias() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class B {}",
- "class M {}",
- "class C = B with M implements a.A;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class B {}
+class M {}
+class C = B with M implements a.A;'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.IMPLEMENTS_DEFERRED_CLASS]);
}
void test_implementsDisallowedClass_class_bool() {
- Source source = addSource(EngineTestCase.createSource(["class A implements bool {}"]));
+ Source source = addSource("class A implements bool {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_class_double() {
- Source source = addSource(EngineTestCase.createSource(["class A implements double {}"]));
+ Source source = addSource("class A implements double {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_class_int() {
- Source source = addSource(EngineTestCase.createSource(["class A implements int {}"]));
+ Source source = addSource("class A implements int {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_class_Null() {
- Source source = addSource(EngineTestCase.createSource(["class A implements Null {}"]));
+ Source source = addSource("class A implements Null {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_class_num() {
- Source source = addSource(EngineTestCase.createSource(["class A implements num {}"]));
+ Source source = addSource("class A implements num {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_class_String() {
- Source source = addSource(EngineTestCase.createSource(["class A implements String {}"]));
+ Source source = addSource("class A implements String {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_class_String_num() {
- Source source = addSource(EngineTestCase.createSource(["class A implements String, num {}"]));
+ Source source = addSource("class A implements String, num {}");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
@@ -1588,70 +1803,70 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_implementsDisallowedClass_classTypeAlias_bool() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class C = A with M implements bool;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class C = A with M implements bool;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_classTypeAlias_double() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class C = A with M implements double;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class C = A with M implements double;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_classTypeAlias_int() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class C = A with M implements int;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class C = A with M implements int;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_classTypeAlias_Null() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class C = A with M implements Null;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class C = A with M implements Null;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_classTypeAlias_num() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class C = A with M implements num;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class C = A with M implements num;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_classTypeAlias_String() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class C = A with M implements String;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class C = A with M implements String;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS]);
verify([source]);
}
void test_implementsDisallowedClass_classTypeAlias_String_num() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class C = A with M implements String, num;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class C = A with M implements String, num;''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.IMPLEMENTS_DISALLOWED_CLASS,
@@ -1660,7 +1875,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_implementsDynamic() {
- Source source = addSource(EngineTestCase.createSource(["class A implements dynamic {}"]));
+ Source source = addSource("class A implements dynamic {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_DYNAMIC]);
verify([source]);
@@ -1670,41 +1885,47 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
analysisOptions.enableEnum = true;
resetWithOptions(analysisOptions);
- Source source = addSource(EngineTestCase.createSource(["enum E { ONE }", "class A implements E {}"]));
+ Source source = addSource(r'''
+enum E { ONE }
+class A implements E {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_ENUM]);
verify([source]);
}
void test_implementsNonClass_class() {
- Source source = addSource(EngineTestCase.createSource(["int A;", "class B implements A {}"]));
+ Source source = addSource(r'''
+int A;
+class B implements A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
verify([source]);
}
void test_implementsNonClass_typeAlias() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "int B;",
- "class C = A with M implements B;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+int B;
+class C = A with M implements B;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_NON_CLASS]);
verify([source]);
}
void test_implementsRepeated() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class B implements A, A {}"]));
+ Source source = addSource(r'''
+class A {}
+class B implements A, A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_REPEATED]);
verify([source]);
}
void test_implementsRepeated_3times() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {} class C{}",
- "class B implements A, A, A, A {}"]));
+ Source source = addSource(r'''
+class A {} class C{}
+class B implements A, A, A, A {}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.IMPLEMENTS_REPEATED,
@@ -1714,85 +1935,95 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_implementsSuperClass() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class B extends A implements A {}"]));
+ Source source = addSource(r'''
+class A {}
+class B extends A implements A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS]);
verify([source]);
}
void test_implementsSuperClass_Object() {
- Source source = addSource(EngineTestCase.createSource(["class A implements Object {}"]));
+ Source source = addSource("class A implements Object {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLEMENTS_SUPER_CLASS]);
verify([source]);
}
void test_implicitThisReferenceInInitializer_field() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " var v;",
- " A() : v = f;",
- " var f;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ var v;
+ A() : v = f;
+ var f;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
verify([source]);
}
void test_implicitThisReferenceInInitializer_field2() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " final x = 0;", " final y = x;", "}"]));
+ Source source = addSource(r'''
+class A {
+ final x = 0;
+ final y = x;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
verify([source]);
}
void test_implicitThisReferenceInInitializer_invocation() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " var v;",
- " A() : v = f();",
- " f() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ var v;
+ A() : v = f();
+ f() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
verify([source]);
}
void test_implicitThisReferenceInInitializer_invocationInStatic() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " static var F = m();", " m() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ static var F = m();
+ m() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
verify([source]);
}
void test_implicitThisReferenceInInitializer_redirectingConstructorInvocation() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A(p) {}",
- " A.named() : this(f);",
- " var f;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A(p) {}
+ A.named() : this(f);
+ var f;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
verify([source]);
}
void test_implicitThisReferenceInInitializer_superConstructorInvocation() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A(p) {}",
- "}",
- "class B extends A {",
- " B() : super(f);",
- " var f;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A(p) {}
+}
+class B extends A {
+ B() : super(f);
+ var f;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPLICIT_THIS_REFERENCE_IN_INITIALIZER]);
verify([source]);
}
void test_importInternalLibrary() {
- Source source = addSource(EngineTestCase.createSource(["import 'dart:_interceptors';"]));
+ Source source = addSource("import 'dart:_interceptors';");
resolve(source);
// Note, in these error cases we may generate an UNUSED_IMPORT hint, while we could prevent
// the hint from being generated by testing the import directive for the error, this is such a
@@ -1805,7 +2036,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_importInternalLibrary_js_helper() {
- Source source = addSource(EngineTestCase.createSource(["import 'dart:_js_helper';"]));
+ Source source = addSource("import 'dart:_js_helper';");
resolve(source);
// Note, in these error cases we may generate an UNUSED_IMPORT hint, while we could prevent
// the hint from being generated by testing the import directive for the error, this is such a
@@ -1818,23 +2049,28 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_importOfNonLibrary() {
- Source source = addSource(EngineTestCase.createSource(["library lib;", "import 'part.dart';", "A a;"]));
- addNamedSource("/part.dart", EngineTestCase.createSource(["part of lib;", "class A{}"]));
+ Source source = addSource(r'''
+library lib;
+import 'part.dart';
+A a;''');
+ addNamedSource("/part.dart", r'''
+part of lib;
+class A{}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.IMPORT_OF_NON_LIBRARY]);
verify([source]);
}
void test_inconsistentCaseExpressionTypes() {
- Source source = addSource(EngineTestCase.createSource([
- "f(var p) {",
- " switch (p) {",
- " case 1:",
- " break;",
- " case 'a':",
- " break;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+f(var p) {
+ switch (p) {
+ case 1:
+ break;
+ case 'a':
+ break;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES]);
verify([source]);
@@ -1843,23 +2079,23 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_inconsistentCaseExpressionTypes_dynamic() {
// Even though A.S and S have a static type of "dynamic", we should see
// that they fail to match 3, because they are constant strings.
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static const S = 'A.S';",
- "}",
- "",
- "const S = 'S';",
- "",
- "foo(var p) {",
- " switch (p) {",
- " case 3:",
- " break;",
- " case S:",
- " break;",
- " case A.S:",
- " break;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static const S = 'A.S';
+}
+
+const S = 'S';
+
+foo(var p) {
+ switch (p) {
+ case 3:
+ break;
+ case S:
+ break;
+ case A.S:
+ break;
+ }
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
@@ -1868,17 +2104,17 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_inconsistentCaseExpressionTypes_repeated() {
- Source source = addSource(EngineTestCase.createSource([
- "f(var p) {",
- " switch (p) {",
- " case 1:",
- " break;",
- " case 'a':",
- " break;",
- " case 'b':",
- " break;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+f(var p) {
+ switch (p) {
+ case 1:
+ break;
+ case 'a':
+ break;
+ case 'b':
+ break;
+ }
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.INCONSISTENT_CASE_EXPRESSION_TYPES,
@@ -1889,133 +2125,154 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_initializerForNonExistent_const() {
// Check that the absence of a matching field doesn't cause a
// crash during constant evaluation.
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A() : x = 'foo';",
- "}",
- "A a = const A();"]));
+ Source source = addSource(r'''
+class A {
+ const A() : x = 'foo';
+}
+A a = const A();''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD]);
}
void test_initializerForNonExistent_initializer() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() : x = 0 {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() : x = 0 {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZER_FOR_NON_EXISTENT_FIELD]);
}
void test_initializerForStaticField() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " static int x;", " A() : x = 0 {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ static int x;
+ A() : x = 0 {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZER_FOR_STATIC_FIELD]);
verify([source]);
}
void test_initializingFormalForNonExistentField() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A(this.x) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A(this.x) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
verify([source]);
}
void test_initializingFormalForNonExistentField_notInEnclosingClass() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- "int x;",
- "}",
- "class B extends A {",
- " B(this.x) {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+int x;
+}
+class B extends A {
+ B(this.x) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
verify([source]);
}
void test_initializingFormalForNonExistentField_optional() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A([this.x]) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A([this.x]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
verify([source]);
}
void test_initializingFormalForNonExistentField_synthetic() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int get x => 1;", " A(this.x) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int get x => 1;
+ A(this.x) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_NON_EXISTENT_FIELD]);
verify([source]);
}
void test_initializingFormalForStaticField() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " static int x;", " A([this.x]) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ static int x;
+ A([this.x]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INITIALIZING_FORMAL_FOR_STATIC_FIELD]);
verify([source]);
}
void test_instanceMemberAccessFromFactory_named() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {}",
- " A();",
- " factory A.make() {",
- " m();",
- " return new A();",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+ A();
+ factory A.make() {
+ m();
+ return new A();
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY]);
verify([source]);
}
void test_instanceMemberAccessFromFactory_unnamed() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {}",
- " A._();",
- " factory A() {",
- " m();",
- " return new A._();",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+ A._();
+ factory A() {
+ m();
+ return new A._();
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_FACTORY]);
verify([source]);
}
void test_instanceMemberAccessFromStatic_field() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " int f;",
- " static foo() {",
- " f;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ int f;
+ static foo() {
+ f;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
verify([source]);
}
void test_instanceMemberAccessFromStatic_getter() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " get g => null;",
- " static foo() {",
- " g;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ get g => null;
+ static foo() {
+ g;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
verify([source]);
}
void test_instanceMemberAccessFromStatic_method() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {}",
- " static foo() {",
- " m();",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+ static foo() {
+ m();
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INSTANCE_MEMBER_ACCESS_FROM_STATIC]);
verify([source]);
@@ -2025,11 +2282,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
analysisOptions.enableEnum = true;
resetWithOptions(analysisOptions);
- Source source = addSource(EngineTestCase.createSource([
- "enum E { ONE }",
- "E e(String name) {",
- " return const E();",
- "}"]));
+ Source source = addSource(r'''
+enum E { ONE }
+E e(String name) {
+ return const E();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INSTANTIATE_ENUM]);
verify([source]);
@@ -2039,98 +2296,138 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
analysisOptions.enableEnum = true;
resetWithOptions(analysisOptions);
- Source source = addSource(EngineTestCase.createSource([
- "enum E { ONE }",
- "E e(String name) {",
- " return new E();",
- "}"]));
+ Source source = addSource(r'''
+enum E { ONE }
+E e(String name) {
+ return new E();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INSTANTIATE_ENUM]);
verify([source]);
}
void test_invalidAnnotation_getter() {
- Source source = addSource(EngineTestCase.createSource(["get V => 0;", "@V", "main() {", "}"]));
+ Source source = addSource(r'''
+get V => 0;
+@V
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
verify([source]);
}
void test_invalidAnnotation_importWithPrefix_getter() {
- addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "get V => 0;"]));
- Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.V", "main() {", "}"]));
+ addNamedSource("/lib.dart", r'''
+library lib;
+get V => 0;''');
+ Source source = addSource(r'''
+import 'lib.dart' as p;
+@p.V
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
verify([source]);
}
void test_invalidAnnotation_importWithPrefix_notConstantVariable() {
- addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "final V = 0;"]));
- Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.V", "main() {", "}"]));
+ addNamedSource("/lib.dart", r'''
+library lib;
+final V = 0;''');
+ Source source = addSource(r'''
+import 'lib.dart' as p;
+@p.V
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
verify([source]);
}
void test_invalidAnnotation_importWithPrefix_notVariableOrConstructorInvocation() {
- addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "typedef V();"]));
- Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "@p.V", "main() {", "}"]));
+ addNamedSource("/lib.dart", r'''
+library lib;
+typedef V();''');
+ Source source = addSource(r'''
+import 'lib.dart' as p;
+@p.V
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
verify([source]);
}
void test_invalidAnnotation_notConstantVariable() {
- Source source = addSource(EngineTestCase.createSource(["final V = 0;", "@V", "main() {", "}"]));
+ Source source = addSource(r'''
+final V = 0;
+@V
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
verify([source]);
}
void test_invalidAnnotation_notVariableOrConstructorInvocation() {
- Source source = addSource(EngineTestCase.createSource(["typedef V();", "@V", "main() {", "}"]));
+ Source source = addSource(r'''
+typedef V();
+@V
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
verify([source]);
}
void test_invalidAnnotation_staticMethodReference() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static f() {}",
- "}",
- "@A.f",
- "main() {",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static f() {}
+}
+@A.f
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
verify([source]);
}
void test_invalidAnnotation_unresolved_identifier() {
- Source source = addSource(EngineTestCase.createSource(["@unresolved", "main() {", "}"]));
+ Source source = addSource(r'''
+@unresolved
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
}
void test_invalidAnnotation_unresolved_invocation() {
- Source source = addSource(EngineTestCase.createSource(["@Unresolved()", "main() {", "}"]));
+ Source source = addSource(r'''
+@Unresolved()
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
}
void test_invalidAnnotation_unresolved_prefixedIdentifier() {
- Source source = addSource(EngineTestCase.createSource([
- "import 'dart:math' as p;",
- "@p.unresolved",
- "main() {",
- "}"]));
+ Source source = addSource(r'''
+import 'dart:math' as p;
+@p.unresolved
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
}
void test_invalidAnnotation_useLibraryScope() {
- Source source = addSource(EngineTestCase.createSource(["@foo", "class A {", " static const foo = null;", "}"]));
+ Source source = addSource(r'''
+@foo
+class A {
+ static const foo = null;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_ANNOTATION]);
}
@@ -2138,59 +2435,77 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidAnnotationFromDeferredLibrary() {
// See test_invalidAnnotation_notConstantVariable
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource([
- "library lib1;",
- "class V { const V(); }",
- "const v = const V();"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "@a.v main () {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+class V { const V(); }
+const v = const V();''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+@a.v main () {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
}
void test_invalidAnnotationFromDeferredLibrary_constructor() {
// See test_invalidAnnotation_notConstantVariable
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class C { const C(); }"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "@a.C() main () {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+class C { const C(); }''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+@a.C() main () {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
}
void test_invalidAnnotationFromDeferredLibrary_namedConstructor() {
// See test_invalidAnnotation_notConstantVariable
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class C { const C.name(); }"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "@a.C.name() main () {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+class C { const C.name(); }''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+@a.C.name() main () {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.INVALID_ANNOTATION_FROM_DEFERRED_LIBRARY]);
}
void test_invalidConstructorName_notEnclosingClassName_defined() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " B() : super();", "}", "class B {}"]));
+ Source source = addSource(r'''
+class A {
+ B() : super();
+}
+class B {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
// no verify() call, "B" is not resolved
}
void test_invalidConstructorName_notEnclosingClassName_undefined() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " B() : super();", "}"]));
+ Source source = addSource(r'''
+class A {
+ B() : super();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_CONSTRUCTOR_NAME]);
// no verify() call, "B" is not resolved
}
void test_invalidFactoryNameNotAClass_notClassName() {
- Source source = addSource(EngineTestCase.createSource(["int B;", "class A {", " factory B() {}", "}"]));
+ Source source = addSource(r'''
+int B;
+class A {
+ factory B() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
verify([source]);
}
void test_invalidFactoryNameNotAClass_notEnclosingClassName() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " factory B() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ factory B() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_FACTORY_NAME_NOT_A_CLASS]);
// no verify() call, "B" is not resolved
@@ -2198,7 +2513,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnConstructor_async() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() async {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() async {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_CONSTRUCTOR]);
verify([source]);
@@ -2206,7 +2524,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnConstructor_asyncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() async* {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() async* {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_CONSTRUCTOR]);
verify([source]);
@@ -2214,7 +2535,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnConstructor_syncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() sync* {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() sync* {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_CONSTRUCTOR]);
verify([source]);
@@ -2222,7 +2546,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnSetter_member_async() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["class A {", " set x(v) async {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ set x(v) async {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER]);
verify([source]);
@@ -2230,7 +2557,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnSetter_member_asyncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["class A {", " set x(v) async* {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ set x(v) async* {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER]);
verify([source]);
@@ -2238,7 +2568,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnSetter_member_syncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["class A {", " set x(v) sync* {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ set x(v) sync* {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER]);
verify([source]);
@@ -2246,7 +2579,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnSetter_topLevel_async() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["set x(v) async {}"]));
+ Source source = addSource("set x(v) async {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER]);
verify([source]);
@@ -2254,7 +2587,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnSetter_topLevel_asyncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["set x(v) async* {}"]));
+ Source source = addSource("set x(v) async* {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER]);
verify([source]);
@@ -2262,55 +2595,71 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_invalidModifierOnSetter_topLevel_syncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["set x(v) sync* {}"]));
+ Source source = addSource("set x(v) sync* {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_MODIFIER_ON_SETTER]);
verify([source]);
}
void test_invalidReferenceToThis_factoryConstructor() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " factory A() { return this; }", "}"]));
+ Source source = addSource(r'''
+class A {
+ factory A() { return this; }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
verify([source]);
}
void test_invalidReferenceToThis_instanceVariableInitializer_inConstructor() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " var f;", " A() : f = this;", "}"]));
+ Source source = addSource(r'''
+class A {
+ var f;
+ A() : f = this;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
verify([source]);
}
void test_invalidReferenceToThis_instanceVariableInitializer_inDeclaration() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " var f = this;", "}"]));
+ Source source = addSource(r'''
+class A {
+ var f = this;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
verify([source]);
}
void test_invalidReferenceToThis_staticMethod() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " static m() { return this; }", "}"]));
+ Source source = addSource(r'''
+class A {
+ static m() { return this; }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
verify([source]);
}
void test_invalidReferenceToThis_staticVariableInitializer() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " static A f = this;", "}"]));
+ Source source = addSource(r'''
+class A {
+ static A f = this;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
verify([source]);
}
void test_invalidReferenceToThis_superInitializer() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A(var x) {}",
- "}",
- "class B extends A {",
- " B() : super(this);",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A(var x) {}
+}
+class B extends A {
+ B() : super(this);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_REFERENCE_TO_THIS]);
verify([source]);
@@ -2331,103 +2680,112 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_invalidTypeArgumentInConstList() {
- Source source = addSource(EngineTestCase.createSource([
- "class A<E> {",
- " m() {",
- " return const <E>[];",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A<E> {
+ m() {
+ return const <E>[];
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_LIST]);
verify([source]);
}
void test_invalidTypeArgumentInConstMap() {
- Source source = addSource(EngineTestCase.createSource([
- "class A<E> {",
- " m() {",
- " return const <String, E>{};",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A<E> {
+ m() {
+ return const <String, E>{};
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_TYPE_ARGUMENT_IN_CONST_MAP]);
verify([source]);
}
void test_invalidUri_export() {
- Source source = addSource(EngineTestCase.createSource(["export 'ht:';"]));
+ Source source = addSource("export 'ht:';");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_URI]);
}
void test_invalidUri_import() {
- Source source = addSource(EngineTestCase.createSource(["import 'ht:';"]));
+ Source source = addSource("import 'ht:';");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_URI]);
}
void test_invalidUri_part() {
- Source source = addSource(EngineTestCase.createSource(["part 'ht:';"]));
+ Source source = addSource("part 'ht:';");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.INVALID_URI]);
}
void test_labelInOuterScope() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " void m(int i) {",
- " l: while (i > 0) {",
- " void f() {",
- " break l;",
- " };",
- " }",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ void m(int i) {
+ l: while (i > 0) {
+ void f() {
+ break l;
+ };
+ }
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.LABEL_IN_OUTER_SCOPE]);
// We cannot verify resolution with unresolvable labels
}
void test_labelUndefined_break() {
- Source source = addSource(EngineTestCase.createSource([
- "f() {",
- " x: while (true) {",
- " break y;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+f() {
+ x: while (true) {
+ break y;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.LABEL_UNDEFINED]);
// We cannot verify resolution with undefined labels
}
void test_labelUndefined_continue() {
- Source source = addSource(EngineTestCase.createSource([
- "f() {",
- " x: while (true) {",
- " continue y;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+f() {
+ x: while (true) {
+ continue y;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.LABEL_UNDEFINED]);
// We cannot verify resolution with undefined labels
}
void test_memberWithClassName_field() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int A = 0;", "}"]));
+ Source source = addSource(r'''
+class A {
+ int A = 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
verify([source]);
}
void test_memberWithClassName_field2() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int z, A, b = 0;", "}"]));
+ Source source = addSource(r'''
+class A {
+ int z, A, b = 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
verify([source]);
}
void test_memberWithClassName_getter() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " get A => 0;", "}"]));
+ Source source = addSource(r'''
+class A {
+ get A => 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MEMBER_WITH_CLASS_NAME]);
verify([source]);
@@ -2438,7 +2796,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_methodAndGetterWithSameName() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " get x => 0;", " x(y) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ get x => 0;
+ x(y) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.METHOD_AND_GETTER_WITH_SAME_NAME]);
verify([source]);
@@ -2448,15 +2810,15 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
analysisOptions.enableEnum = true;
resetWithOptions(analysisOptions);
- Source source = addSource(EngineTestCase.createSource([
- "enum E { ONE, TWO, THREE, FOUR }",
- "bool odd(E e) {",
- " switch (e) {",
- " case E.ONE:",
- " case E.THREE: return true;",
- " }",
- " return false;",
- "}"]));
+ Source source = addSource(r'''
+enum E { ONE, TWO, THREE, FOUR }
+bool odd(E e) {
+ switch (e) {
+ case E.ONE:
+ case E.THREE: return true;
+ }
+ return false;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.MISSING_ENUM_CONSTANT_IN_SWITCH,
@@ -2465,18 +2827,22 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_mixinDeclaresConstructor_classDeclaration() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A() {}",
- "}",
- "class B extends Object with A {}"]));
+ Source source = addSource(r'''
+class A {
+ A() {}
+}
+class B extends Object with A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
verify([source]);
}
void test_mixinDeclaresConstructor_typeAlias() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() {}", "}", "class B = Object with A;"]));
+ Source source = addSource(r'''
+class A {
+ A() {}
+}
+class B = Object with A;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_DECLARES_CONSTRUCTOR]);
verify([source]);
@@ -2484,149 +2850,167 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_mixinDeferredClass() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class B extends Object with a.A {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class B extends Object with a.A {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
}
void test_mixinDeferredClass_classTypeAlias() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "class A {}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class B {}",
- "class C = B with a.A;"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
+ r'''
+library lib1;
+class A {}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class B {}
+class C = B with a.A;'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.MIXIN_DEFERRED_CLASS]);
}
void test_mixinInheritsFromNotObject_classDeclaration_extends() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B extends A {}",
- "class C extends Object with B {}"]));
+ Source source = addSource(r'''
+class A {}
+class B extends A {}
+class C extends Object with B {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
verify([source]);
}
void test_mixinInheritsFromNotObject_classDeclaration_with() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B extends Object with A {}",
- "class C extends Object with B {}"]));
+ Source source = addSource(r'''
+class A {}
+class B extends Object with A {}
+class C extends Object with B {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
verify([source]);
}
void test_mixinInheritsFromNotObject_typeAlias_extends() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B extends A {}",
- "class C = Object with B;"]));
+ Source source = addSource(r'''
+class A {}
+class B extends A {}
+class C = Object with B;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
verify([source]);
}
void test_mixinInheritsFromNotObject_typeAlias_with() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B extends Object with A {}",
- "class C = Object with B;"]));
+ Source source = addSource(r'''
+class A {}
+class B extends Object with A {}
+class C = Object with B;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_INHERITS_FROM_NOT_OBJECT]);
verify([source]);
}
void test_mixinOfDisallowedClass_class_bool() {
- Source source = addSource(EngineTestCase.createSource(["class A extends Object with bool {}"]));
+ Source source = addSource("class A extends Object with bool {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_class_double() {
- Source source = addSource(EngineTestCase.createSource(["class A extends Object with double {}"]));
+ Source source = addSource("class A extends Object with double {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_class_int() {
- Source source = addSource(EngineTestCase.createSource(["class A extends Object with int {}"]));
+ Source source = addSource("class A extends Object with int {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_class_Null() {
- Source source = addSource(EngineTestCase.createSource(["class A extends Object with Null {}"]));
+ Source source = addSource("class A extends Object with Null {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_class_num() {
- Source source = addSource(EngineTestCase.createSource(["class A extends Object with num {}"]));
+ Source source = addSource("class A extends Object with num {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_class_String() {
- Source source = addSource(EngineTestCase.createSource(["class A extends Object with String {}"]));
+ Source source = addSource("class A extends Object with String {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_classTypeAlias_bool() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class C = A with bool;"]));
+ Source source = addSource(r'''
+class A {}
+class C = A with bool;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_classTypeAlias_double() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class C = A with double;"]));
+ Source source = addSource(r'''
+class A {}
+class C = A with double;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_classTypeAlias_int() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class C = A with int;"]));
+ Source source = addSource(r'''
+class A {}
+class C = A with int;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_classTypeAlias_Null() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class C = A with Null;"]));
+ Source source = addSource(r'''
+class A {}
+class C = A with Null;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_classTypeAlias_num() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class C = A with num;"]));
+ Source source = addSource(r'''
+class A {}
+class C = A with num;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_classTypeAlias_String() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class C = A with String;"]));
+ Source source = addSource(r'''
+class A {}
+class C = A with String;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS]);
verify([source]);
}
void test_mixinOfDisallowedClass_classTypeAlias_String_num() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "class C = A with String, num;"]));
+ Source source = addSource(r'''
+class A {}
+class C = A with String, num;''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.MIXIN_OF_DISALLOWED_CLASS,
@@ -2638,69 +3022,82 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
AnalysisOptionsImpl analysisOptions = new AnalysisOptionsImpl();
analysisOptions.enableEnum = true;
resetWithOptions(analysisOptions);
- Source source = addSource(EngineTestCase.createSource(["enum E { ONE }", "class A extends Object with E {}"]));
+ Source source = addSource(r'''
+enum E { ONE }
+class A extends Object with E {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_ENUM]);
verify([source]);
}
void test_mixinOfNonClass_class() {
- Source source = addSource(EngineTestCase.createSource(["int A;", "class B extends Object with A {}"]));
+ Source source = addSource(r'''
+int A;
+class B extends Object with A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
verify([source]);
}
void test_mixinOfNonClass_typeAlias() {
- Source source = addSource(EngineTestCase.createSource(["class A {}", "int B;", "class C = A with B;"]));
+ Source source = addSource(r'''
+class A {}
+int B;
+class C = A with B;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_OF_NON_CLASS]);
verify([source]);
}
void test_mixinReferencesSuper() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " toString() => super.toString();",
- "}",
- "class B extends Object with A {}"]));
+ Source source = addSource(r'''
+class A {
+ toString() => super.toString();
+}
+class B extends Object with A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_REFERENCES_SUPER]);
verify([source]);
}
void test_mixinWithNonClassSuperclass_class() {
- Source source = addSource(EngineTestCase.createSource(["int A;", "class B {}", "class C extends A with B {}"]));
+ Source source = addSource(r'''
+int A;
+class B {}
+class C extends A with B {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
verify([source]);
}
void test_mixinWithNonClassSuperclass_typeAlias() {
- Source source = addSource(EngineTestCase.createSource(["int A;", "class B {}", "class C = A with B;"]));
+ Source source = addSource(r'''
+int A;
+class B {}
+class C = A with B;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MIXIN_WITH_NON_CLASS_SUPERCLASS]);
verify([source]);
}
void test_multipleRedirectingConstructorInvocations() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A() : this.a(), this.b();",
- " A.a() {}",
- " A.b() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A() : this.a(), this.b();
+ A.a() {}
+ A.b() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MULTIPLE_REDIRECTING_CONSTRUCTOR_INVOCATIONS]);
verify([source]);
}
void test_multipleSuperInitializers() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B extends A {",
- " B() : super(), super() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {}
+class B extends A {
+ B() : super(), super() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.MULTIPLE_SUPER_INITIALIZERS]);
verify([source]);
@@ -2709,7 +3106,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nativeClauseInNonSDKCode() {
// TODO(jwren) Move this test somewhere else: This test verifies a parser error code is generated
// through the ErrorVerifier, it is not a CompileTimeErrorCode.
- Source source = addSource(EngineTestCase.createSource(["class A native 'string' {}"]));
+ Source source = addSource("class A native 'string' {}");
resolve(source);
assertErrors(source, [ParserErrorCode.NATIVE_CLAUSE_IN_NON_SDK_CODE]);
verify([source]);
@@ -2718,7 +3115,7 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nativeFunctionBodyInNonSDKCode_function() {
// TODO(jwren) Move this test somewhere else: This test verifies a parser error code is generated
// through the ErrorVerifier, it is not a CompileTimeErrorCode.
- Source source = addSource(EngineTestCase.createSource(["int m(a) native 'string';"]));
+ Source source = addSource("int m(a) native 'string';");
resolve(source);
assertErrors(source, [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
verify([source]);
@@ -2727,103 +3124,145 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nativeFunctionBodyInNonSDKCode_method() {
// TODO(jwren) Move this test somewhere else: This test verifies a parser error code is generated
// through the ErrorVerifier, it is not a CompileTimeErrorCode.
- Source source = addSource(EngineTestCase.createSource(["class A{", " static int m(a) native 'string';", "}"]));
+ Source source = addSource(r'''
+class A{
+ static int m(a) native 'string';
+}''');
resolve(source);
assertErrors(source, [ParserErrorCode.NATIVE_FUNCTION_BODY_IN_NON_SDK_CODE]);
verify([source]);
}
void test_noAnnotationConstructorArguments() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " const A();", "}", "@A", "main() {", "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+@A
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NO_ANNOTATION_CONSTRUCTOR_ARGUMENTS]);
verify([source]);
}
void test_noDefaultSuperConstructorExplicit() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A(p);",
- "}",
- "class B extends A {",
- " B() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A(p);
+}
+class B extends A {
+ B() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_EXPLICIT]);
verify([source]);
}
void test_noDefaultSuperConstructorImplicit_superHasParameters() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A(p);", "}", "class B extends A {", "}"]));
+ Source source = addSource(r'''
+class A {
+ A(p);
+}
+class B extends A {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
verify([source]);
}
void test_noDefaultSuperConstructorImplicit_superOnlyNamed() {
- Source source = addSource(EngineTestCase.createSource(["class A { A.named() {} }", "class B extends A {}"]));
+ Source source = addSource(r'''
+class A { A.named() {} }
+class B extends A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NO_DEFAULT_SUPER_CONSTRUCTOR_IMPLICIT]);
verify([source]);
}
void test_nonConstantAnnotationConstructor_named() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A.fromInt() {}",
- "}",
- "@A.fromInt()",
- "main() {",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A.fromInt() {}
+}
+@A.fromInt()
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR]);
verify([source]);
}
void test_nonConstantAnnotationConstructor_unnamed() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() {}", "}", "@A()", "main() {", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() {}
+}
+@A()
+main() {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_ANNOTATION_CONSTRUCTOR]);
verify([source]);
}
void test_nonConstantDefaultValue_function_named() {
- Source source = addSource(EngineTestCase.createSource(["int y;", "f({x : y}) {}"]));
+ Source source = addSource(r'''
+int y;
+f({x : y}) {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
verify([source]);
}
void test_nonConstantDefaultValue_function_positional() {
- Source source = addSource(EngineTestCase.createSource(["int y;", "f([x = y]) {}"]));
+ Source source = addSource(r'''
+int y;
+f([x = y]) {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
verify([source]);
}
void test_nonConstantDefaultValue_inConstructor_named() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int y;", " A({x : y}) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int y;
+ A({x : y}) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
verify([source]);
}
void test_nonConstantDefaultValue_inConstructor_positional() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int y;", " A([x = y]) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int y;
+ A([x = y]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
verify([source]);
}
void test_nonConstantDefaultValue_method_named() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int y;", " m({x : y}) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int y;
+ m({x : y}) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
verify([source]);
}
void test_nonConstantDefaultValue_method_positional() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " int y;", " m([x = y]) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ int y;
+ m([x = y]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE]);
verify([source]);
@@ -2831,30 +3270,34 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nonConstantDefaultValueFromDeferredLibrary() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const V = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f({x : a.V}) {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const V = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f({x : a.V}) {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstantDefaultValueFromDeferredLibrary_nested() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const V = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f({x : a.V + 1}) {}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const V = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f({x : a.V + 1}) {}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_DEFAULT_VALUE_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstCaseExpression() {
- Source source = addSource(EngineTestCase.createSource([
- "f(int p, int q) {",
- " switch (p) {",
- " case 3 + q:",
- " break;",
- " }",
- "}"]));
+ Source source = addSource(r'''
+f(int p, int q) {
+ switch (p) {
+ case 3 + q:
+ break;
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION]);
verify([source]);
@@ -2862,34 +3305,41 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nonConstCaseExpressionFromDeferredLibrary() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "main (int p) {",
- " switch (p) {",
- " case a.c:",
- " break;",
- " }",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+main (int p) {
+ switch (p) {
+ case a.c:
+ break;
+ }
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstCaseExpressionFromDeferredLibrary_nested() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "main (int p) {",
- " switch (p) {",
- " case a.c + 1:",
- " break;",
- " }",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+main (int p) {
+ switch (p) {
+ case a.c + 1:
+ break;
+ }
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_CASE_EXPRESSION_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstListElement() {
- Source source = addSource(EngineTestCase.createSource(["f(a) {", " return const [a];", "}"]));
+ Source source = addSource(r'''
+f(a) {
+ return const [a];
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT]);
verify([source]);
@@ -2897,42 +3347,55 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nonConstListElementFromDeferredLibrary() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f() {",
- " return const [a.c];",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+ return const [a.c];
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstListElementFromDeferredLibrary_nested() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f() {",
- " return const [a.c + 1];",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+ return const [a.c + 1];
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_LIST_ELEMENT_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstMapAsExpressionStatement_begin() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " {'a' : 0, 'b' : 1}.length;", "}"]));
+ Source source = addSource(r'''
+f() {
+ {'a' : 0, 'b' : 1}.length;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]);
verify([source]);
}
void test_nonConstMapAsExpressionStatement_only() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " {'a' : 0, 'b' : 1};", "}"]));
+ Source source = addSource(r'''
+f() {
+ {'a' : 0, 'b' : 1};
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONST_MAP_AS_EXPRESSION_STATEMENT]);
verify([source]);
}
void test_nonConstMapKey() {
- Source source = addSource(EngineTestCase.createSource(["f(a) {", " return const {a : 0};", "}"]));
+ Source source = addSource(r'''
+f(a) {
+ return const {a : 0};
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_MAP_KEY]);
verify([source]);
@@ -2940,28 +3403,35 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nonConstMapKeyFromDeferredLibrary() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f() {",
- " return const {a.c : 0};",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+ return const {a.c : 0};
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstMapKeyFromDeferredLibrary_nested() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f() {",
- " return const {a.c + 1 : 0};",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+ return const {a.c + 1 : 0};
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_KEY_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstMapValue() {
- Source source = addSource(EngineTestCase.createSource(["f(a) {", " return const {'a' : a};", "}"]));
+ Source source = addSource(r'''
+f(a) {
+ return const {'a' : a};
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE]);
verify([source]);
@@ -2969,32 +3439,36 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nonConstMapValueFromDeferredLibrary() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f() {",
- " return const {'a' : a.c};",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+ return const {'a' : a.c};
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstMapValueFromDeferredLibrary_nested() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "f() {",
- " return const {'a' : a.c + 1};",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+f() {
+ return const {'a' : a.c + 1};
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_MAP_VALUE_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstValueInInitializer_binary_notBool_left() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final bool a;",
- " const A(String p) : a = p && true;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ final bool a;
+ const A(String p) : a = p && true;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL,
@@ -3003,11 +3477,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_nonConstValueInInitializer_binary_notBool_right() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final bool a;",
- " const A(String p) : a = true && p;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ final bool a;
+ const A(String p) : a = true && p;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL,
@@ -3016,11 +3490,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_nonConstValueInInitializer_binary_notInt() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final int a;",
- " const A(String p) : a = 5 & p;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ final int a;
+ const A(String p) : a = 5 & p;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_TYPE_INT,
@@ -3029,11 +3503,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_nonConstValueInInitializer_binary_notNum() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final int a;",
- " const A(String p) : a = 5 + p;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ final int a;
+ const A(String p) : a = 5 + p;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_TYPE_NUM,
@@ -3042,53 +3516,53 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_nonConstValueInInitializer_field() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static int C;",
- " final int a;",
- " const A() : a = C;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static int C;
+ final int a;
+ const A() : a = C;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
verify([source]);
}
void test_nonConstValueInInitializer_instanceCreation() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A();",
- "}",
- "class B {",
- " const B() : a = new A();",
- " final a;",
- "}",
- "var b = const B();"]));
+ Source source = addSource(r'''
+class A {
+ A();
+}
+class B {
+ const B() : a = new A();
+ final a;
+}
+var b = const B();''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
verify([source]);
}
void test_nonConstValueInInitializer_redirecting() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static var C;",
- " const A.named(p);",
- " const A() : this.named(C);",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static var C;
+ const A.named(p);
+ const A() : this.named(C);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
verify([source]);
}
void test_nonConstValueInInitializer_super() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A(p);",
- "}",
- "class B extends A {",
- " static var C;",
- " const B() : super(C);",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A(p);
+}
+class B extends A {
+ static var C;
+ const B() : super(C);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER]);
verify([source]);
@@ -3096,199 +3570,239 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_nonConstValueInInitializerFromDeferredLibrary_field() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class A {",
- " final int x;",
- " const A() : x = a.c;",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class A {
+ final int x;
+ const A() : x = a.c;
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstValueInInitializerFromDeferredLibrary_field_nested() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class A {",
- " final int x;",
- " const A() : x = a.c + 1;",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class A {
+ final int x;
+ const A() : x = a.c + 1;
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstValueInInitializerFromDeferredLibrary_redirecting() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class A {",
- " const A.named(p);",
- " const A() : this.named(a.c);",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class A {
+ const A.named(p);
+ const A() : this.named(a.c);
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
}
void test_nonConstValueInInitializerFromDeferredLibrary_super() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "const int c = 1;"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as a;",
- "class A {",
- " const A(p);",
- "}",
- "class B extends A {",
- " const B() : super(a.c);",
- "}"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
+ r'''
+library lib1;
+const int c = 1;''',
+ r'''
+library root;
+import 'lib1.dart' deferred as a;
+class A {
+ const A(p);
+}
+class B extends A {
+ const B() : super(a.c);
+}'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.NON_CONSTANT_VALUE_IN_INITIALIZER_FROM_DEFERRED_LIBRARY]);
}
void test_nonGenerativeConstructor_explicit() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " factory A.named() {}",
- "}",
- "class B extends A {",
- " B() : super.named();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ factory A.named() {}
+}
+class B extends A {
+ B() : super.named();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
verify([source]);
}
void test_nonGenerativeConstructor_implicit() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " factory A() {}",
- "}",
- "class B extends A {",
- " B();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ factory A() {}
+}
+class B extends A {
+ B();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
verify([source]);
}
void test_nonGenerativeConstructor_implicit2() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " factory A() {}",
- "}",
- "class B extends A {",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ factory A() {}
+}
+class B extends A {
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NON_GENERATIVE_CONSTRUCTOR]);
verify([source]);
}
void test_notEnoughRequiredArguments_const() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A(int p);",
- "}",
- "main() {",
- " const A();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A(int p);
+}
+main() {
+ const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
verify([source]);
}
void test_notEnoughRequiredArguments_const_super() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A(int p);",
- "}",
- "class B extends A {",
- " const B() : super();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A(int p);
+}
+class B extends A {
+ const B() : super();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.NOT_ENOUGH_REQUIRED_ARGUMENTS]);
verify([source]);
}
void test_optionalParameterInOperator_named() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " operator +({p}) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ operator +({p}) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]);
verify([source]);
}
void test_optionalParameterInOperator_positional() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " operator +([p]) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ operator +([p]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.OPTIONAL_PARAMETER_IN_OPERATOR]);
verify([source]);
}
void test_partOfNonPart() {
- Source source = addSource(EngineTestCase.createSource(["library l1;", "part 'l2.dart';"]));
- addNamedSource("/l2.dart", EngineTestCase.createSource(["library l2;"]));
+ Source source = addSource(r'''
+library l1;
+part 'l2.dart';''');
+ addNamedSource("/l2.dart", "library l2;");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PART_OF_NON_PART]);
verify([source]);
}
void test_prefixCollidesWithTopLevelMembers_functionTypeAlias() {
- addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
- Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "typedef p();", "p.A a;"]));
+ addNamedSource("/lib.dart", r'''
+library lib;
+class A{}''');
+ Source source = addSource(r'''
+import 'lib.dart' as p;
+typedef p();
+p.A a;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
verify([source]);
}
void test_prefixCollidesWithTopLevelMembers_topLevelFunction() {
- addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
- Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "p() {}", "p.A a;"]));
+ addNamedSource("/lib.dart", r'''
+library lib;
+class A{}''');
+ Source source = addSource(r'''
+import 'lib.dart' as p;
+p() {}
+p.A a;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
verify([source]);
}
void test_prefixCollidesWithTopLevelMembers_topLevelVariable() {
- addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
- Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "var p = null;", "p.A a;"]));
+ addNamedSource("/lib.dart", r'''
+library lib;
+class A{}''');
+ Source source = addSource(r'''
+import 'lib.dart' as p;
+var p = null;
+p.A a;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
verify([source]);
}
void test_prefixCollidesWithTopLevelMembers_type() {
- addNamedSource("/lib.dart", EngineTestCase.createSource(["library lib;", "class A{}"]));
- Source source = addSource(EngineTestCase.createSource(["import 'lib.dart' as p;", "class p {}", "p.A a;"]));
+ addNamedSource("/lib.dart", r'''
+library lib;
+class A{}''');
+ Source source = addSource(r'''
+import 'lib.dart' as p;
+class p {}
+p.A a;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PREFIX_COLLIDES_WITH_TOP_LEVEL_MEMBER]);
verify([source]);
}
void test_privateOptionalParameter() {
- Source source = addSource(EngineTestCase.createSource(["f({var _p}) {}"]));
+ Source source = addSource("f({var _p}) {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
verify([source]);
}
void test_privateOptionalParameter_fieldFormal() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " var _p;", " A({this._p: 0});", "}"]));
+ Source source = addSource(r'''
+class A {
+ var _p;
+ A({this._p: 0});
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
verify([source]);
}
void test_privateOptionalParameter_withDefaultValue() {
- Source source = addSource(EngineTestCase.createSource(["f({_p : 0}) {}"]));
+ Source source = addSource("f({_p : 0}) {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.PRIVATE_OPTIONAL_PARAMETER]);
verify([source]);
}
void test_recursiveConstructorRedirect() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A.a() : this.b();",
- " A.b() : this.a();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A.a() : this.b();
+ A.b() : this.a();
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT,
@@ -3297,23 +3811,26 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveConstructorRedirect_directSelfReference() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() : this();", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() : this();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_CONSTRUCTOR_REDIRECT]);
verify([source]);
}
void test_recursiveFactoryRedirect() {
- Source source = addSource(EngineTestCase.createSource([
- "class A implements B {",
- " factory A() = C;",
- "}",
- "class B implements C {",
- " factory B() = A;",
- "}",
- "class C implements A {",
- " factory C() = B;",
- "}"]));
+ Source source = addSource(r'''
+class A implements B {
+ factory A() = C;
+}
+class B implements C {
+ factory B() = A;
+}
+class C implements A {
+ factory C() = B;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
@@ -3326,23 +3843,26 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveFactoryRedirect_directSelfReference() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " factory A() = A;", "}"]));
+ Source source = addSource(r'''
+class A {
+ factory A() = A;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT]);
verify([source]);
}
void test_recursiveFactoryRedirect_generic() {
- Source source = addSource(EngineTestCase.createSource([
- "class A<T> implements B<T> {",
- " factory A() = C;",
- "}",
- "class B<T> implements C<T> {",
- " factory B() = A;",
- "}",
- "class C<T> implements A<T> {",
- " factory C() = B;",
- "}"]));
+ Source source = addSource(r'''
+class A<T> implements B<T> {
+ factory A() = C;
+}
+class B<T> implements C<T> {
+ factory B() = A;
+}
+class C<T> implements A<T> {
+ factory C() = B;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
@@ -3355,16 +3875,16 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveFactoryRedirect_named() {
- Source source = addSource(EngineTestCase.createSource([
- "class A implements B {",
- " factory A.nameA() = C.nameC;",
- "}",
- "class B implements C {",
- " factory B.nameB() = A.nameA;",
- "}",
- "class C implements A {",
- " factory C.nameC() = B.nameB;",
- "}"]));
+ Source source = addSource(r'''
+class A implements B {
+ factory A.nameA() = C.nameC;
+}
+class B implements C {
+ factory B.nameB() = A.nameA;
+}
+class C implements A {
+ factory C.nameC() = B.nameB;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
@@ -3381,16 +3901,16 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
* not the part of a cycle.
*/
void test_recursiveFactoryRedirect_outsideCycle() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " factory A() = C;",
- "}",
- "class B implements C {",
- " factory B() = C;",
- "}",
- "class C implements A, B {",
- " factory C() = B;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ factory A() = C;
+}
+class B implements C {
+ factory B() = C;
+}
+class C implements A, B {
+ factory C() = B;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_FACTORY_REDIRECT,
@@ -3401,7 +3921,9 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveInterfaceInheritance_extends() {
- Source source = addSource(EngineTestCase.createSource(["class A extends B {}", "class B extends A {}"]));
+ Source source = addSource(r'''
+class A extends B {}
+class B extends A {}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
@@ -3410,7 +3932,9 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveInterfaceInheritance_extends_implements() {
- Source source = addSource(EngineTestCase.createSource(["class A extends B {}", "class B implements A {}"]));
+ Source source = addSource(r'''
+class A extends B {}
+class B implements A {}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
@@ -3419,7 +3943,9 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveInterfaceInheritance_implements() {
- Source source = addSource(EngineTestCase.createSource(["class A implements B {}", "class B implements A {}"]));
+ Source source = addSource(r'''
+class A implements B {}
+class B implements A {}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
@@ -3428,9 +3954,9 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveInterfaceInheritance_mixin() {
- Source source = addSource(EngineTestCase.createSource([
- "class M1 = Object with M2;",
- "class M2 = Object with M1;"]));
+ Source source = addSource(r'''
+class M1 = Object with M2;
+class M2 = Object with M1;''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
@@ -3439,19 +3965,19 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveInterfaceInheritance_tail() {
- Source source = addSource(EngineTestCase.createSource([
- "abstract class A implements A {}",
- "class B implements A {}"]));
+ Source source = addSource(r'''
+abstract class A implements A {}
+class B implements A {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
verify([source]);
}
void test_recursiveInterfaceInheritance_tail2() {
- Source source = addSource(EngineTestCase.createSource([
- "abstract class A implements B {}",
- "abstract class B implements A {}",
- "class C implements A {}"]));
+ Source source = addSource(r'''
+abstract class A implements B {}
+abstract class B implements A {}
+class C implements A {}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
@@ -3460,11 +3986,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveInterfaceInheritance_tail3() {
- Source source = addSource(EngineTestCase.createSource([
- "abstract class A implements B {}",
- "abstract class B implements C {}",
- "abstract class C implements A {}",
- "class D implements A {}"]));
+ Source source = addSource(r'''
+abstract class A implements B {}
+abstract class B implements C {}
+abstract class C implements A {}
+class D implements A {}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE,
@@ -3474,168 +4000,193 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_recursiveInterfaceInheritanceBaseCaseExtends() {
- Source source = addSource(EngineTestCase.createSource(["class A extends A {}"]));
+ Source source = addSource("class A extends A {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_EXTENDS]);
verify([source]);
}
void test_recursiveInterfaceInheritanceBaseCaseImplements() {
- Source source = addSource(EngineTestCase.createSource(["class A implements A {}"]));
+ Source source = addSource("class A implements A {}");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
verify([source]);
}
void test_recursiveInterfaceInheritanceBaseCaseImplements_typeAlias() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class M {}",
- "class B = A with M implements B;"]));
+ Source source = addSource(r'''
+class A {}
+class M {}
+class B = A with M implements B;''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_IMPLEMENTS]);
verify([source]);
}
void test_recursiveInterfaceInheritanceBaseCaseWith() {
- Source source = addSource(EngineTestCase.createSource(["class M = Object with M;"]));
+ Source source = addSource("class M = Object with M;");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RECURSIVE_INTERFACE_INHERITANCE_BASE_CASE_WITH]);
verify([source]);
}
void test_redirectGenerativeToMissingConstructor() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() : this.noSuchConstructor();", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() : this.noSuchConstructor();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_MISSING_CONSTRUCTOR]);
}
void test_redirectGenerativeToNonGenerativeConstructor() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A() : this.x();",
- " factory A.x() => null;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A() : this.x();
+ factory A.x() => null;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REDIRECT_GENERATIVE_TO_NON_GENERATIVE_CONSTRUCTOR]);
verify([source]);
}
void test_redirectToMissingConstructor_named() {
- Source source = addSource(EngineTestCase.createSource([
- "class A implements B{",
- " A() {}",
- "}",
- "class B {",
- " const factory B() = A.name;",
- "}"]));
+ Source source = addSource(r'''
+class A implements B{
+ A() {}
+}
+class B {
+ const factory B() = A.name;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
}
void test_redirectToMissingConstructor_unnamed() {
- Source source = addSource(EngineTestCase.createSource([
- "class A implements B{",
- " A.name() {}",
- "}",
- "class B {",
- " const factory B() = A;",
- "}"]));
+ Source source = addSource(r'''
+class A implements B{
+ A.name() {}
+}
+class B {
+ const factory B() = A;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REDIRECT_TO_MISSING_CONSTRUCTOR]);
}
void test_redirectToNonClass_notAType() {
- Source source = addSource(EngineTestCase.createSource(["int A;", "class B {", " const factory B() = A;", "}"]));
+ Source source = addSource(r'''
+int A;
+class B {
+ const factory B() = A;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REDIRECT_TO_NON_CLASS]);
verify([source]);
}
void test_redirectToNonClass_undefinedIdentifier() {
- Source source = addSource(EngineTestCase.createSource(["class B {", " const factory B() = A;", "}"]));
+ Source source = addSource(r'''
+class B {
+ const factory B() = A;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REDIRECT_TO_NON_CLASS]);
verify([source]);
}
void test_redirectToNonConstConstructor() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A.a() {}",
- " const factory A.b() = A.a;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A.a() {}
+ const factory A.b() = A.a;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REDIRECT_TO_NON_CONST_CONSTRUCTOR]);
verify([source]);
}
void test_referencedBeforeDeclaration_hideInBlock_function() {
- Source source = addSource(EngineTestCase.createSource([
- "var v = 1;",
- "main() {",
- " print(v);",
- " v() {}",
- "}",
- "print(x) {}"]));
+ Source source = addSource(r'''
+var v = 1;
+main() {
+ print(v);
+ v() {}
+}
+print(x) {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
}
void test_referencedBeforeDeclaration_hideInBlock_local() {
- Source source = addSource(EngineTestCase.createSource([
- "var v = 1;",
- "main() {",
- " print(v);",
- " var v = 2;",
- "}",
- "print(x) {}"]));
+ Source source = addSource(r'''
+var v = 1;
+main() {
+ print(v);
+ var v = 2;
+}
+print(x) {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
}
void test_referencedBeforeDeclaration_hideInBlock_subBlock() {
- Source source = addSource(EngineTestCase.createSource([
- "var v = 1;",
- "main() {",
- " {",
- " print(v);",
- " }",
- " var v = 2;",
- "}",
- "print(x) {}"]));
+ Source source = addSource(r'''
+var v = 1;
+main() {
+ {
+ print(v);
+ }
+ var v = 2;
+}
+print(x) {}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
}
void test_referencedBeforeDeclaration_inInitializer_closure() {
- Source source = addSource(EngineTestCase.createSource(["main() {", " var v = () => v;", "}"]));
+ Source source = addSource(r'''
+main() {
+ var v = () => v;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
}
void test_referencedBeforeDeclaration_inInitializer_directly() {
- Source source = addSource(EngineTestCase.createSource(["main() {", " var v = v;", "}"]));
+ Source source = addSource(r'''
+main() {
+ var v = v;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.REFERENCED_BEFORE_DECLARATION]);
}
void test_rethrowOutsideCatch() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " rethrow;", "}"]));
+ Source source = addSource(r'''
+f() {
+ rethrow;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RETHROW_OUTSIDE_CATCH]);
verify([source]);
}
void test_returnInGenerativeConstructor() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() { return 0; }", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() { return 0; }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]);
verify([source]);
}
void test_returnInGenerativeConstructor_expressionFunctionBody() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " A() => null;", "}"]));
+ Source source = addSource(r'''
+class A {
+ A() => null;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATIVE_CONSTRUCTOR]);
verify([source]);
@@ -3643,7 +4194,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_returnInGenerator_asyncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f() async* {", " return 0;", "}"]));
+ Source source = addSource(r'''
+f() async* {
+ return 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATOR]);
verify([source]);
@@ -3651,7 +4205,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_returnInGenerator_syncStar() {
resetWithAsync();
- Source source = addSource(EngineTestCase.createSource(["f() sync* {", " return 0;", "}"]));
+ Source source = addSource(r'''
+f() sync* {
+ return 0;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.RETURN_IN_GENERATOR]);
verify([source]);
@@ -3659,135 +4216,142 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
void test_sharedDeferredPrefix() {
resolveWithAndWithoutExperimental(<String> [
- EngineTestCase.createSource(["library lib1;", "f1() {}"]),
- EngineTestCase.createSource(["library lib2;", "f2() {}"]),
- EngineTestCase.createSource([
- "library root;",
- "import 'lib1.dart' deferred as lib;",
- "import 'lib2.dart' as lib;",
- "main() { lib.f1(); lib.f2(); }"])], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.SHARED_DEFERRED_PREFIX]);
+ r'''
+library lib1;
+f1() {}''',
+ r'''
+library lib2;
+f2() {}''',
+ r'''
+library root;
+import 'lib1.dart' deferred as lib;
+import 'lib2.dart' as lib;
+main() { lib.f1(); lib.f2(); }'''], <ErrorCode> [ParserErrorCode.DEFERRED_IMPORTS_NOT_SUPPORTED], <ErrorCode> [CompileTimeErrorCode.SHARED_DEFERRED_PREFIX]);
}
void test_superInInvalidContext_binaryExpression() {
- Source source = addSource(EngineTestCase.createSource(["var v = super + 0;"]));
+ Source source = addSource("var v = super + 0;");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.v' is not resolved
}
void test_superInInvalidContext_constructorFieldInitializer() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {}",
- "}",
- "class B extends A {",
- " var f;",
- " B() : f = super.m();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+}
+class B extends A {
+ var f;
+ B() : f = super.m();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.m' is not resolved
}
void test_superInInvalidContext_factoryConstructor() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " m() {}",
- "}",
- "class B extends A {",
- " factory B() {",
- " super.m();",
- " }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ m() {}
+}
+class B extends A {
+ factory B() {
+ super.m();
+ }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.m' is not resolved
}
void test_superInInvalidContext_instanceVariableInitializer() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " var a;",
- "}",
- "class B extends A {",
- " var b = super.a;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ var a;
+}
+class B extends A {
+ var b = super.a;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.a' is not resolved
}
void test_superInInvalidContext_staticMethod() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static m() {}",
- "}",
- "class B extends A {",
- " static n() { return super.m(); }",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static m() {}
+}
+class B extends A {
+ static n() { return super.m(); }
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.m' is not resolved
}
void test_superInInvalidContext_staticVariableInitializer() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " static int a = 0;",
- "}",
- "class B extends A {",
- " static int b = super.a;",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ static int a = 0;
+}
+class B extends A {
+ static int b = super.a;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.a' is not resolved
}
void test_superInInvalidContext_topLevelFunction() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " super.f();", "}"]));
+ Source source = addSource(r'''
+f() {
+ super.f();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.f' is not resolved
}
void test_superInInvalidContext_topLevelVariableInitializer() {
- Source source = addSource(EngineTestCase.createSource(["var v = super.y;"]));
+ Source source = addSource("var v = super.y;");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_INVALID_CONTEXT]);
// no verify(), 'super.y' is not resolved
}
void test_superInRedirectingConstructor_redirectionSuper() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B {",
- " B() : this.name(), super();",
- " B.name() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {}
+class B {
+ B() : this.name(), super();
+ B.name() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR]);
verify([source]);
}
void test_superInRedirectingConstructor_superRedirection() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B {",
- " B() : super(), this.name();",
- " B.name() {}",
- "}"]));
+ Source source = addSource(r'''
+class A {}
+class B {
+ B() : super(), this.name();
+ B.name() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.SUPER_IN_REDIRECTING_CONSTRUCTOR]);
verify([source]);
}
void test_symbol_constructor_badArgs() {
- Source source = addSource(EngineTestCase.createSource([
- "var s1 = const Symbol('3');",
- "var s2 = const Symbol(3);",
- "var s3 = const Symbol();",
- "var s4 = const Symbol('x', 'y');",
- "var s5 = const Symbol('x', foo: 'x');"]));
+ Source source = addSource(r'''
+var s1 = const Symbol('3');
+var s2 = const Symbol(3);
+var s3 = const Symbol();
+var s4 = const Symbol('x', 'y');
+var s5 = const Symbol('x', foo: 'x');''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_THROWS_EXCEPTION,
@@ -3800,12 +4364,12 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_typeAliasCannotReferenceItself_11987() {
- Source source = addSource(EngineTestCase.createSource([
- "typedef void F(List<G> l);",
- "typedef void G(List<F> l);",
- "main() {",
- " F foo(G g) => g;",
- "}"]));
+ Source source = addSource(r'''
+typedef void F(List<G> l);
+typedef void G(List<F> l);
+main() {
+ F foo(G g) => g;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
@@ -3815,54 +4379,56 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_typeAliasCannotReferenceItself_parameterType_named() {
- Source source = addSource(EngineTestCase.createSource(["typedef A({A a});"]));
+ Source source = addSource("typedef A({A a});");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
verify([source]);
}
void test_typeAliasCannotReferenceItself_parameterType_positional() {
- Source source = addSource(EngineTestCase.createSource(["typedef A([A a]);"]));
+ Source source = addSource("typedef A([A a]);");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
verify([source]);
}
void test_typeAliasCannotReferenceItself_parameterType_required() {
- Source source = addSource(EngineTestCase.createSource(["typedef A(A a);"]));
+ Source source = addSource("typedef A(A a);");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
verify([source]);
}
void test_typeAliasCannotReferenceItself_parameterType_typeArgument() {
- Source source = addSource(EngineTestCase.createSource(["typedef A(List<A> a);"]));
+ Source source = addSource("typedef A(List<A> a);");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
verify([source]);
}
void test_typeAliasCannotReferenceItself_returnClass_withTypeAlias() {
- Source source = addSource(EngineTestCase.createSource([
- "typedef C A();",
- "typedef A B();",
- "class C {",
- " B a;",
- "}"]));
+ Source source = addSource(r'''
+typedef C A();
+typedef A B();
+class C {
+ B a;
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
verify([source]);
}
void test_typeAliasCannotReferenceItself_returnType() {
- Source source = addSource(EngineTestCase.createSource(["typedef A A();"]));
+ Source source = addSource("typedef A A();");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
verify([source]);
}
void test_typeAliasCannotReferenceItself_returnType_indirect() {
- Source source = addSource(EngineTestCase.createSource(["typedef B A();", "typedef A B();"]));
+ Source source = addSource(r'''
+typedef B A();
+typedef A B();''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF,
@@ -3871,102 +4437,105 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_typeAliasCannotReferenceItself_typeVariableBounds() {
- Source source = addSource(EngineTestCase.createSource(["typedef A<T extends A>();"]));
+ Source source = addSource("typedef A<T extends A>();");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ALIAS_CANNOT_REFERENCE_ITSELF]);
verify([source]);
}
void test_typeArgumentNotMatchingBounds_const() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B {}",
- "class G<E extends A> {",
- " const G();",
- "}",
- "f() { return const G<B>(); }"]));
+ Source source = addSource(r'''
+class A {}
+class B {}
+class G<E extends A> {
+ const G();
+}
+f() { return const G<B>(); }''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.TYPE_ARGUMENT_NOT_MATCHING_BOUNDS]);
verify([source]);
}
void test_undefinedClass_const() {
- Source source = addSource(EngineTestCase.createSource(["f() {", " return const A();", "}"]));
+ Source source = addSource(r'''
+f() {
+ return const A();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CLASS]);
verify([source]);
}
void test_undefinedConstructorInInitializer_explicit_named() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {}",
- "class B extends A {",
- " B() : super.named();",
- "}"]));
+ Source source = addSource(r'''
+class A {}
+class B extends A {
+ B() : super.named();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER]);
// no verify(), "super.named()" is not resolved
}
void test_undefinedConstructorInInitializer_explicit_unnamed() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A.named() {}",
- "}",
- "class B extends A {",
- " B() : super();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A.named() {}
+}
+class B extends A {
+ B() : super();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
verify([source]);
}
void test_undefinedConstructorInInitializer_implicit() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " A.named() {}",
- "}",
- "class B extends A {",
- " B();",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ A.named() {}
+}
+class B extends A {
+ B();
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.UNDEFINED_CONSTRUCTOR_IN_INITIALIZER_DEFAULT]);
verify([source]);
}
void test_undefinedNamedParameter() {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " const A();",
- "}",
- "main() {",
- " const A(p: 0);",
- "}"]));
+ Source source = addSource(r'''
+class A {
+ const A();
+}
+main() {
+ const A(p: 0);
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.UNDEFINED_NAMED_PARAMETER]);
// no verify(), 'p' is not resolved
}
void test_uriDoesNotExist_export() {
- Source source = addSource(EngineTestCase.createSource(["export 'unknown.dart';"]));
+ Source source = addSource("export 'unknown.dart';");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
}
void test_uriDoesNotExist_import() {
- Source source = addSource(EngineTestCase.createSource(["import 'unknown.dart';"]));
+ Source source = addSource("import 'unknown.dart';");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
}
void test_uriDoesNotExist_part() {
- Source source = addSource(EngineTestCase.createSource(["part 'unknown.dart';"]));
+ Source source = addSource("part 'unknown.dart';");
resolve(source);
assertErrors(source, [CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
}
void test_uriWithInterpolation_constant() {
- Source source = addSource(EngineTestCase.createSource(["import 'stuff_\$platform.dart';"]));
+ Source source = addSource("import 'stuff_\$platform.dart';");
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.URI_WITH_INTERPOLATION,
@@ -3975,14 +4544,19 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_uriWithInterpolation_nonConstant() {
- Source source = addSource(EngineTestCase.createSource(["library lib;", "part '\${'a'}.dart';"]));
+ Source source = addSource(r'''
+library lib;
+part '${'a'}.dart';''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.URI_WITH_INTERPOLATION]);
// We cannot verify resolution with an unresolvable URI: '${'a'}.dart'
}
void test_wrongNumberOfParametersForOperator_minus() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " operator -(a, b) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ operator -(a, b) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR_MINUS]);
verify([source]);
@@ -4041,28 +4615,40 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void test_wrongNumberOfParametersForSetter_method_named() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " set x({p}) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ set x({p}) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
verify([source]);
}
void test_wrongNumberOfParametersForSetter_method_optional() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " set x([p]) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ set x([p]) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
verify([source]);
}
void test_wrongNumberOfParametersForSetter_method_tooFew() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " set x() {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ set x() {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
verify([source]);
}
void test_wrongNumberOfParametersForSetter_method_tooMany() {
- Source source = addSource(EngineTestCase.createSource(["class A {", " set x(a, b) {}", "}"]));
+ Source source = addSource(r'''
+class A {
+ set x(a, b) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_SETTER]);
verify([source]);
@@ -4082,11 +4668,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void _check_constEvalTypeBool_withParameter_binary(String expr) {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final a;",
- " const A(bool p) : a = ${expr};",
- "}"]));
+ Source source = addSource('''
+class A {
+ final a;
+ const A(bool p) : a = $expr;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_TYPE_BOOL,
@@ -4096,11 +4682,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void _check_constEvalTypeInt_withParameter_binary(String expr) {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final a;",
- " const A(int p) : a = ${expr};",
- "}"]));
+ Source source = addSource('''
+class A {
+ final a;
+ const A(int p) : a = $expr;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_TYPE_INT,
@@ -4110,11 +4696,11 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void _check_constEvalTypeNum_withParameter_binary(String expr) {
- Source source = addSource(EngineTestCase.createSource([
- "class A {",
- " final a;",
- " const A(num p) : a = ${expr};",
- "}"]));
+ Source source = addSource('''
+class A {
+ final a;
+ const A(num p) : a = $expr;
+}''');
resolve(source);
assertErrors(source, [
CompileTimeErrorCode.CONST_EVAL_TYPE_NUM,
@@ -4124,7 +4710,10 @@ class CompileTimeErrorCodeTest extends ResolverTestCase {
}
void _check_wrongNumberOfParametersForOperator(String name, String parameters) {
- Source source = addSource(EngineTestCase.createSource(["class A {", " operator ${name}(${parameters}) {}", "}"]));
+ Source source = addSource('''
+class A {
+ operator $name($parameters) {}
+}''');
resolve(source);
assertErrors(source, [CompileTimeErrorCode.WRONG_NUMBER_OF_PARAMETERS_FOR_OPERATOR]);
verify([source]);
« no previous file with comments | « pkg/analyzer/test/generated/ast_test.dart ('k') | pkg/analyzer/test/generated/element_test.dart » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698