Remove trailing spaces in analyzer_experimental

pkg/analyzer_experimental/test/generated/resolver_test.dart

 // This code was auto-generated, is not intended to be edited, and is subject to
 // significant change. Please see the README file for more information.
-
 library engine.resolver_test;
-
 import 'dart:collection';
 import 'package:analyzer_experimental/src/generated/java_core.dart';
 import 'package:analyzer_experimental/src/generated/java_engine.dart';
 import 'package:analyzer_experimental/src/generated/java_junit.dart';
 import 'package:analyzer_experimental/src/generated/source_io.dart';
 import 'package:analyzer_experimental/src/generated/error.dart';
 import 'package:analyzer_experimental/src/generated/scanner.dart';
 import 'package:analyzer_experimental/src/generated/ast.dart' hide Annotation;
 import 'package:analyzer_experimental/src/generated/parser.dart' show ParserErrorCode;
 import 'package:analyzer_experimental/src/generated/element.dart';
 import 'package:analyzer_experimental/src/generated/resolver.dart';
 import 'package:analyzer_experimental/src/generated/engine.dart';
 import 'package:analyzer_experimental/src/generated/java_engine_io.dart';
 import 'package:analyzer_experimental/src/generated/sdk.dart' show DartSdk;
 import 'package:analyzer_experimental/src/generated/sdk_io.dart' show DirectoryBasedDartSdk;
 import 'package:unittest/unittest.dart' as _ut;
 import 'test_support.dart';
 import 'ast_test.dart' show ASTFactory;
 import 'element_test.dart' show ElementFactory;
-
 class TypePropagationTest extends ResolverTestCase {
   void test_as() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  bool get g => true;", "}", "A f(var p) {", "  if ((p as A).g) {", "    return p;", "  } else {", "    return null;", "  }", "}"]));
     LibraryElement library = resolve(source);
     assertNoErrors();
     verify([source]);
     CompilationUnit unit = resolveCompilationUnit(source, library);
     ClassDeclaration classA = unit.declarations[0] as ClassDeclaration;
     InterfaceType typeA = classA.element.type;
     FunctionDeclaration function = unit.declarations[1] as FunctionDeclaration;
@@ skipping 4151 matching lines @@
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_FORMAL_PARAMETER]);
     verify([source]);
   }
   void test_constInitializedWithNonConstValue() {
     Source source = addSource(EngineTestCase.createSource(["f(p) {", "  const C = p;", "}"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
     verify([source]);
   }
+  void test_constInitializedWithNonConstValue_missingConstInListLiteral() {
+    Source source = addSource("const List L = [0];");
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    verify([source]);
+  }
+  void test_constInitializedWithNonConstValue_missingConstInMapLiteral() {
+    Source source = addSource("const Map M = {'a' : 0};");
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.CONST_INITIALIZED_WITH_NON_CONSTANT_VALUE]);
+    verify([source]);
+  }
   void test_constWithInvalidTypeParameters() {
     Source source = addSource(EngineTestCase.createSource(["class A {", "  const A();", "}", "f() { return const A<A>(); }"]));
     resolve(source);
     assertErrors([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); }"]));
     resolve(source);
     assertErrors([CompileTimeErrorCode.CONST_WITH_NON_CONST]);
@@ skipping 1353 matching lines @@
         runJUnitTest(__test, __test.test_constFormalParameter_fieldFormalParameter);
       });
       _ut.test('test_constFormalParameter_simpleFormalParameter', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constFormalParameter_simpleFormalParameter);
       });
       _ut.test('test_constInitializedWithNonConstValue', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constInitializedWithNonConstValue);
       });
+      _ut.test('test_constInitializedWithNonConstValue_missingConstInListLiteral', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constInitializedWithNonConstValue_missingConstInListLiteral);
+      });
+      _ut.test('test_constInitializedWithNonConstValue_missingConstInMapLiteral', () {
+        final __test = new CompileTimeErrorCodeTest();
+        runJUnitTest(__test, __test.test_constInitializedWithNonConstValue_missingConstInMapLiteral);
+      });
       _ut.test('test_constWithInvalidTypeParameters', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithInvalidTypeParameters);
       });
       _ut.test('test_constWithNonConst', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_constWithNonConst);
       });
       _ut.test('test_constWithNonConstantArgument', () {
         final __test = new CompileTimeErrorCodeTest();
@@ skipping 763 matching lines @@
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_tooFew);
       });
       _ut.test('test_wrongNumberOfParametersForSetter_method_tooMany', () {
         final __test = new CompileTimeErrorCodeTest();
         runJUnitTest(__test, __test.test_wrongNumberOfParametersForSetter_method_tooMany);
       });
     });
   }
 }
-
 /**
  * Instances of the class {@code StaticTypeVerifier} verify that all of the nodes in an AST
  * structure that should have a static type associated with them do have a static type.
  */
 class StaticTypeVerifier extends GeneralizingASTVisitor<Object> {
 
   /**
    * A list containing all of the AST Expression nodes that were not resolved.
    */
   List<Expression> _unresolvedExpressions = new List<Expression>();
@@ skipping 114 matching lines @@
         } else {
           return "<unknown file- CompilationUnit.getElement() returned null>";
         }
       } else {
         return "<unknown file- CompilationUnit.getRoot() is not a CompilationUnit>";
       }
     }
     return "<unknown file- ASTNode is null>";
   }
 }
+/**
+ * The class {@code StrictModeTest} contains tests to ensure that the correct errors and warnings
+ * are reported when the analysis engine is run in strict mode.
+ */
+class StrictModeTest extends ResolverTestCase {
+  void fail_for() {
+    Source source = addSource(EngineTestCase.createSource(["int f(List<int> list) {", "  num sum = 0;", "  for (num i = 0; i < list.length; i++) {", "    sum += list[i];", "  }", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void setUp() {
+    super.setUp();
+    AnalysisOptionsImpl options = new AnalysisOptionsImpl();
+    options.strictMode = true;
+    analysisContext.analysisOptions = options;
+  }
+  void test_assert_is() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  assert (n is int);", "  return n & 0x0F;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_conditional_and_is() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  return (n is int && n > 0) ? n & 0x0F : 0;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_conditional_is() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  return (n is int) ? n & 0x0F : 0;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_conditional_isNot() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  return (n is! int) ? 0 : n & 0x0F;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_conditional_or_is() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  return (n is! int || n < 0) ? 0 : n & 0x0F;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_forEach() {
+    Source source = addSource(EngineTestCase.createSource(["int f(List<int> list) {", "  num sum = 0;", "  for (num n in list) {", "    sum += n & 0x0F;", "  }", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_if_and_is() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  if (n is int && n > 0) {", "    return n & 0x0F;", "  }", "  return 0;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_if_is() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  if (n is int) {", "    return n & 0x0F;", "  }", "  return 0;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_if_isNot() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  if (n is! int) {", "    return 0;", "  } else {", "    return n & 0x0F;", "  }", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_if_isNot_abrupt() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  if (n is! int) {", "    return 0;", "  }", "  return n & 0x0F;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_if_or_is() {
+    Source source = addSource(EngineTestCase.createSource(["int f(num n) {", "  if (n is! int || n < 0) {", "    return 0;", "  } else {", "    return n & 0x0F;", "  }", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  void test_localVar() {
+    Source source = addSource(EngineTestCase.createSource(["int f() {", "  num n = 1234;", "  return n & 0x0F;", "}"]));
+    resolve(source);
+    assertErrors([StaticTypeWarningCode.UNDEFINED_OPERATOR]);
+  }
+  static dartSuite() {
+    _ut.group('StrictModeTest', () {
+      _ut.test('test_assert_is', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_assert_is);
+      });
+      _ut.test('test_conditional_and_is', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_conditional_and_is);
+      });
+      _ut.test('test_conditional_is', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_conditional_is);
+      });
+      _ut.test('test_conditional_isNot', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_conditional_isNot);
+      });
+      _ut.test('test_conditional_or_is', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_conditional_or_is);
+      });
+      _ut.test('test_forEach', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_forEach);
+      });
+      _ut.test('test_if_and_is', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_if_and_is);
+      });
+      _ut.test('test_if_is', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_if_is);
+      });
+      _ut.test('test_if_isNot', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_if_isNot);
+      });
+      _ut.test('test_if_isNot_abrupt', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_if_isNot_abrupt);
+      });
+      _ut.test('test_if_or_is', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_if_or_is);
+      });
+      _ut.test('test_localVar', () {
+        final __test = new StrictModeTest();
+        runJUnitTest(__test, __test.test_localVar);
+      });
+    });
+  }
+}
 class ElementResolverTest extends EngineTestCase {
 
   /**
    * The error listener to which errors will be reported.
    */
   GatheringErrorListener _listener;
 
   /**
    * The type provider used to access the types.
    */
@@ skipping 743 matching lines @@
         final __test = new TypeOverrideManagerTest();
         runJUnitTest(__test, __test.test_getType_noOverride);
       });
       _ut.test('test_getType_noScope', () {
         final __test = new TypeOverrideManagerTest();
         runJUnitTest(__test, __test.test_getType_noScope);
       });
     });
   }
 }
+class PubSuggestionCodeTest extends ResolverTestCase {
+  void test_import_packageWithDotDot() {
+    Source source = addSource(EngineTestCase.createSource(["import 'package:somepackage/../other.dart';"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST, PubSuggestionCode.PACKAGE_IMPORT_CONTAINS_DOT_DOT]);
+  }
+  void test_import_referenceIntoLibDirectory() {
+    Source source = addSource(EngineTestCase.createSource(["import '../lib/other.dart';"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST, PubSuggestionCode.FILE_IMPORT_OUTSIDE_LIB_REFERENCES_FILE_INSIDE]);
+  }
+  void test_import_referenceOutOfLibDirectory() {
+    Source source = addSource2("lib/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST, PubSuggestionCode.FILE_IMPORT_INSIDE_LIB_REFERENCES_FILE_OUTSIDE]);
+  }
+  void test_import_valid() {
+    Source source = addSource2("lib2/test.dart", EngineTestCase.createSource(["import '../web/other.dart';"]));
+    resolve(source);
+    assertErrors([CompileTimeErrorCode.URI_DOES_NOT_EXIST]);
+  }
+  static dartSuite() {
+    _ut.group('PubSuggestionCodeTest', () {
+      _ut.test('test_import_packageWithDotDot', () {
+        final __test = new PubSuggestionCodeTest();
+        runJUnitTest(__test, __test.test_import_packageWithDotDot);
+      });
+      _ut.test('test_import_referenceIntoLibDirectory', () {
+        final __test = new PubSuggestionCodeTest();
+        runJUnitTest(__test, __test.test_import_referenceIntoLibDirectory);
+      });
+      _ut.test('test_import_referenceOutOfLibDirectory', () {
+        final __test = new PubSuggestionCodeTest();
+        runJUnitTest(__test, __test.test_import_referenceOutOfLibDirectory);
+      });
+      _ut.test('test_import_valid', () {
+        final __test = new PubSuggestionCodeTest();
+        runJUnitTest(__test, __test.test_import_valid);
+      });
+    });
+  }
+}
 class StaticWarningCodeTest extends ResolverTestCase {
   void fail_argumentTypeNotAssignable_invocation_functionParameter_generic() {
     Source source = addSource(EngineTestCase.createSource(["class A<K, V> {", "  m(f(K k), V v) {", "    f(v);", "  }", "}"]));
     resolve(source);
     assertErrors([StaticWarningCode.ARGUMENT_TYPE_NOT_ASSIGNABLE]);
     verify([source]);
   }
   void fail_castToNonType() {
     Source source = addSource(EngineTestCase.createSource(["var A = 0;", "f(String s) { var x = s as A; }"]));
     resolve(source);
@@ skipping 1198 matching lines @@
         final __test = new ErrorResolverTest();
         runJUnitTest(__test, __test.test_breakLabelOnSwitchMember);
       });
       _ut.test('test_continueLabelOnSwitch', () {
         final __test = new ErrorResolverTest();
         runJUnitTest(__test, __test.test_continueLabelOnSwitch);
       });
     });
   }
 }
-
 /**
  * Instances of the class {@code TestTypeProvider} implement a type provider that can be used by
  * tests without creating the element model for the core library.
  */
 class TestTypeProvider implements TypeProvider {
 
   /**
    * The type representing the built-in type 'bool'.
    */
   InterfaceType _boolType;
@@ skipping 122 matching lines @@
     return _iteratorType;
   }
   InterfaceType get listType {
     if (_listType == null) {
       ClassElementImpl listElement = ElementFactory.classElement2("List", ["E"]);
       listElement.constructors = <ConstructorElement> [ElementFactory.constructorElement(listElement, null)];
       _listType = listElement.type;
       Type2 eType = listElement.typeVariables[0].type;
       InterfaceType supertype = iterableType.substitute5(<Type2> [eType]);
       listElement.supertype = supertype;
-      listElement.methods = <MethodElement> [ElementFactory.methodElement("[]", eType, [_intType]), ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [_intType, eType])];
+      listElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, intType)];
+      listElement.methods = <MethodElement> [ElementFactory.methodElement("[]", eType, [intType]), ElementFactory.methodElement("[]=", VoidTypeImpl.instance, [intType, eType])];
     }
     return _listType;
   }
   InterfaceType get mapType {
     if (_mapType == null) {
       ClassElementImpl mapElement = ElementFactory.classElement2("Map", ["K", "V"]);
       _mapType = mapElement.type;
-      mapElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, _intType)];
+      mapElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("length", false, intType)];
     }
     return _mapType;
   }
   InterfaceType get numType {
     if (_numType == null) {
       initializeNumericTypes();
     }
     return _numType;
   }
   InterfaceType get objectType {
     if (_objectType == null) {
       ClassElementImpl objectElement = ElementFactory.object;
       _objectType = objectElement.type;
       if (objectElement.methods.length == 0) {
         objectElement.constructors = <ConstructorElement> [ElementFactory.constructorElement(objectElement, null)];
-        objectElement.methods = <MethodElement> [ElementFactory.methodElement("toString", stringType, []), ElementFactory.methodElement("==", _boolType, [_objectType]), ElementFactory.methodElement("noSuchMethod", dynamicType, [dynamicType])];
+        objectElement.methods = <MethodElement> [ElementFactory.methodElement("toString", stringType, []), ElementFactory.methodElement("==", boolType, [_objectType]), ElementFactory.methodElement("noSuchMethod", dynamicType, [dynamicType])];
         objectElement.accessors = <PropertyAccessorElement> [ElementFactory.getterElement("hashCode", false, intType), ElementFactory.getterElement("runtimeType", false, typeType)];
       }
     }
     return _objectType;
   }
   InterfaceType get stackTraceType {
     if (_stackTraceType == null) {
       _stackTraceType = ElementFactory.classElement2("StackTrace", []).type;
     }
     return _stackTraceType;
@@ skipping 33 matching lines @@
     doubleElement.fields = fields;
     int fieldCount = fields.length;
     List<PropertyAccessorElement> accessors = new List<PropertyAccessorElement>(fieldCount);
     for (int i = 0; i < fieldCount; i++) {
       accessors[i] = fields[i].getter;
     }
     doubleElement.accessors = accessors;
     doubleElement.methods = <MethodElement> [ElementFactory.methodElement("remainder", _doubleType, [_numType]), ElementFactory.methodElement("+", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, [_numType]), ElementFactory.methodElement("*", _doubleType, [_numType]), ElementFactory.methodElement("%", _doubleType, [_numType]), ElementFactory.methodElement("/", _doubleType, [_numType]), ElementFactory.methodElement("~/", _doubleType, [_numType]), ElementFactory.methodElement("-", _doubleType, []), ElementFactory.methodElement("abs", _doubleType, []), ElementFactory.methodElement("round", _doubleType, []), ElementFactory.methodElement("floor", _doubleType, []), ElementFactory.methodElement("ceil", _doubleType, []), ElementFactory.methodElement("truncate", _doubleType, []), ElementFactory.methodElement("toString", _stringType, [])];
   }
 }
-
 /**
  * The class {@code AnalysisContextFactory} defines utility methods used to create analysis contexts
  * for testing purposes.
  */
 class AnalysisContextFactory {
 
   /**
    * Create an analysis context that has a fake core library already resolved.
    * @return the analysis context that was created
    */
@@ skipping 153 matching lines @@
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_getErrorListener);
       });
       _ut.test('test_prefixedAndNonPrefixed', () {
         final __test = new LibraryImportScopeTest();
         runJUnitTest(__test, __test.test_prefixedAndNonPrefixed);
       });
     });
   }
 }
-
 /**
  * Instances of the class {@code ResolutionVerifier} verify that all of the nodes in an AST
  * structure that should have been resolved were resolved.
  */
 class ResolutionVerifier extends RecursiveASTVisitor<Object> {
 
   /**
    * A set containing nodes that are known to not be resolvable and should therefore not cause the
    * test to fail.
    */
   Set<ASTNode> _knownExceptions;
 
   /**
    * A list containing all of the AST nodes that were not resolved.
    */
   List<ASTNode> _unresolvedNodes = new List<ASTNode>();
 
   /**
    * A list containing all of the AST nodes that were resolved to an element of the wrong type.
    */
   List<ASTNode> _wrongTypedNodes = new List<ASTNode>();
 
   /**
    * Initialize a newly created verifier to verify that all of the nodes in the visited AST
    * structures that are expected to have been resolved have an element associated with them.
    */
   ResolutionVerifier() {
-    _jtd_constructor_359_impl();
+    _jtd_constructor_361_impl();
   }
-  _jtd_constructor_359_impl() {
-    _jtd_constructor_360_impl(null);
+  _jtd_constructor_361_impl() {
+    _jtd_constructor_362_impl(null);
   }
 
   /**
    * Initialize a newly created verifier to verify that all of the identifiers in the visited AST
    * structures that are expected to have been resolved have an element associated with them. Nodes
    * in the set of known exceptions are not expected to have been resolved, even if they normally
    * would have been expected to have been resolved.
    * @param knownExceptions a set containing nodes that are known to not be resolvable and should
    * therefore not cause the test to fail
    */
   ResolutionVerifier.con1(Set<ASTNode> knownExceptions2) {
-    _jtd_constructor_360_impl(knownExceptions2);
+    _jtd_constructor_362_impl(knownExceptions2);
   }
-  _jtd_constructor_360_impl(Set<ASTNode> knownExceptions2) {
+  _jtd_constructor_362_impl(Set<ASTNode> knownExceptions2) {
     this._knownExceptions = knownExceptions2;
   }
 
   /**
    * Assert that all of the visited identifiers were resolved.
    */
   void assertResolved() {
     if (!_unresolvedNodes.isEmpty || !_wrongTypedNodes.isEmpty) {
       PrintStringWriter writer = new PrintStringWriter();
       if (!_unresolvedNodes.isEmpty) {
@@ skipping 1479 matching lines @@
         final __test = new ScopeTest();
         runJUnitTest(__test, __test.test_isPrivateName_nonPrivate);
       });
       _ut.test('test_isPrivateName_private', () {
         final __test = new ScopeTest();
         runJUnitTest(__test, __test.test_isPrivateName_private);
       });
     });
   }
 }
-
 /**
  * A non-abstract subclass that can be used for testing purposes.
  */
 class ScopeTest_TestScope extends Scope {
 
   /**
    * The element representing the library in which this scope is enclosed.
    */
   LibraryElement _definingLibrary;
 
@@ skipping 548 matching lines @@
 //  TypeOverrideManagerTest.dartSuite();
 //  TypeProviderImplTest.dartSuite();
 //  TypeResolverVisitorTest.dartSuite();
 //  EnclosedScopeTest.dartSuite();
 //  LibraryImportScopeTest.dartSuite();
 //  LibraryScopeTest.dartSuite();
 //  ScopeTest.dartSuite();
 //  CompileTimeErrorCodeTest.dartSuite();
 //  ErrorResolverTest.dartSuite();
 //  NonErrorResolverTest.dartSuite();
+//  PubSuggestionCodeTest.dartSuite();
 //  SimpleResolverTest.dartSuite();
 //  StaticTypeWarningCodeTest.dartSuite();
 //  StaticWarningCodeTest.dartSuite();
+//  StrictModeTest.dartSuite();
 //  TypePropagationTest.dartSuite();
 }