Use AbstractContextTest for AnalysisContextImplTest.

pkg/analyzer/test/src/context/context_test.dart

 // Copyright (c) 2014, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 library test.src.context.context_test;
 
 import 'dart:async';
 
 import 'package:analyzer/src/cancelable_future.dart';
 import 'package:analyzer/src/context/cache.dart';
@@ skipping 13 matching lines @@
         AnalysisOptionsImpl,
         AnalysisResult,
         CacheState,
         ChangeNotice,
         ChangeSet,
         IncrementalAnalysisCache,
         TimestampedData;
 import 'package:analyzer/src/generated/error.dart';
 import 'package:analyzer/src/generated/html.dart' as ht;
 import 'package:analyzer/src/generated/java_engine.dart';
-import 'package:analyzer/src/generated/java_engine_io.dart';
 import 'package:analyzer/src/generated/resolver.dart';
 import 'package:analyzer/src/generated/scanner.dart';
-import 'package:analyzer/src/generated/sdk.dart';
-import 'package:analyzer/src/generated/sdk_io.dart';
 import 'package:analyzer/src/generated/source.dart';
-import 'package:analyzer/src/generated/source_io.dart';
-import 'package:analyzer/src/plugin/engine_plugin.dart';
 import 'package:analyzer/task/dart.dart';
-import 'package:plugin/manager.dart';
 import 'package:unittest/unittest.dart';
 import 'package:watcher/src/utils.dart';
 
 import '../../generated/engine_test.dart';
 import '../../generated/test_support.dart';
 import '../../reflective_tests.dart';
-import '../mock_sdk.dart';
+import 'abstract_context.dart';
 
 main() {
   groupSep = ' | ';
   runReflectiveTests(AnalysisContextImplTest);
 }
 
-contextWithCore() {
-  return new AnalysisContextForTests();
-}
-
-/**
- * An analysis context that has a fake SDK that is much smaller and faster for
- * testing purposes.
- */
-class AnalysisContextForTests extends AnalysisContextImpl {
-  AnalysisContextForTests() {
-    DartSdk sdk = new MockSdk();
-    SourceFactory sourceFactory =
-        new SourceFactory([new DartUriResolver(sdk), new FileUriResolver()]);
-    this.sourceFactory = sourceFactory;
-  }
-
-  @override
-  void set analysisOptions(AnalysisOptions options) {
-    AnalysisOptions currentOptions = analysisOptions;
-    bool needsRecompute = currentOptions.analyzeFunctionBodiesPredicate !=
-            options.analyzeFunctionBodiesPredicate ||
-        currentOptions.generateImplicitErrors !=
-            options.generateImplicitErrors ||
-        currentOptions.generateSdkErrors != options.generateSdkErrors ||
-        currentOptions.dart2jsHint != options.dart2jsHint ||
-        (currentOptions.hint && !options.hint) ||
-        currentOptions.preserveComments != options.preserveComments ||
-        currentOptions.enableNullAwareOperators !=
-            options.enableNullAwareOperators ||
-        currentOptions.enableStrictCallChecks != options.enableStrictCallChecks;
-    if (needsRecompute) {
-      fail(
-          "Cannot set options that cause the sources to be reanalyzed in a test context");
-    }
-    super.analysisOptions = options;
-  }
-
-  @override
-  LibraryResolverFactory get libraryResolverFactory => null;
-
-  @override
-  bool exists(Source source) =>
-      super.exists(source) || sourceFactory.dartSdk.context.exists(source);
-
-  @override
-  TimestampedData<String> getContents(Source source) {
-    if (source.isInSystemLibrary) {
-      return sourceFactory.dartSdk.context.getContents(source);
-    }
-    return super.getContents(source);
-  }
-
-  @override
-  int getModificationStamp(Source source) {
-    if (source.isInSystemLibrary) {
-      return sourceFactory.dartSdk.context.getModificationStamp(source);
-    }
-    return super.getModificationStamp(source);
-  }
-
-//  /**
-//   * Set the analysis options, even if they would force re-analysis. This method should only be
-//   * invoked before the fake SDK is initialized.
-//   *
-//   * @param options the analysis options to be set
-//   */
-//  void _internalSetAnalysisOptions(AnalysisOptions options) {
-//    super.analysisOptions = options;
-//  }
-}
-
 @reflectiveTest
-class AnalysisContextImplTest extends EngineTestCase {
-  /**
-   * An analysis context whose source factory is [sourceFactory].
-   */
-  AnalysisContextImpl _context;
-
-  /**
-   * The source factory associated with the analysis [context].
-   */
-  SourceFactory _sourceFactory;
-
+class AnalysisContextImplTest extends AbstractContextTest {
   void fail_applyChanges_empty() {
-    _context.applyChanges(new ChangeSet());
-    expect(_context.performAnalysisTask().changeNotices, isNull);
+    context.applyChanges(new ChangeSet());
+    expect(context.performAnalysisTask().changeNotices, isNull);
     // This test appears to be flaky. If it is named "test_" it fails, if it's
     // named "fail_" it doesn't fail. I'm guessing that it's dependent on
     // whether some other test is run.
     fail('Should have failed');
   }
 
   void fail_applyChanges_overriddenSource() {
     // Note: addSource adds the source to the contentCache.
-    Source source = _addSource("/test.dart", "library test;");
-    _context.computeErrors(source);
-    while (!_context.sourcesNeedingProcessing.isEmpty) {
-      _context.performAnalysisTask();
+    Source source = addSource("/test.dart", "library test;");
+    context.computeErrors(source);
+    while (!context.sourcesNeedingProcessing.isEmpty) {
+      context.performAnalysisTask();
     }
     // Adding the source as a changedSource should have no effect since
     // it is already overridden in the content cache.
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedSource(source);
-    _context.applyChanges(changeSet);
-    expect(_context.sourcesNeedingProcessing, hasLength(0));
+    context.applyChanges(changeSet);
+    expect(context.sourcesNeedingProcessing, hasLength(0));
   }
 
   Future fail_applyChanges_remove() {
-    _context = contextWithCore();
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    _sourceFactory = _context.sourceFactory;
+    context.onSourcesChanged.listen(listener.onData);
     String libAContents = r'''
 library libA;
 import 'libB.dart';''';
-    Source libA = _addSource("/libA.dart", libAContents);
+    Source libA = addSource("/libA.dart", libAContents);
     String libBContents = "library libB;";
-    Source libB = _addSource("/libB.dart", libBContents);
-    LibraryElement libAElement = _context.computeLibraryElement(libA);
+    Source libB = addSource("/libB.dart", libBContents);
+    LibraryElement libAElement = context.computeLibraryElement(libA);
     expect(libAElement, isNotNull);
     List<LibraryElement> importedLibraries = libAElement.importedLibraries;
     expect(importedLibraries, hasLength(2));
-    _context.computeErrors(libA);
-    _context.computeErrors(libB);
-    expect(_context.sourcesNeedingProcessing, hasLength(0));
-    _context.setContents(libB, null);
+    context.computeErrors(libA);
+    context.computeErrors(libB);
+    expect(context.sourcesNeedingProcessing, hasLength(0));
+    context.setContents(libB, null);
     _removeSource(libB);
-    List<Source> sources = _context.sourcesNeedingProcessing;
+    List<Source> sources = context.sourcesNeedingProcessing;
     expect(sources, hasLength(1));
     expect(sources[0], same(libA));
-    libAElement = _context.computeLibraryElement(libA);
+    libAElement = context.computeLibraryElement(libA);
     importedLibraries = libAElement.importedLibraries;
     expect(importedLibraries, hasLength(1));
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [libA]);
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [libB]);
       listener.assertEvent(changedSources: [libB]);
       listener.assertEvent(wereSourcesRemovedOrDeleted: true);
       listener.assertNoMoreEvents();
     });
   }
 
   Future fail_applyChanges_removeContainer() {
-    _context = contextWithCore();
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    _sourceFactory = _context.sourceFactory;
+    context.onSourcesChanged.listen(listener.onData);
     String libAContents = r'''
 library libA;
 import 'libB.dart';''';
-    Source libA = _addSource("/libA.dart", libAContents);
+    Source libA = addSource("/libA.dart", libAContents);
     String libBContents = "library libB;";
-    Source libB = _addSource("/libB.dart", libBContents);
-    _context.computeLibraryElement(libA);
-    _context.computeErrors(libA);
-    _context.computeErrors(libB);
-    expect(_context.sourcesNeedingProcessing, hasLength(0));
+    Source libB = addSource("/libB.dart", libBContents);
+    context.computeLibraryElement(libA);
+    context.computeErrors(libA);
+    context.computeErrors(libB);
+    expect(context.sourcesNeedingProcessing, hasLength(0));
     ChangeSet changeSet = new ChangeSet();
     SourceContainer removedContainer =
         new _AnalysisContextImplTest_test_applyChanges_removeContainer(libB);
     changeSet.removedContainer(removedContainer);
-    _context.applyChanges(changeSet);
-    List<Source> sources = _context.sourcesNeedingProcessing;
+    context.applyChanges(changeSet);
+    List<Source> sources = context.sourcesNeedingProcessing;
     expect(sources, hasLength(1));
     expect(sources[0], same(libA));
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [libA]);
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [libB]);
       listener.assertEvent(wereSourcesRemovedOrDeleted: true);
       listener.assertNoMoreEvents();
     });
   }
 
   void fail_computeErrors_dart_none() {
-    Source source = _addSource("/lib.dart", "library lib;");
-    List<AnalysisError> errors = _context.computeErrors(source);
+    Source source = addSource("/lib.dart", "library lib;");
+    List<AnalysisError> errors = context.computeErrors(source);
     expect(errors, hasLength(0));
   }
 
   void fail_computeErrors_dart_part() {
     Source librarySource =
-        _addSource("/lib.dart", "library lib; part 'part.dart';");
-    Source partSource = _addSource("/part.dart", "part of 'lib';");
-    _context.parseCompilationUnit(librarySource);
-    List<AnalysisError> errors = _context.computeErrors(partSource);
+        addSource("/lib.dart", "library lib; part 'part.dart';");
+    Source partSource = addSource("/part.dart", "part of 'lib';");
+    context.parseCompilationUnit(librarySource);
+    List<AnalysisError> errors = context.computeErrors(partSource);
     expect(errors, isNotNull);
     expect(errors.length > 0, isTrue);
   }
 
   void fail_computeErrors_dart_some() {
-    Source source = _addSource("/lib.dart", "library 'lib';");
-    List<AnalysisError> errors = _context.computeErrors(source);
+    Source source = addSource("/lib.dart", "library 'lib';");
+    List<AnalysisError> errors = context.computeErrors(source);
     expect(errors, isNotNull);
     expect(errors.length > 0, isTrue);
   }
 
   void fail_computeErrors_html_none() {
-    Source source = _addSource("/test.html", "<html></html>");
-    List<AnalysisError> errors = _context.computeErrors(source);
+    Source source = addSource("/test.html", "<html></html>");
+    List<AnalysisError> errors = context.computeErrors(source);
     expect(errors, hasLength(0));
   }
 
   void fail_computeHtmlElement_valid() {
-    Source source = _addSource("/test.html", "<html></html>");
-    HtmlElement element = _context.computeHtmlElement(source);
+    Source source = addSource("/test.html", "<html></html>");
+    HtmlElement element = context.computeHtmlElement(source);
     expect(element, isNotNull);
-    expect(_context.computeHtmlElement(source), same(element));
+    expect(context.computeHtmlElement(source), same(element));
   }
 
   void fail_computeImportedLibraries_none() {
     // This is failing because computeImportedLibraries now always includes
     // dart:core, and we don't have any way of knowing whether it was explicit.
-    Source source = _addSource("/test.dart", "library test;");
-    expect(_context.computeImportedLibraries(source), hasLength(0));
+    Source source = addSource("/test.dart", "library test;");
+    expect(context.computeImportedLibraries(source), hasLength(0));
   }
 
   void fail_computeImportedLibraries_some() {
     // This is failing because computeImportedLibraries now always includes
     // dart:core, and we don't have any way of knowing whether it was explicit.
     //    addSource("/lib1.dart", "library lib1;");
     //    addSource("/lib2.dart", "library lib2;");
-    Source source = _addSource(
+    Source source = addSource(
         "/test.dart", "library test; import 'lib1.dart'; import 'lib2.dart';");
-    expect(_context.computeImportedLibraries(source), hasLength(2));
+    expect(context.computeImportedLibraries(source), hasLength(2));
   }
 
   void fail_computeResolvableCompilationUnit_dart_exception() {
     TestSource source = _addSourceWithException("/test.dart");
     try {
-      _context.computeResolvableCompilationUnit(source);
+      context.computeResolvableCompilationUnit(source);
       fail("Expected AnalysisException");
     } on AnalysisException {
       // Expected
     }
   }
 
   void fail_computeResolvableCompilationUnit_html_exception() {
-    Source source = _addSource("/lib.html", "<html></html>");
+    Source source = addSource("/lib.html", "<html></html>");
     try {
-      _context.computeResolvableCompilationUnit(source);
+      context.computeResolvableCompilationUnit(source);
       fail("Expected AnalysisException");
     } on AnalysisException {
       // Expected
     }
   }
 
   void fail_computeResolvableCompilationUnit_valid() {
-    Source source = _addSource("/lib.dart", "library lib;");
-    CompilationUnit parsedUnit = _context.parseCompilationUnit(source);
+    Source source = addSource("/lib.dart", "library lib;");
+    CompilationUnit parsedUnit = context.parseCompilationUnit(source);
     expect(parsedUnit, isNotNull);
     CompilationUnit resolvedUnit =
-        _context.computeResolvableCompilationUnit(source);
+        context.computeResolvableCompilationUnit(source);
     expect(resolvedUnit, isNotNull);
     expect(resolvedUnit, same(parsedUnit));
   }
 
   Future fail_computeResolvedCompilationUnitAsync_dispose() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
+    Source source = addSource("/lib.dart", "library lib;");
     // Complete all pending analysis tasks and flush the AST so that it won't
     // be available immediately.
     _performPendingAnalysisTasks();
     _flushAst(source);
     CancelableFuture<CompilationUnit> future =
-        _context.computeResolvedCompilationUnitAsync(source, source);
+        context.computeResolvedCompilationUnitAsync(source, source);
     bool completed = false;
     future.then((CompilationUnit unit) {
       fail('Future should have completed with error');
     }, onError: (error) {
       expect(error, new isInstanceOf<AnalysisNotScheduledError>());
       completed = true;
     });
     expect(completed, isFalse);
-    expect(_context.pendingFutureSources_forTesting, isNotEmpty);
+    expect(context.pendingFutureSources_forTesting, isNotEmpty);
     // Disposing of the context should cause all pending futures to complete
     // with AnalysisNotScheduled, so that no clients are left hanging.
-    _context.dispose();
-    expect(_context.pendingFutureSources_forTesting, isEmpty);
+    context.dispose();
+    expect(context.pendingFutureSources_forTesting, isEmpty);
     return pumpEventQueue().then((_) {
       expect(completed, isTrue);
-      expect(_context.pendingFutureSources_forTesting, isEmpty);
+      expect(context.pendingFutureSources_forTesting, isEmpty);
     });
   }
 
   Future fail_computeResolvedCompilationUnitAsync_unrelatedLibrary() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", "library lib;");
-    Source partSource = _addSource("/part.dart", "part of foo;");
+    Source librarySource = addSource("/lib.dart", "library lib;");
+    Source partSource = addSource("/part.dart", "part of foo;");
     bool completed = false;
-    _context
+    context
         .computeResolvedCompilationUnitAsync(partSource, librarySource)
         .then((_) {
       fail('Expected resolution to fail');
     }, onError: (e) {
       expect(e, new isInstanceOf<AnalysisNotScheduledError>());
       completed = true;
     });
     return pumpEventQueue().then((_) {
       expect(completed, isFalse);
       _performPendingAnalysisTasks();
     }).then((_) => pumpEventQueue()).then((_) {
       expect(completed, isTrue);
     });
   }
 
   void fail_extractContext() {
     fail("Implement this");
   }
 
-  void fail_getElement_constructor_named() {
-    Source source = _addSource("/lib.dart", r'''
+  void test_getElement_constructor_named() {
+    Source source = addSource("/lib.dart", r'''
 class A {
   A.named() {}
 }''');
     _analyzeAll_assertFinished();
-    LibraryElement library = _context.computeLibraryElement(source);
+    LibraryElement library = context.computeLibraryElement(source);
     ClassElement classA = _findClass(library.definingCompilationUnit, "A");
     ConstructorElement constructor = classA.constructors[0];
     ElementLocation location = constructor.location;
-    Element element = _context.getElement(location);
+    Element element = context.getElement(location);
     expect(element, same(constructor));
   }
 
-  void fail_getElement_constructor_unnamed() {
-    Source source = _addSource("/lib.dart", r'''
+  void test_getElement_constructor_unnamed() {
+    Source source = addSource("/lib.dart", r'''
 class A {
   A() {}
 }''');
     _analyzeAll_assertFinished();
-    LibraryElement library = _context.computeLibraryElement(source);
+    LibraryElement library = context.computeLibraryElement(source);
     ClassElement classA = _findClass(library.definingCompilationUnit, "A");
     ConstructorElement constructor = classA.constructors[0];
     ElementLocation location = constructor.location;
-    Element element = _context.getElement(location);
+    Element element = context.getElement(location);
     expect(element, same(constructor));
   }
 
-  void fail_getElement_enum() {
-    Source source = _addSource('/test.dart', 'enum MyEnum {A, B, C}');
+  void test_getElement_enum() {
+    Source source = addSource('/test.dart', 'enum MyEnum {A, B, C}');
     _analyzeAll_assertFinished();
-    LibraryElement library = _context.computeLibraryElement(source);
+    LibraryElement library = context.computeLibraryElement(source);
     ClassElement myEnum = library.definingCompilationUnit.getEnum('MyEnum');
     ElementLocation location = myEnum.location;
-    Element element = _context.getElement(location);
+    Element element = context.getElement(location);
     expect(element, same(myEnum));
   }
 
   void fail_getErrors_dart_none() {
-    Source source = _addSource("/lib.dart", "library lib;");
-    var errorInfo = _context.getErrors(source);
+    Source source = addSource("/lib.dart", "library lib;");
+    var errorInfo = context.getErrors(source);
     expect(errorInfo, isNotNull);
     List<AnalysisError> errors = errorInfo.errors;
     expect(errors, hasLength(0));
-    _context.computeErrors(source);
+    context.computeErrors(source);
     errors = errorInfo.errors;
     expect(errors, hasLength(0));
   }
 
   void fail_getErrors_dart_some() {
-    Source source = _addSource("/lib.dart", "library 'lib';");
-    var errorInfo = _context.getErrors(source);
+    Source source = addSource("/lib.dart", "library 'lib';");
+    var errorInfo = context.getErrors(source);
     expect(errorInfo, isNotNull);
     List<AnalysisError> errors = errorInfo.errors;
     expect(errors, hasLength(0));
-    _context.computeErrors(source);
+    context.computeErrors(source);
     errors = errorInfo.errors;
     expect(errors, hasLength(1));
   }
 
   void fail_getErrors_html_none() {
-    Source source = _addSource("/test.html", "<html></html>");
-    AnalysisErrorInfo errorInfo = _context.getErrors(source);
+    Source source = addSource("/test.html", "<html></html>");
+    AnalysisErrorInfo errorInfo = context.getErrors(source);
     expect(errorInfo, isNotNull);
     List<AnalysisError> errors = errorInfo.errors;
     expect(errors, hasLength(0));
-    _context.computeErrors(source);
+    context.computeErrors(source);
     errors = errorInfo.errors;
     expect(errors, hasLength(0));
   }
 
   void fail_getErrors_html_some() {
-    Source source = _addSource("/test.html", r'''
+    Source source = addSource("/test.html", r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 </head></html>''');
-    AnalysisErrorInfo errorInfo = _context.getErrors(source);
+    AnalysisErrorInfo errorInfo = context.getErrors(source);
     expect(errorInfo, isNotNull);
     List<AnalysisError> errors = errorInfo.errors;
     expect(errors, hasLength(0));
-    _context.computeErrors(source);
+    context.computeErrors(source);
     errors = errorInfo.errors;
     expect(errors, hasLength(1));
   }
 
   void fail_getHtmlElement_html() {
-    Source source = _addSource("/test.html", "<html></html>");
-    HtmlElement element = _context.getHtmlElement(source);
+    Source source = addSource("/test.html", "<html></html>");
+    HtmlElement element = context.getHtmlElement(source);
     expect(element, isNull);
-    _context.computeHtmlElement(source);
-    element = _context.getHtmlElement(source);
+    context.computeHtmlElement(source);
+    element = context.getHtmlElement(source);
     expect(element, isNotNull);
   }
 
   void fail_getHtmlFilesReferencing_library() {
-    Source htmlSource = _addSource("/test.html", r'''
+    Source htmlSource = addSource("/test.html", r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
-    Source librarySource = _addSource("/test.dart", "library lib;");
-    List<Source> result = _context.getHtmlFilesReferencing(librarySource);
+    Source librarySource = addSource("/test.dart", "library lib;");
+    List<Source> result = context.getHtmlFilesReferencing(librarySource);
     expect(result, hasLength(0));
-    _context.parseHtmlUnit(htmlSource);
-    result = _context.getHtmlFilesReferencing(librarySource);
+    context.parseHtmlUnit(htmlSource);
+    result = context.getHtmlFilesReferencing(librarySource);
     expect(result, hasLength(1));
     expect(result[0], htmlSource);
   }
 
   void fail_getHtmlFilesReferencing_part() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source htmlSource = _addSource("/test.html", r'''
+    Source htmlSource = addSource("/test.html", r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
     Source librarySource =
-        _addSource("/test.dart", "library lib; part 'part.dart';");
-    Source partSource = _addSource("/part.dart", "part of lib;");
-    _context.computeLibraryElement(librarySource);
-    List<Source> result = _context.getHtmlFilesReferencing(partSource);
+        addSource("/test.dart", "library lib; part 'part.dart';");
+    Source partSource = addSource("/part.dart", "part of lib;");
+    context.computeLibraryElement(librarySource);
+    List<Source> result = context.getHtmlFilesReferencing(partSource);
     expect(result, hasLength(0));
-    _context.parseHtmlUnit(htmlSource);
-    result = _context.getHtmlFilesReferencing(partSource);
+    context.parseHtmlUnit(htmlSource);
+    result = context.getHtmlFilesReferencing(partSource);
     expect(result, hasLength(1));
     expect(result[0], htmlSource);
   }
 
   void fail_getHtmlSources() {
-    List<Source> sources = _context.htmlSources;
+    List<Source> sources = context.htmlSources;
     expect(sources, hasLength(0));
-    Source source = _addSource("/test.html", "");
-    _context.computeKindOf(source);
-    sources = _context.htmlSources;
+    Source source = addSource("/test.html", "");
+    context.computeKindOf(source);
+    sources = context.htmlSources;
     expect(sources, hasLength(1));
     expect(sources[0], source);
   }
 
   void fail_getLibrariesReferencedFromHtml() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source htmlSource = _addSource("/test.html", r'''
+    Source htmlSource = addSource("/test.html", r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
-    Source librarySource = _addSource("/test.dart", "library lib;");
-    _context.computeLibraryElement(librarySource);
-    _context.parseHtmlUnit(htmlSource);
-    List<Source> result = _context.getLibrariesReferencedFromHtml(htmlSource);
+    Source librarySource = addSource("/test.dart", "library lib;");
+    context.computeLibraryElement(librarySource);
+    context.parseHtmlUnit(htmlSource);
+    List<Source> result = context.getLibrariesReferencedFromHtml(htmlSource);
     expect(result, hasLength(1));
     expect(result[0], librarySource);
   }
 
   void fail_getResolvedCompilationUnit_library() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library libb;");
-    LibraryElement library = _context.computeLibraryElement(source);
-    expect(_context.getResolvedCompilationUnit(source, library), isNotNull);
-    _context.setContents(source, "library lib;");
-    expect(_context.getResolvedCompilationUnit(source, library), isNull);
+    Source source = addSource("/lib.dart", "library libb;");
+    LibraryElement library = context.computeLibraryElement(source);
+    expect(context.getResolvedCompilationUnit(source, library), isNotNull);
+    context.setContents(source, "library lib;");
+    expect(context.getResolvedCompilationUnit(source, library), isNull);
   }
 
   void fail_getResolvedHtmlUnit() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.html", "<html></html>");
-    expect(_context.getResolvedHtmlUnit(source), isNull);
-    _context.resolveHtmlUnit(source);
-    expect(_context.getResolvedHtmlUnit(source), isNotNull);
+    Source source = addSource("/test.html", "<html></html>");
+    expect(context.getResolvedHtmlUnit(source), isNull);
+    context.resolveHtmlUnit(source);
+    expect(context.getResolvedHtmlUnit(source), isNotNull);
   }
 
   void fail_mergeContext() {
     fail("Implement this");
   }
 
   void fail_parseHtmlUnit_noErrors() {
-    Source source = _addSource("/lib.html", "<html></html>");
-    ht.HtmlUnit unit = _context.parseHtmlUnit(source);
+    Source source = addSource("/lib.html", "<html></html>");
+    ht.HtmlUnit unit = context.parseHtmlUnit(source);
     expect(unit, isNotNull);
   }
 
   void fail_parseHtmlUnit_resolveDirectives() {
-    Source libSource = _addSource("/lib.dart", r'''
+    Source libSource = addSource("/lib.dart", r'''
 library lib;
 class ClassA {}''');
-    Source source = _addSource("/lib.html", r'''
+    Source source = addSource("/lib.html", r'''
 <html>
 <head>
   <script type='application/dart'>
     import 'lib.dart';
     ClassA v = null;
   </script>
 </head>
 <body>
 </body>
 </html>''');
-    ht.HtmlUnit unit = _context.parseHtmlUnit(source);
+    ht.HtmlUnit unit = context.parseHtmlUnit(source);
     expect(unit, isNotNull);
     // import directive should be resolved
     ht.XmlTagNode htmlNode = unit.tagNodes[0];
     ht.XmlTagNode headNode = htmlNode.tagNodes[0];
     ht.HtmlScriptTagNode scriptNode = headNode.tagNodes[0];
     CompilationUnit script = scriptNode.script;
     ImportDirective importNode = script.directives[0] as ImportDirective;
     expect(importNode.uriContent, isNotNull);
     expect(importNode.source, libSource);
   }
 
   void fail_performAnalysisTask_addPart() {
-    Source libSource = _addSource("/lib.dart", r'''
+    Source libSource = addSource("/lib.dart", r'''
 library lib;
 part 'part.dart';''');
     // run all tasks without part
     _analyzeAll_assertFinished();
     // add part and run all tasks
-    Source partSource = _addSource("/part.dart", r'''
+    Source partSource = addSource("/part.dart", r'''
 part of lib;
 ''');
     _analyzeAll_assertFinished();
     // "libSource" should be here
-    List<Source> librariesWithPart =
-        _context.getLibrariesContaining(partSource);
+    List<Source> librariesWithPart = context.getLibrariesContaining(partSource);
     expect(librariesWithPart, unorderedEquals([libSource]));
   }
 
   void fail_performAnalysisTask_changeLibraryContents() {
     Source libSource =
-        _addSource("/test.dart", "library lib; part 'test-part.dart';");
-    Source partSource = _addSource("/test-part.dart", "part of lib;");
+        addSource("/test.dart", "library lib; part 'test-part.dart';");
+    Source partSource = addSource("/test-part.dart", "part of lib;");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 1");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 1");
     // update and analyze #1
-    _context.setContents(libSource, "library lib;");
-    expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull,
+    context.setContents(libSource, "library lib;");
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNull,
         reason: "library changed 2");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part changed 2");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 2");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part resolved 2");
     // update and analyze #2
-    _context.setContents(libSource, "library lib; part 'test-part.dart';");
-    expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull,
+    context.setContents(libSource, "library lib; part 'test-part.dart';");
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNull,
         reason: "library changed 3");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part changed 3");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 2");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 3");
   }
 
   void fail_performAnalysisTask_changeLibraryThenPartContents() {
     Source libSource =
-        _addSource("/test.dart", "library lib; part 'test-part.dart';");
-    Source partSource = _addSource("/test-part.dart", "part of lib;");
+        addSource("/test.dart", "library lib; part 'test-part.dart';");
+    Source partSource = addSource("/test-part.dart", "part of lib;");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 1");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 1");
     // update and analyze #1
-    _context.setContents(libSource, "library lib;");
-    expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull,
+    context.setContents(libSource, "library lib;");
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNull,
         reason: "library changed 2");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part changed 2");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 2");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part resolved 2");
     // update and analyze #2
-    _context.setContents(partSource, "part of lib; // 1");
+    context.setContents(partSource, "part of lib; // 1");
     // Assert that changing the part's content does not effect the library
     // now that it is no longer part of that library
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library changed 3");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part changed 3");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 3");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part resolved 3");
   }
 
   void fail_performAnalysisTask_changePartContents_makeItAPart() {
-    Source libSource = _addSource("/lib.dart", r'''
+    Source libSource = addSource("/lib.dart", r'''
 library lib;
 part 'part.dart';
 void f(x) {}''');
-    Source partSource = _addSource("/part.dart", "void g() { f(null); }");
+    Source partSource = addSource("/part.dart", "void g() { f(null); }");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 1");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 1");
     // update and analyze
-    _context.setContents(partSource, r'''
+    context.setContents(partSource, r'''
 part of lib;
 void g() { f(null); }''');
-    expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNull,
         reason: "library changed 2");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part changed 2");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 2");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 2");
-    expect(_context.getErrors(libSource).errors, hasLength(0));
-    expect(_context.getErrors(partSource).errors, hasLength(0));
+    expect(context.getErrors(libSource).errors, hasLength(0));
+    expect(context.getErrors(partSource).errors, hasLength(0));
   }
 
   /**
    * https://code.google.com/p/dart/issues/detail?id=12424
    */
   void fail_performAnalysisTask_changePartContents_makeItNotPart() {
-    Source libSource = _addSource("/lib.dart", r'''
+    Source libSource = addSource("/lib.dart", r'''
 library lib;
 part 'part.dart';
 void f(x) {}''');
-    Source partSource = _addSource("/part.dart", r'''
+    Source partSource = addSource("/part.dart", r'''
 part of lib;
 void g() { f(null); }''');
     _analyzeAll_assertFinished();
-    expect(_context.getErrors(libSource).errors, hasLength(0));
-    expect(_context.getErrors(partSource).errors, hasLength(0));
+    expect(context.getErrors(libSource).errors, hasLength(0));
+    expect(context.getErrors(partSource).errors, hasLength(0));
     // Remove 'part' directive, which should make "f(null)" an error.
-    _context.setContents(partSource, r'''
+    context.setContents(partSource, r'''
 //part of lib;
 void g() { f(null); }''');
     _analyzeAll_assertFinished();
-    expect(_context.getErrors(libSource).errors.length != 0, isTrue);
+    expect(context.getErrors(libSource).errors.length != 0, isTrue);
   }
 
   void fail_performAnalysisTask_changePartContents_noSemanticChanges() {
     Source libSource =
-        _addSource("/test.dart", "library lib; part 'test-part.dart';");
-    Source partSource = _addSource("/test-part.dart", "part of lib;");
+        addSource("/test.dart", "library lib; part 'test-part.dart';");
+    Source partSource = addSource("/test-part.dart", "part of lib;");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 1");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 1");
     // update and analyze #1
-    _context.setContents(partSource, "part of lib; // 1");
-    expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull,
+    context.setContents(partSource, "part of lib; // 1");
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNull,
         reason: "library changed 2");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part changed 2");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 2");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 2");
     // update and analyze #2
-    _context.setContents(partSource, "part of lib; // 12");
-    expect(_context.getResolvedCompilationUnit2(libSource, libSource), isNull,
+    context.setContents(partSource, "part of lib; // 12");
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNull,
         reason: "library changed 3");
-    expect(_context.getResolvedCompilationUnit2(partSource, libSource), isNull,
+    expect(context.getResolvedCompilationUnit2(partSource, libSource), isNull,
         reason: "part changed 3");
     _analyzeAll_assertFinished();
-    expect(
-        _context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
+    expect(context.getResolvedCompilationUnit2(libSource, libSource), isNotNull,
         reason: "library resolved 3");
     expect(
-        _context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
+        context.getResolvedCompilationUnit2(partSource, libSource), isNotNull,
         reason: "part resolved 3");
   }
 
   void fail_performAnalysisTask_getContentException_dart() {
     // add source that throw an exception on "get content"
     Source source = new _Source_getContent_throwException('test.dart');
     {
       ChangeSet changeSet = new ChangeSet();
       changeSet.addedSource(source);
-      _context.applyChanges(changeSet);
+      context.applyChanges(changeSet);
     }
     // prepare errors
     _analyzeAll_assertFinished();
-    List<AnalysisError> errors = _context.getErrors(source).errors;
+    List<AnalysisError> errors = context.getErrors(source).errors;
     // validate errors
     expect(errors, hasLength(1));
     AnalysisError error = errors[0];
     expect(error.source, same(source));
     expect(error.errorCode, ScannerErrorCode.UNABLE_GET_CONTENT);
   }
 
   void fail_performAnalysisTask_getContentException_html() {
     // add source that throw an exception on "get content"
     Source source = new _Source_getContent_throwException('test.html');
     {
       ChangeSet changeSet = new ChangeSet();
       changeSet.addedSource(source);
-      _context.applyChanges(changeSet);
+      context.applyChanges(changeSet);
     }
     // prepare errors
     _analyzeAll_assertFinished();
-    List<AnalysisError> errors = _context.getErrors(source).errors;
+    List<AnalysisError> errors = context.getErrors(source).errors;
     // validate errors
     expect(errors, hasLength(1));
     AnalysisError error = errors[0];
     expect(error.source, same(source));
     expect(error.errorCode, ScannerErrorCode.UNABLE_GET_CONTENT);
   }
 
   void fail_performAnalysisTask_importedLibraryAdd() {
     Source libASource =
-        _addSource("/libA.dart", "library libA; import 'libB.dart';");
+        addSource("/libA.dart", "library libA; import 'libB.dart';");
     _analyzeAll_assertFinished();
     expect(
-        _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
+        context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
         reason: "libA resolved 1");
-    expect(_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)),
+    expect(_hasAnalysisErrorWithErrorSeverity(context.getErrors(libASource)),
         isTrue, reason: "libA has an error");
     // add libB.dart and analyze
-    Source libBSource = _addSource("/libB.dart", "library libB;");
+    Source libBSource = addSource("/libB.dart", "library libB;");
     _analyzeAll_assertFinished();
     expect(
-        _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
+        context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
         reason: "libA resolved 2");
     expect(
-        _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
+        context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
         reason: "libB resolved 2");
-    expect(!_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)),
+    expect(!_hasAnalysisErrorWithErrorSeverity(context.getErrors(libASource)),
         isTrue, reason: "libA doesn't have errors");
   }
 
   void fail_performAnalysisTask_importedLibraryAdd_html() {
-    Source htmlSource = _addSource("/page.html", r'''
+    Source htmlSource = addSource("/page.html", r'''
 <html><body><script type="application/dart">
   import '/libB.dart';
   main() {print('hello dart');}
 </script></body></html>''');
     _analyzeAll_assertFinished();
-    expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull,
+    expect(context.getResolvedHtmlUnit(htmlSource), isNotNull,
         reason: "htmlUnit resolved 1");
-    expect(_hasAnalysisErrorWithErrorSeverity(_context.getErrors(htmlSource)),
+    expect(_hasAnalysisErrorWithErrorSeverity(context.getErrors(htmlSource)),
         isTrue, reason: "htmlSource has an error");
     // add libB.dart and analyze
-    Source libBSource = _addSource("/libB.dart", "library libB;");
+    Source libBSource = addSource("/libB.dart", "library libB;");
     _analyzeAll_assertFinished();
-    expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull,
+    expect(context.getResolvedHtmlUnit(htmlSource), isNotNull,
         reason: "htmlUnit resolved 1");
     expect(
-        _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
+        context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
         reason: "libB resolved 2");
     // TODO (danrubel) commented out to fix red bots
 //    AnalysisErrorInfo errors = _context.getErrors(htmlSource);
 //    expect(
 //        !_hasAnalysisErrorWithErrorSeverity(errors),
 //        isTrue,
 //        reason: "htmlSource doesn't have errors");
   }
 
   void fail_performAnalysisTask_importedLibraryDelete() {
     Source libASource =
-        _addSource("/libA.dart", "library libA; import 'libB.dart';");
-    Source libBSource = _addSource("/libB.dart", "library libB;");
+        addSource("/libA.dart", "library libA; import 'libB.dart';");
+    Source libBSource = addSource("/libB.dart", "library libB;");
     _analyzeAll_assertFinished();
     expect(
-        _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
+        context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
         reason: "libA resolved 1");
     expect(
-        _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
+        context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
         reason: "libB resolved 1");
-    expect(!_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)),
+    expect(!_hasAnalysisErrorWithErrorSeverity(context.getErrors(libASource)),
         isTrue, reason: "libA doesn't have errors");
     // remove libB.dart content and analyze
-    _context.setContents(libBSource, null);
+    context.setContents(libBSource, null);
     _analyzeAll_assertFinished();
     expect(
-        _context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
+        context.getResolvedCompilationUnit2(libASource, libASource), isNotNull,
         reason: "libA resolved 2");
-    expect(_hasAnalysisErrorWithErrorSeverity(_context.getErrors(libASource)),
+    expect(_hasAnalysisErrorWithErrorSeverity(context.getErrors(libASource)),
         isTrue, reason: "libA has an error");
   }
 
   void fail_performAnalysisTask_importedLibraryDelete_html() {
     // NOTE: This was failing before converting to the new task model.
-    Source htmlSource = _addSource("/page.html", r'''
+    Source htmlSource = addSource("/page.html", r'''
 <html><body><script type="application/dart">
   import 'libB.dart';
   main() {print('hello dart');}
 </script></body></html>''');
-    Source libBSource = _addSource("/libB.dart", "library libB;");
+    Source libBSource = addSource("/libB.dart", "library libB;");
     _analyzeAll_assertFinished();
-    expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull,
+    expect(context.getResolvedHtmlUnit(htmlSource), isNotNull,
         reason: "htmlUnit resolved 1");
     expect(
-        _context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
+        context.getResolvedCompilationUnit2(libBSource, libBSource), isNotNull,
         reason: "libB resolved 1");
-    expect(!_hasAnalysisErrorWithErrorSeverity(_context.getErrors(htmlSource)),
+    expect(!_hasAnalysisErrorWithErrorSeverity(context.getErrors(htmlSource)),
         isTrue, reason: "htmlSource doesn't have errors");
     // remove libB.dart content and analyze
-    _context.setContents(libBSource, null);
+    context.setContents(libBSource, null);
     _analyzeAll_assertFinished();
-    expect(_context.getResolvedHtmlUnit(htmlSource), isNotNull,
+    expect(context.getResolvedHtmlUnit(htmlSource), isNotNull,
         reason: "htmlUnit resolved 1");
-    AnalysisErrorInfo errors = _context.getErrors(htmlSource);
+    AnalysisErrorInfo errors = context.getErrors(htmlSource);
     expect(_hasAnalysisErrorWithErrorSeverity(errors), isTrue,
         reason: "htmlSource has an error");
   }
 
   void fail_performAnalysisTask_IOException() {
     TestSource source = _addSourceWithException2("/test.dart", "library test;");
-    int oldTimestamp = _context.getModificationStamp(source);
+    int oldTimestamp = context.getModificationStamp(source);
     source.generateExceptionOnRead = false;
     _analyzeAll_assertFinished();
     expect(source.readCount, 1);
     source.generateExceptionOnRead = true;
     do {
       _changeSource(source, "");
       // Ensure that the timestamp differs,
       // so that analysis engine notices the change
-    } while (oldTimestamp == _context.getModificationStamp(source));
+    } while (oldTimestamp == context.getModificationStamp(source));
     _analyzeAll_assertFinished();
     expect(source.readCount, 2);
   }
 
   void fail_performAnalysisTask_missingPart() {
     Source source =
-        _addSource("/test.dart", "library lib; part 'no-such-file.dart';");
+        addSource("/test.dart", "library lib; part 'no-such-file.dart';");
     _analyzeAll_assertFinished();
-    expect(_context.getLibraryElement(source), isNotNull,
+    expect(context.getLibraryElement(source), isNotNull,
         reason: "performAnalysisTask failed to compute an element model");
   }
 
   void fail_recordLibraryElements() {
     fail("Implement this");
   }
 
   void fail_resolveCompilationUnit_import_relative() {
-    _context = contextWithCore();
     Source sourceA =
-        _addSource("/libA.dart", "library libA; import 'libB.dart'; class A{}");
-    _addSource("/libB.dart", "library libB; class B{}");
+        addSource("/libA.dart", "library libA; import 'libB.dart'; class A{}");
+    addSource("/libB.dart", "library libB; class B{}");
     CompilationUnit compilationUnit =
-        _context.resolveCompilationUnit2(sourceA, sourceA);
+        context.resolveCompilationUnit2(sourceA, sourceA);
     expect(compilationUnit, isNotNull);
     LibraryElement library = compilationUnit.element.library;
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core", "libB"]);
     List<LibraryElement> visibleLibraries = library.visibleLibraries;
     assertNamedElements(visibleLibraries, ["dart.core", "libA", "libB"]);
   }
 
   void fail_resolveCompilationUnit_import_relative_cyclic() {
-    _context = contextWithCore();
     Source sourceA =
-        _addSource("/libA.dart", "library libA; import 'libB.dart'; class A{}");
-    _addSource("/libB.dart", "library libB; import 'libA.dart'; class B{}");
+        addSource("/libA.dart", "library libA; import 'libB.dart'; class A{}");
+    addSource("/libB.dart", "library libB; import 'libA.dart'; class B{}");
     CompilationUnit compilationUnit =
-        _context.resolveCompilationUnit2(sourceA, sourceA);
+        context.resolveCompilationUnit2(sourceA, sourceA);
     expect(compilationUnit, isNotNull);
     LibraryElement library = compilationUnit.element.library;
     List<LibraryElement> importedLibraries = library.importedLibraries;
     assertNamedElements(importedLibraries, ["dart.core", "libB"]);
     List<LibraryElement> visibleLibraries = library.visibleLibraries;
     assertNamedElements(visibleLibraries, ["dart.core", "libA", "libB"]);
   }
 
   void fail_resolveHtmlUnit() {
-    Source source = _addSource("/lib.html", "<html></html>");
-    ht.HtmlUnit unit = _context.resolveHtmlUnit(source);
+    Source source = addSource("/lib.html", "<html></html>");
+    ht.HtmlUnit unit = context.resolveHtmlUnit(source);
     expect(unit, isNotNull);
   }
 
   void fail_setAnalysisOptions_reduceAnalysisPriorityOrder() {
     AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
+        new AnalysisOptionsImpl.con1(context.analysisOptions);
     List<Source> sources = new List<Source>();
     for (int index = 0; index < options.cacheSize; index++) {
-      sources.add(_addSource("/lib.dart$index", ""));
+      sources.add(addSource("/lib.dart$index", ""));
     }
-    _context.analysisPriorityOrder = sources;
-    int oldPriorityOrderSize = _getPriorityOrder(_context).length;
+    context.analysisPriorityOrder = sources;
+    int oldPriorityOrderSize = _getPriorityOrder(context).length;
     options.cacheSize = options.cacheSize - 10;
-    _context.analysisOptions = options;
-    expect(oldPriorityOrderSize > _getPriorityOrder(_context).length, isTrue);
+    context.analysisOptions = options;
+    expect(oldPriorityOrderSize > _getPriorityOrder(context).length, isTrue);
   }
 
   void fail_setAnalysisPriorityOrder_lessThanCacheSize() {
-    AnalysisOptions options = _context.analysisOptions;
+    AnalysisOptions options = context.analysisOptions;
     List<Source> sources = new List<Source>();
     for (int index = 0; index < options.cacheSize; index++) {
-      sources.add(_addSource("/lib.dart$index", ""));
+      sources.add(addSource("/lib.dart$index", ""));
     }
-    _context.analysisPriorityOrder = sources;
-    expect(options.cacheSize > _getPriorityOrder(_context).length, isTrue);
+    context.analysisPriorityOrder = sources;
+    expect(options.cacheSize > _getPriorityOrder(context).length, isTrue);
   }
 
   Future fail_setChangedContents_libraryWithPart() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.incremental = true;
-    _context = new AnalysisContextForTests();
-    _context.analysisOptions = options;
+    context.analysisOptions = options;
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    _sourceFactory = _context.sourceFactory;
+    context.onSourcesChanged.listen(listener.onData);
     String oldCode = r'''
 library lib;
 part 'part.dart';
 int a = 0;''';
-    Source librarySource = _addSource("/lib.dart", oldCode);
+    Source librarySource = addSource("/lib.dart", oldCode);
     String partContents = r'''
 part of lib;
 int b = a;''';
-    Source partSource = _addSource("/part.dart", partContents);
-    LibraryElement element = _context.computeLibraryElement(librarySource);
+    Source partSource = addSource("/part.dart", partContents);
+    LibraryElement element = context.computeLibraryElement(librarySource);
     CompilationUnit unit =
-        _context.getResolvedCompilationUnit(librarySource, element);
+        context.getResolvedCompilationUnit(librarySource, element);
     expect(unit, isNotNull);
     int offset = oldCode.indexOf("int a") + 4;
     String newCode = r'''
 library lib;
 part 'part.dart';
 int ya = 0;''';
-    expect(_getIncrementalAnalysisCache(_context), isNull);
-    _context.setChangedContents(librarySource, newCode, offset, 0, 1);
-    expect(_context.getContents(librarySource).data, newCode);
+    expect(_getIncrementalAnalysisCache(context), isNull);
+    context.setChangedContents(librarySource, newCode, offset, 0, 1);
+    expect(context.getContents(librarySource).data, newCode);
     IncrementalAnalysisCache incrementalCache =
-        _getIncrementalAnalysisCache(_context);
+        _getIncrementalAnalysisCache(context);
     expect(incrementalCache.librarySource, librarySource);
     expect(incrementalCache.resolvedUnit, same(unit));
-    expect(_context.getResolvedCompilationUnit2(partSource, librarySource),
-        isNull);
+    expect(
+        context.getResolvedCompilationUnit2(partSource, librarySource), isNull);
     expect(incrementalCache.newContents, newCode);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [librarySource]);
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [partSource]);
       listener.assertEvent(changedSources: [librarySource]);
       listener.assertNoMoreEvents();
     });
   }
 
-  void fail_setContents_unchanged_consistentModificationTime() {
+  void test_setContents_unchanged_consistentModificationTime() {
     String contents = "// foo";
-    Source source = _addSource("/test.dart", contents);
+    Source source = addSource("/test.dart", contents);
     // do all, no tasks
     _analyzeAll_assertFinished();
     {
-      AnalysisResult result = _context.performAnalysisTask();
+      AnalysisResult result = context.performAnalysisTask();
       expect(result.changeNotices, isNull);
     }
     // set the same contents, still no tasks
-    _context.setContents(source, contents);
+    context.setContents(source, contents);
     {
-      AnalysisResult result = _context.performAnalysisTask();
+      AnalysisResult result = context.performAnalysisTask();
       expect(result.changeNotices, isNull);
     }
   }
 
   void fail_unreadableSource() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source test1 = _addSource("/test1.dart", r'''
+    Source test1 = addSource("/test1.dart", r'''
 import 'test2.dart';
 library test1;''');
-    Source test2 = _addSource("/test2.dart", r'''
+    Source test2 = addSource("/test2.dart", r'''
 import 'test1.dart';
 import 'test3.dart';
 library test2;''');
     Source test3 = _addSourceWithException("/test3.dart");
     _analyzeAll_assertFinished();
     // test1 and test2 should have been successfully analyzed
     // despite the fact that test3 couldn't be read.
-    expect(_context.computeLibraryElement(test1), isNotNull);
-    expect(_context.computeLibraryElement(test2), isNotNull);
-    expect(_context.computeLibraryElement(test3), isNull);
-  }
-
-  @override
-  void setUp() {
-    EnginePlugin enginePlugin = AnalysisEngine.instance.enginePlugin;
-    if (enginePlugin.taskExtensionPoint == null) {
-      ExtensionManager manager = new ExtensionManager();
-      manager.processPlugins([enginePlugin]);
-    }
-
-    _context = new AnalysisContextImpl();
-    _sourceFactory = new SourceFactory([
-      new DartUriResolver(DirectoryBasedDartSdk.defaultSdk),
-      new FileUriResolver()
-    ]);
-    _context.sourceFactory = _sourceFactory;
-    AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
-    options.cacheSize = 256;
-    _context.analysisOptions = options;
-  }
-
-  void test_applyChanges_change_flush_element() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", r'''
-library lib;
-int a = 0;''');
-    expect(_context.computeLibraryElement(librarySource), isNotNull);
-    _context.setContents(librarySource, r'''
-library lib;
-int aa = 0;''');
-    expect(_context.getLibraryElement(librarySource), isNull);
+    expect(context.computeLibraryElement(test1), isNotNull);
+    expect(context.computeLibraryElement(test2), isNotNull);
+    expect(context.computeLibraryElement(test3), isNull);
   }
 
   @override
   void tearDown() {
-    _context = null;
-    _sourceFactory = null;
+    context = null;
+    sourceFactory = null;
     super.tearDown();
   }
 
   Future test_applyChanges_add() {
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    expect(_context.sourcesNeedingProcessing, isEmpty);
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    context.onSourcesChanged.listen(listener.onData);
+    expect(context.sourcesNeedingProcessing, isEmpty);
+    Source source = newSource('/test.dart');
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
-    _context.applyChanges(changeSet);
-    expect(_context.sourcesNeedingProcessing, contains(source));
+    context.applyChanges(changeSet);
+    expect(context.sourcesNeedingProcessing, contains(source));
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertNoMoreEvents();
     });
   }
 
   Future test_applyChanges_change() {
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    expect(_context.sourcesNeedingProcessing, isEmpty);
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    context.onSourcesChanged.listen(listener.onData);
+    expect(context.sourcesNeedingProcessing, isEmpty);
+    Source source = newSource('/test.dart');
     ChangeSet changeSet1 = new ChangeSet();
     changeSet1.addedSource(source);
-    _context.applyChanges(changeSet1);
-    expect(_context.sourcesNeedingProcessing, contains(source));
-    Source source2 =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    context.applyChanges(changeSet1);
+    expect(context.sourcesNeedingProcessing, contains(source));
+    Source source2 = newSource('/test2.dart');
     ChangeSet changeSet2 = new ChangeSet();
     changeSet2.addedSource(source2);
     changeSet2.changedSource(source);
-    _context.applyChanges(changeSet2);
+    context.applyChanges(changeSet2);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(wereSourcesAdded: true, changedSources: [source]);
       listener.assertNoMoreEvents();
     });
   }
 
   Future test_applyChanges_change_content() {
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    expect(_context.sourcesNeedingProcessing, isEmpty);
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    context.onSourcesChanged.listen(listener.onData);
+    expect(context.sourcesNeedingProcessing, isEmpty);
+    Source source = newSource('/test.dart');
     ChangeSet changeSet1 = new ChangeSet();
     changeSet1.addedSource(source);
-    _context.applyChanges(changeSet1);
-    expect(_context.sourcesNeedingProcessing, contains(source));
-    Source source2 =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    context.applyChanges(changeSet1);
+    expect(context.sourcesNeedingProcessing, contains(source));
+    Source source2 = newSource('/test2.dart');
     ChangeSet changeSet2 = new ChangeSet();
     changeSet2.addedSource(source2);
     changeSet2.changedContent(source, 'library test;');
-    _context.applyChanges(changeSet2);
+    context.applyChanges(changeSet2);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(wereSourcesAdded: true, changedSources: [source]);
       listener.assertNoMoreEvents();
     });
   }
 
+  void test_applyChanges_change_flush_element() {
+    Source librarySource = addSource("/lib.dart", r'''
+library lib;
+int a = 0;''');
+    expect(context.computeLibraryElement(librarySource), isNotNull);
+    context.setContents(librarySource, r'''
+library lib;
+int aa = 0;''');
+    expect(context.getLibraryElement(librarySource), isNull);
+  }
+
   Future test_applyChanges_change_multiple() {
-    _context = contextWithCore();
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    _sourceFactory = _context.sourceFactory;
+    context.onSourcesChanged.listen(listener.onData);
     String libraryContents1 = r'''
 library lib;
 part 'part.dart';
 int a = 0;''';
-    Source librarySource = _addSource("/lib.dart", libraryContents1);
+    Source librarySource = addSource("/lib.dart", libraryContents1);
     String partContents1 = r'''
 part of lib;
 int b = a;''';
-    Source partSource = _addSource("/part.dart", partContents1);
-    _context.computeLibraryElement(librarySource);
+    Source partSource = addSource("/part.dart", partContents1);
+    context.computeLibraryElement(librarySource);
     String libraryContents2 = r'''
 library lib;
 part 'part.dart';
 int aa = 0;''';
-    _context.setContents(librarySource, libraryContents2);
+    context.setContents(librarySource, libraryContents2);
     String partContents2 = r'''
 part of lib;
 int b = aa;''';
-    _context.setContents(partSource, partContents2);
-    _context.computeLibraryElement(librarySource);
+    context.setContents(partSource, partContents2);
+    context.computeLibraryElement(librarySource);
     CompilationUnit libraryUnit =
-        _context.resolveCompilationUnit2(librarySource, librarySource);
+        context.resolveCompilationUnit2(librarySource, librarySource);
     expect(libraryUnit, isNotNull);
     CompilationUnit partUnit =
-        _context.resolveCompilationUnit2(partSource, librarySource);
+        context.resolveCompilationUnit2(partSource, librarySource);
     expect(partUnit, isNotNull);
     TopLevelVariableDeclaration declaration =
         libraryUnit.declarations[0] as TopLevelVariableDeclaration;
     Element declarationElement = declaration.variables.variables[0].element;
     TopLevelVariableDeclaration use =
         partUnit.declarations[0] as TopLevelVariableDeclaration;
     Element useElement = (use.variables.variables[
         0].initializer as SimpleIdentifier).staticElement;
     expect((useElement as PropertyAccessorElement).variable,
         same(declarationElement));
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [librarySource]);
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [partSource]);
       listener.assertEvent(changedSources: [librarySource]);
       listener.assertEvent(changedSources: [partSource]);
       listener.assertNoMoreEvents();
     });
   }
 
   Future test_applyChanges_change_range() {
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    expect(_context.sourcesNeedingProcessing, isEmpty);
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    context.onSourcesChanged.listen(listener.onData);
+    expect(context.sourcesNeedingProcessing, isEmpty);
+    Source source = newSource('/test.dart');
     ChangeSet changeSet1 = new ChangeSet();
     changeSet1.addedSource(source);
-    _context.applyChanges(changeSet1);
-    expect(_context.sourcesNeedingProcessing, contains(source));
-    Source source2 =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test2.dart"));
+    context.applyChanges(changeSet1);
+    expect(context.sourcesNeedingProcessing, contains(source));
+    Source source2 = newSource('/test2.dart');
     ChangeSet changeSet2 = new ChangeSet();
     changeSet2.addedSource(source2);
     changeSet2.changedRange(source, 'library test;', 0, 0, 13);
-    _context.applyChanges(changeSet2);
+    context.applyChanges(changeSet2);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(wereSourcesAdded: true, changedSources: [source]);
       listener.assertNoMoreEvents();
     });
   }
 
   void test_computeDocumentationComment_block() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
     String comment = "/** Comment */";
-    Source source = _addSource("/test.dart", """
+    Source source = addSource("/test.dart", """
 $comment
 class A {}""");
-    LibraryElement libraryElement = _context.computeLibraryElement(source);
+    LibraryElement libraryElement = context.computeLibraryElement(source);
     expect(libraryElement, isNotNull);
     ClassElement classElement = libraryElement.definingCompilationUnit.types[0];
     expect(libraryElement, isNotNull);
-    expect(_context.computeDocumentationComment(classElement), comment);
+    expect(context.computeDocumentationComment(classElement), comment);
   }
 
   void test_computeDocumentationComment_none() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", "class A {}");
-    LibraryElement libraryElement = _context.computeLibraryElement(source);
+    Source source = addSource("/test.dart", "class A {}");
+    LibraryElement libraryElement = context.computeLibraryElement(source);
     expect(libraryElement, isNotNull);
     ClassElement classElement = libraryElement.definingCompilationUnit.types[0];
     expect(libraryElement, isNotNull);
-    expect(_context.computeDocumentationComment(classElement), isNull);
+    expect(context.computeDocumentationComment(classElement), isNull);
   }
 
   void test_computeDocumentationComment_null() {
-    expect(_context.computeDocumentationComment(null), isNull);
+    expect(context.computeDocumentationComment(null), isNull);
   }
 
   void test_computeDocumentationComment_singleLine_multiple_EOL_n() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
     String comment = "/// line 1\n/// line 2\n/// line 3\n";
-    Source source = _addSource("/test.dart", "${comment}class A {}");
-    LibraryElement libraryElement = _context.computeLibraryElement(source);
+    Source source = addSource("/test.dart", "${comment}class A {}");
+    LibraryElement libraryElement = context.computeLibraryElement(source);
     expect(libraryElement, isNotNull);
     ClassElement classElement = libraryElement.definingCompilationUnit.types[0];
     expect(libraryElement, isNotNull);
-    String actual = _context.computeDocumentationComment(classElement);
+    String actual = context.computeDocumentationComment(classElement);
     expect(actual, "/// line 1\n/// line 2\n/// line 3");
   }
 
   void test_computeDocumentationComment_singleLine_multiple_EOL_rn() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
     String comment = "/// line 1\r\n/// line 2\r\n/// line 3\r\n";
-    Source source = _addSource("/test.dart", "${comment}class A {}");
-    LibraryElement libraryElement = _context.computeLibraryElement(source);
+    Source source = addSource("/test.dart", "${comment}class A {}");
+    LibraryElement libraryElement = context.computeLibraryElement(source);
     expect(libraryElement, isNotNull);
     ClassElement classElement = libraryElement.definingCompilationUnit.types[0];
     expect(libraryElement, isNotNull);
-    String actual = _context.computeDocumentationComment(classElement);
+    String actual = context.computeDocumentationComment(classElement);
     expect(actual, "/// line 1\n/// line 2\n/// line 3");
   }
 
   void test_computeExportedLibraries_none() {
-    Source source = _addSource("/test.dart", "library test;");
-    expect(_context.computeExportedLibraries(source), hasLength(0));
+    Source source = addSource("/test.dart", "library test;");
+    expect(context.computeExportedLibraries(source), hasLength(0));
   }
 
   void test_computeExportedLibraries_some() {
     //    addSource("/lib1.dart", "library lib1;");
     //    addSource("/lib2.dart", "library lib2;");
-    Source source = _addSource(
+    Source source = addSource(
         "/test.dart", "library test; export 'lib1.dart'; export 'lib2.dart';");
-    expect(_context.computeExportedLibraries(source), hasLength(2));
+    expect(context.computeExportedLibraries(source), hasLength(2));
   }
 
   void test_computeHtmlElement_nonHtml() {
-    Source source = _addSource("/test.dart", "library test;");
-    expect(_context.computeHtmlElement(source), isNull);
+    Source source = addSource("/test.dart", "library test;");
+    expect(context.computeHtmlElement(source), isNull);
   }
 
   void test_computeKindOf_html() {
-    Source source = _addSource("/test.html", "");
-    expect(_context.computeKindOf(source), same(SourceKind.HTML));
+    Source source = addSource("/test.html", "");
+    expect(context.computeKindOf(source), same(SourceKind.HTML));
   }
 
   void test_computeKindOf_library() {
-    Source source = _addSource("/test.dart", "library lib;");
-    expect(_context.computeKindOf(source), same(SourceKind.LIBRARY));
+    Source source = addSource("/test.dart", "library lib;");
+    expect(context.computeKindOf(source), same(SourceKind.LIBRARY));
   }
 
   void test_computeKindOf_libraryAndPart() {
-    Source source = _addSource("/test.dart", "library lib; part of lib;");
-    expect(_context.computeKindOf(source), same(SourceKind.LIBRARY));
+    Source source = addSource("/test.dart", "library lib; part of lib;");
+    expect(context.computeKindOf(source), same(SourceKind.LIBRARY));
   }
 
   void test_computeKindOf_part() {
-    Source source = _addSource("/test.dart", "part of lib;");
-    expect(_context.computeKindOf(source), same(SourceKind.PART));
+    Source source = addSource("/test.dart", "part of lib;");
+    expect(context.computeKindOf(source), same(SourceKind.PART));
   }
 
   void test_computeLibraryElement() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", "library lib;");
-    LibraryElement element = _context.computeLibraryElement(source);
+    Source source = addSource("/test.dart", "library lib;");
+    LibraryElement element = context.computeLibraryElement(source);
     expect(element, isNotNull);
   }
 
   void test_computeLineInfo_dart() {
-    Source source = _addSource("/test.dart", r'''
+    Source source = addSource("/test.dart", r'''
 library lib;
 
 main() {}''');
-    LineInfo info = _context.computeLineInfo(source);
+    LineInfo info = context.computeLineInfo(source);
     expect(info, isNotNull);
   }
 
   void test_computeLineInfo_html() {
-    Source source = _addSource("/test.html", r'''
+    Source source = addSource("/test.html", r'''
 <html>
   <body>
     <h1>A</h1>
   </body>
 </html>''');
-    LineInfo info = _context.computeLineInfo(source);
+    LineInfo info = context.computeLineInfo(source);
     expect(info, isNotNull);
   }
 
   Future test_computeResolvedCompilationUnitAsync_afterDispose() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
+    Source source = addSource("/lib.dart", "library lib;");
     // Complete all pending analysis tasks and flush the AST so that it won't
     // be available immediately.
     _performPendingAnalysisTasks();
     _flushAst(source);
     // Dispose of the context.
-    _context.dispose();
+    context.dispose();
     // Any attempt to start an asynchronous computation should return a future
     // which completes with error.
     CancelableFuture<CompilationUnit> future =
-        _context.computeResolvedCompilationUnitAsync(source, source);
+        context.computeResolvedCompilationUnitAsync(source, source);
     bool completed = false;
     future.then((CompilationUnit unit) {
       fail('Future should have completed with error');
     }, onError: (error) {
       expect(error, new isInstanceOf<AnalysisNotScheduledError>());
       completed = true;
     });
     return pumpEventQueue().then((_) {
       expect(completed, isTrue);
     });
   }
 
   void test_dispose() {
-    expect(_context.isDisposed, isFalse);
-    _context.dispose();
-    expect(_context.isDisposed, isTrue);
+    expect(context.isDisposed, isFalse);
+    context.dispose();
+    expect(context.isDisposed, isTrue);
   }
 
   void test_exists_false() {
     TestSource source = new TestSource();
     source.exists2 = false;
-    expect(_context.exists(source), isFalse);
+    expect(context.exists(source), isFalse);
   }
 
   void test_exists_null() {
-    expect(_context.exists(null), isFalse);
+    expect(context.exists(null), isFalse);
   }
 
   void test_exists_overridden() {
     Source source = new TestSource();
-    _context.setContents(source, "");
-    expect(_context.exists(source), isTrue);
+    context.setContents(source, "");
+    expect(context.exists(source), isTrue);
   }
 
   void test_exists_true() {
-    expect(_context.exists(new AnalysisContextImplTest_Source_exists_true()),
+    expect(context.exists(new AnalysisContextImplTest_Source_exists_true()),
         isTrue);
   }
 
   void test_getAnalysisOptions() {
-    expect(_context.analysisOptions, isNotNull);
+    expect(context.analysisOptions, isNotNull);
   }
 
   void test_getContents_fromSource() {
     String content = "library lib;";
     TimestampedData<String> contents =
-        _context.getContents(new TestSource('/test.dart', content));
+        context.getContents(new TestSource('/test.dart', content));
     expect(contents.data.toString(), content);
   }
 
   void test_getContents_overridden() {
     String content = "library lib;";
     Source source = new TestSource();
-    _context.setContents(source, content);
-    TimestampedData<String> contents = _context.getContents(source);
+    context.setContents(source, content);
+    TimestampedData<String> contents = context.getContents(source);
     expect(contents.data.toString(), content);
   }
 
   void test_getContents_unoverridden() {
     String content = "library lib;";
     Source source = new TestSource('/test.dart', content);
-    _context.setContents(source, "part of lib;");
-    _context.setContents(source, null);
-    TimestampedData<String> contents = _context.getContents(source);
+    context.setContents(source, "part of lib;");
+    context.setContents(source, null);
+    TimestampedData<String> contents = context.getContents(source);
     expect(contents.data.toString(), content);
   }
 
   void test_getDeclaredVariables() {
-    _context = contextWithCore();
-    expect(_context.declaredVariables, isNotNull);
+    expect(context.declaredVariables, isNotNull);
   }
 
   void test_getElement() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
     LibraryElement core =
-        _context.computeLibraryElement(_sourceFactory.forUri("dart:core"));
+        context.computeLibraryElement(sourceFactory.forUri("dart:core"));
     expect(core, isNotNull);
     ClassElement classObject =
         _findClass(core.definingCompilationUnit, "Object");
     expect(classObject, isNotNull);
     ElementLocation location = classObject.location;
-    Element element = _context.getElement(location);
+    Element element = context.getElement(location);
     expect(element, same(classObject));
   }
 
   void test_getHtmlElement_dart() {
-    Source source = _addSource("/test.dart", "");
-    expect(_context.getHtmlElement(source), isNull);
-    expect(_context.computeHtmlElement(source), isNull);
-    expect(_context.getHtmlElement(source), isNull);
+    Source source = addSource("/test.dart", "");
+    expect(context.getHtmlElement(source), isNull);
+    expect(context.computeHtmlElement(source), isNull);
+    expect(context.getHtmlElement(source), isNull);
   }
 
   void test_getHtmlFilesReferencing_html() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source htmlSource = _addSource("/test.html", r'''
+    Source htmlSource = addSource("/test.html", r'''
 <html><head>
 <script type='application/dart' src='test.dart'/>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
-    Source librarySource = _addSource("/test.dart", "library lib;");
-    Source secondHtmlSource = _addSource("/test.html", "<html></html>");
-    _context.computeLibraryElement(librarySource);
-    List<Source> result = _context.getHtmlFilesReferencing(secondHtmlSource);
+    Source librarySource = addSource("/test.dart", "library lib;");
+    Source secondHtmlSource = addSource("/test.html", "<html></html>");
+    context.computeLibraryElement(librarySource);
+    List<Source> result = context.getHtmlFilesReferencing(secondHtmlSource);
     expect(result, hasLength(0));
-    _context.parseHtmlUnit(htmlSource);
-    result = _context.getHtmlFilesReferencing(secondHtmlSource);
+    context.parseHtmlUnit(htmlSource);
+    result = context.getHtmlFilesReferencing(secondHtmlSource);
     expect(result, hasLength(0));
   }
 
   void test_getKindOf_html() {
-    Source source = _addSource("/test.html", "");
-    expect(_context.getKindOf(source), same(SourceKind.HTML));
+    Source source = addSource("/test.html", "");
+    expect(context.getKindOf(source), same(SourceKind.HTML));
   }
 
   void test_getKindOf_library() {
-    Source source = _addSource("/test.dart", "library lib;");
-    expect(_context.getKindOf(source), same(SourceKind.UNKNOWN));
-    _context.computeKindOf(source);
-    expect(_context.getKindOf(source), same(SourceKind.LIBRARY));
+    Source source = addSource("/test.dart", "library lib;");
+    expect(context.getKindOf(source), same(SourceKind.UNKNOWN));
+    context.computeKindOf(source);
+    expect(context.getKindOf(source), same(SourceKind.LIBRARY));
   }
 
   void test_getKindOf_part() {
-    Source source = _addSource("/test.dart", "part of lib;");
-    expect(_context.getKindOf(source), same(SourceKind.UNKNOWN));
-    _context.computeKindOf(source);
-    expect(_context.getKindOf(source), same(SourceKind.PART));
+    Source source = addSource("/test.dart", "part of lib;");
+    expect(context.getKindOf(source), same(SourceKind.UNKNOWN));
+    context.computeKindOf(source);
+    expect(context.getKindOf(source), same(SourceKind.PART));
   }
 
   void test_getKindOf_unknown() {
-    Source source = _addSource("/test.css", "");
-    expect(_context.getKindOf(source), same(SourceKind.UNKNOWN));
+    Source source = addSource("/test.css", "");
+    expect(context.getKindOf(source), same(SourceKind.UNKNOWN));
   }
 
   void test_getLaunchableClientLibrarySources_doesNotImportHtml() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", r'''
-main() {}''');
-    _context.computeLibraryElement(source);
-    List<Source> sources = _context.launchableClientLibrarySources;
+    Source source = addSource("/test.dart", r'''
+main() {}''');
+    context.computeLibraryElement(source);
+    List<Source> sources = context.launchableClientLibrarySources;
     expect(sources, isEmpty);
   }
 
   void test_getLaunchableClientLibrarySources_importsHtml_explicitly() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    List<Source> sources = _context.launchableClientLibrarySources;
-    expect(sources, isEmpty);
-    Source source = _addSource("/test.dart", r'''
-import 'dart:html';
-main() {}''');
-    _context.computeLibraryElement(source);
-    sources = _context.launchableClientLibrarySources;
+    List<Source> sources = context.launchableClientLibrarySources;
+    expect(sources, isEmpty);
+    Source source = addSource("/test.dart", r'''
+import 'dart:html';
+main() {}''');
+    context.computeLibraryElement(source);
+    sources = context.launchableClientLibrarySources;
     expect(sources, unorderedEquals([source]));
   }
 
   void test_getLaunchableClientLibrarySources_importsHtml_implicitly() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    List<Source> sources = _context.launchableClientLibrarySources;
-    expect(sources, isEmpty);
-    _addSource("/a.dart", r'''
-import 'dart:html';
-''');
-    Source source = _addSource("/test.dart", r'''
+    List<Source> sources = context.launchableClientLibrarySources;
+    expect(sources, isEmpty);
+    addSource("/a.dart", r'''
+import 'dart:html';
+''');
+    Source source = addSource("/test.dart", r'''
 import 'a.dart';
 main() {}''');
-    _context.computeLibraryElement(source);
-    sources = _context.launchableClientLibrarySources;
+    context.computeLibraryElement(source);
+    sources = context.launchableClientLibrarySources;
     expect(sources, unorderedEquals([source]));
   }
 
   void test_getLaunchableClientLibrarySources_importsHtml_implicitly2() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    List<Source> sources = _context.launchableClientLibrarySources;
-    expect(sources, isEmpty);
-    _addSource("/a.dart", r'''
+    List<Source> sources = context.launchableClientLibrarySources;
+    expect(sources, isEmpty);
+    addSource("/a.dart", r'''
 export 'dart:html';
 ''');
-    Source source = _addSource("/test.dart", r'''
+    Source source = addSource("/test.dart", r'''
 import 'a.dart';
 main() {}''');
-    _context.computeLibraryElement(source);
-    sources = _context.launchableClientLibrarySources;
+    context.computeLibraryElement(source);
+    sources = context.launchableClientLibrarySources;
     expect(sources, unorderedEquals([source]));
   }
 
   void test_getLaunchableServerLibrarySources() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    expect(_context.launchableServerLibrarySources, isEmpty);
-    Source source = _addSource("/test.dart", "main() {}");
-    _context.computeLibraryElement(source);
-    expect(_context.launchableServerLibrarySources, unorderedEquals([source]));
+    expect(context.launchableServerLibrarySources, isEmpty);
+    Source source = addSource("/test.dart", "main() {}");
+    context.computeLibraryElement(source);
+    expect(context.launchableServerLibrarySources, unorderedEquals([source]));
   }
 
   void test_getLaunchableServerLibrarySources_importsHtml_explicitly() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", r'''
+    Source source = addSource("/test.dart", r'''
 import 'dart:html';
 main() {}
 ''');
-    _context.computeLibraryElement(source);
-    expect(_context.launchableServerLibrarySources, isEmpty);
+    context.computeLibraryElement(source);
+    expect(context.launchableServerLibrarySources, isEmpty);
   }
 
   void test_getLaunchableServerLibrarySources_importsHtml_implicitly() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    _addSource("/imports_html.dart", r'''
-import 'dart:html';
-''');
-    Source source = _addSource("/test.dart", r'''
+    addSource("/imports_html.dart", r'''
+import 'dart:html';
+''');
+    Source source = addSource("/test.dart", r'''
 import 'imports_html.dart';
 main() {}''');
-    _context.computeLibraryElement(source);
-    expect(_context.launchableServerLibrarySources, isEmpty);
+    context.computeLibraryElement(source);
+    expect(context.launchableServerLibrarySources, isEmpty);
   }
 
   void test_getLaunchableServerLibrarySources_noMain() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", '');
-    _context.computeLibraryElement(source);
-    expect(_context.launchableServerLibrarySources, isEmpty);
+    Source source = addSource("/test.dart", '');
+    context.computeLibraryElement(source);
+    expect(context.launchableServerLibrarySources, isEmpty);
   }
 
   void test_getLibrariesContaining() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", r'''
+    Source librarySource = addSource("/lib.dart", r'''
 library lib;
 part 'part.dart';''');
-    Source partSource = _addSource("/part.dart", "part of lib;");
-    _context.computeLibraryElement(librarySource);
-    List<Source> result = _context.getLibrariesContaining(librarySource);
+    Source partSource = addSource("/part.dart", "part of lib;");
+    context.computeLibraryElement(librarySource);
+    List<Source> result = context.getLibrariesContaining(librarySource);
     expect(result, hasLength(1));
     expect(result[0], librarySource);
-    result = _context.getLibrariesContaining(partSource);
+    result = context.getLibrariesContaining(partSource);
     expect(result, hasLength(1));
     expect(result[0], librarySource);
   }
 
   void test_getLibrariesDependingOn() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source libASource = _addSource("/libA.dart", "library libA;");
-    _addSource("/libB.dart", "library libB;");
-    Source lib1Source = _addSource("/lib1.dart", r'''
+    Source libASource = addSource("/libA.dart", "library libA;");
+    addSource("/libB.dart", "library libB;");
+    Source lib1Source = addSource("/lib1.dart", r'''
 library lib1;
 import 'libA.dart';
 export 'libB.dart';''');
-    Source lib2Source = _addSource("/lib2.dart", r'''
+    Source lib2Source = addSource("/lib2.dart", r'''
 library lib2;
 import 'libB.dart';
 export 'libA.dart';''');
-    _context.computeLibraryElement(lib1Source);
-    _context.computeLibraryElement(lib2Source);
-    List<Source> result = _context.getLibrariesDependingOn(libASource);
+    context.computeLibraryElement(lib1Source);
+    context.computeLibraryElement(lib2Source);
+    List<Source> result = context.getLibrariesDependingOn(libASource);
     expect(result, unorderedEquals([lib1Source, lib2Source]));
   }
 
   void test_getLibrariesReferencedFromHtml_no() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source htmlSource = _addSource("/test.html", r'''
+    Source htmlSource = addSource("/test.html", r'''
 <html><head>
 <script type='application/dart' src='test.js'/>
 </head></html>''');
-    _addSource("/test.dart", "library lib;");
-    _context.parseHtmlUnit(htmlSource);
-    List<Source> result = _context.getLibrariesReferencedFromHtml(htmlSource);
+    addSource("/test.dart", "library lib;");
+    context.parseHtmlUnit(htmlSource);
+    List<Source> result = context.getLibrariesReferencedFromHtml(htmlSource);
     expect(result, hasLength(0));
   }
 
   void test_getLibraryElement() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", "library lib;");
-    LibraryElement element = _context.getLibraryElement(source);
+    Source source = addSource("/test.dart", "library lib;");
+    LibraryElement element = context.getLibraryElement(source);
     expect(element, isNull);
-    _context.computeLibraryElement(source);
-    element = _context.getLibraryElement(source);
+    context.computeLibraryElement(source);
+    element = context.getLibraryElement(source);
     expect(element, isNotNull);
   }
 
   void test_getLibrarySources() {
-    List<Source> sources = _context.librarySources;
+    List<Source> sources = context.librarySources;
     int originalLength = sources.length;
-    Source source = _addSource("/test.dart", "library lib;");
-    _context.computeKindOf(source);
-    sources = _context.librarySources;
+    Source source = addSource("/test.dart", "library lib;");
+    context.computeKindOf(source);
+    sources = context.librarySources;
     expect(sources, hasLength(originalLength + 1));
     for (Source returnedSource in sources) {
       if (returnedSource == source) {
         return;
       }
     }
     fail("The added source was not in the list of library sources");
   }
 
   void test_getLineInfo() {
-    Source source = _addSource("/test.dart", r'''
+    Source source = addSource("/test.dart", r'''
 library lib;
 
 main() {}''');
-    LineInfo info = _context.getLineInfo(source);
+    LineInfo info = context.getLineInfo(source);
     expect(info, isNull);
-    _context.parseCompilationUnit(source);
-    info = _context.getLineInfo(source);
+    context.parseCompilationUnit(source);
+    info = context.getLineInfo(source);
     expect(info, isNotNull);
   }
 
   void test_getModificationStamp_fromSource() {
     int stamp = 42;
-    expect(_context.getModificationStamp(
+    expect(context.getModificationStamp(
         new AnalysisContextImplTest_Source_getModificationStamp_fromSource(
             stamp)), stamp);
   }
 
   void test_getModificationStamp_overridden() {
     int stamp = 42;
     Source source =
         new AnalysisContextImplTest_Source_getModificationStamp_overridden(
             stamp);
-    _context.setContents(source, "");
-    expect(stamp != _context.getModificationStamp(source), isTrue);
+    context.setContents(source, "");
+    expect(stamp != context.getModificationStamp(source), isTrue);
   }
 
   void test_getPublicNamespace_element() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", "class A {}");
-    LibraryElement library = _context.computeLibraryElement(source);
+    Source source = addSource("/test.dart", "class A {}");
+    LibraryElement library = context.computeLibraryElement(source);
     expect(library, isNotNull);
-    Namespace namespace = _context.getPublicNamespace(library);
+    Namespace namespace = context.getPublicNamespace(library);
     expect(namespace, isNotNull);
     EngineTestCase.assertInstanceOf(
         (obj) => obj is ClassElement, ClassElement, namespace.get("A"));
   }
 
   void test_getResolvedCompilationUnit_library_null() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
-    expect(_context.getResolvedCompilationUnit(source, null), isNull);
+    Source source = addSource("/lib.dart", "library lib;");
+    expect(context.getResolvedCompilationUnit(source, null), isNull);
   }
 
   void test_getResolvedCompilationUnit_source_dart() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
-    expect(_context.getResolvedCompilationUnit2(source, source), isNull);
-    _context.resolveCompilationUnit2(source, source);
-    expect(_context.getResolvedCompilationUnit2(source, source), isNotNull);
+    Source source = addSource("/lib.dart", "library lib;");
+    expect(context.getResolvedCompilationUnit2(source, source), isNull);
+    context.resolveCompilationUnit2(source, source);
+    expect(context.getResolvedCompilationUnit2(source, source), isNotNull);
   }
 
   void test_getResolvedCompilationUnit_source_html() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.html", "<html></html>");
-    expect(_context.getResolvedCompilationUnit2(source, source), isNull);
-    expect(_context.resolveCompilationUnit2(source, source), isNull);
-    expect(_context.getResolvedCompilationUnit2(source, source), isNull);
+    Source source = addSource("/test.html", "<html></html>");
+    expect(context.getResolvedCompilationUnit2(source, source), isNull);
+    expect(context.resolveCompilationUnit2(source, source), isNull);
+    expect(context.getResolvedCompilationUnit2(source, source), isNull);
   }
 
   void test_getSourceFactory() {
-    expect(_context.sourceFactory, same(_sourceFactory));
+    expect(context.sourceFactory, same(sourceFactory));
   }
 
   void test_getSourcesWithFullName() {
     String filePath = '/foo/lib/file.dart';
     List<Source> expected = <Source>[];
     ChangeSet changeSet = new ChangeSet();
 
     TestSourceWithUri source1 =
         new TestSourceWithUri(filePath, Uri.parse('file://$filePath'));
     expected.add(source1);
     changeSet.addedSource(source1);
 
     TestSourceWithUri source2 =
         new TestSourceWithUri(filePath, Uri.parse('package:foo/file.dart'));
     expected.add(source2);
     changeSet.addedSource(source2);
 
-    _context.applyChanges(changeSet);
-    expect(
-        _context.getSourcesWithFullName(filePath), unorderedEquals(expected));
+    context.applyChanges(changeSet);
+    expect(context.getSourcesWithFullName(filePath), unorderedEquals(expected));
   }
 
   void test_getStatistics() {
-    AnalysisContextStatistics statistics = _context.statistics;
+    AnalysisContextStatistics statistics = context.statistics;
     expect(statistics, isNotNull);
     // The following lines are fragile.
     // The values depend on the number of libraries in the SDK.
 //    assertLength(0, statistics.getCacheRows());
 //    assertLength(0, statistics.getExceptions());
 //    assertLength(0, statistics.getSources());
   }
 
   void test_isClientLibrary_dart() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", r'''
+    Source source = addSource("/test.dart", r'''
 import 'dart:html';
 
 main() {}''');
-    expect(_context.isClientLibrary(source), isFalse);
-    expect(_context.isServerLibrary(source), isFalse);
-    _context.computeLibraryElement(source);
-    expect(_context.isClientLibrary(source), isTrue);
-    expect(_context.isServerLibrary(source), isFalse);
+    expect(context.isClientLibrary(source), isFalse);
+    expect(context.isServerLibrary(source), isFalse);
+    context.computeLibraryElement(source);
+    expect(context.isClientLibrary(source), isTrue);
+    expect(context.isServerLibrary(source), isFalse);
   }
 
   void test_isClientLibrary_html() {
-    Source source = _addSource("/test.html", "<html></html>");
-    expect(_context.isClientLibrary(source), isFalse);
+    Source source = addSource("/test.html", "<html></html>");
+    expect(context.isClientLibrary(source), isFalse);
   }
 
   void test_isServerLibrary_dart() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/test.dart", r'''
+    Source source = addSource("/test.dart", r'''
 library lib;
 
 main() {}''');
-    expect(_context.isClientLibrary(source), isFalse);
-    expect(_context.isServerLibrary(source), isFalse);
-    _context.computeLibraryElement(source);
-    expect(_context.isClientLibrary(source), isFalse);
-    expect(_context.isServerLibrary(source), isTrue);
+    expect(context.isClientLibrary(source), isFalse);
+    expect(context.isServerLibrary(source), isFalse);
+    context.computeLibraryElement(source);
+    expect(context.isClientLibrary(source), isFalse);
+    expect(context.isServerLibrary(source), isTrue);
   }
 
   void test_isServerLibrary_html() {
-    Source source = _addSource("/test.html", "<html></html>");
-    expect(_context.isServerLibrary(source), isFalse);
+    Source source = addSource("/test.html", "<html></html>");
+    expect(context.isServerLibrary(source), isFalse);
   }
 
   void test_parseCompilationUnit_errors() {
-    Source source = _addSource("/lib.dart", "library {");
-    CompilationUnit compilationUnit = _context.parseCompilationUnit(source);
+    Source source = addSource("/lib.dart", "library {");
+    CompilationUnit compilationUnit = context.parseCompilationUnit(source);
     expect(compilationUnit, isNotNull);
-    var errorInfo = _context.getErrors(source);
+    var errorInfo = context.getErrors(source);
     expect(errorInfo, isNotNull);
     List<AnalysisError> errors = errorInfo.errors;
     expect(errors, isNotNull);
     expect(errors.length > 0, isTrue);
   }
 
   void test_parseCompilationUnit_exception() {
     Source source = _addSourceWithException("/test.dart");
     try {
-      _context.parseCompilationUnit(source);
+      context.parseCompilationUnit(source);
       fail("Expected AnalysisException");
     } on AnalysisException {
       // Expected
     }
   }
 
   void test_parseCompilationUnit_html() {
-    Source source = _addSource("/test.html", "<html></html>");
-    expect(_context.parseCompilationUnit(source), isNull);
+    Source source = addSource("/test.html", "<html></html>");
+    expect(context.parseCompilationUnit(source), isNull);
   }
 
   void test_parseCompilationUnit_noErrors() {
-    Source source = _addSource("/lib.dart", "library lib;");
-    CompilationUnit compilationUnit = _context.parseCompilationUnit(source);
+    Source source = addSource("/lib.dart", "library lib;");
+    CompilationUnit compilationUnit = context.parseCompilationUnit(source);
     expect(compilationUnit, isNotNull);
-    AnalysisErrorInfo errorInfo = _context.getErrors(source);
+    AnalysisErrorInfo errorInfo = context.getErrors(source);
     expect(errorInfo, isNotNull);
     expect(errorInfo.errors, hasLength(0));
   }
 
   void test_parseCompilationUnit_nonExistentSource() {
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    Source source = newSource('/test.dart');
+    resourceProvider.deleteFile('/test.dart');
     try {
-      _context.parseCompilationUnit(source);
+      context.parseCompilationUnit(source);
       fail("Expected AnalysisException because file does not exist");
     } on AnalysisException {
       // Expected result
     }
   }
 
 //  void test_resolveCompilationUnit_sourceChangeDuringResolution() {
 //    _context = new _AnalysisContext_sourceChangeDuringResolution();
 //    AnalysisContextFactory.initContextWithCore(_context);
 //    _sourceFactory = _context.sourceFactory;
@@ skipping 16 matching lines @@
 //      Thread.sleep(1);
 //      // Force the modification time to be different.
 //    }
 //    _context.setContents(source, "library test;");
 //    JUnitTestCase.assertTrue(initialTime != _context.getModificationStamp(source));
 //    _analyzeAll_assertFinished();
 //    JUnitTestCase.assertNotNullMsg("performAnalysisTask failed to compute an element model", _context.getLibraryElement(source));
   }
 
   void test_resolveCompilationUnit_library() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
-    LibraryElement library = _context.computeLibraryElement(source);
+    Source source = addSource("/lib.dart", "library lib;");
+    LibraryElement library = context.computeLibraryElement(source);
     CompilationUnit compilationUnit =
-        _context.resolveCompilationUnit(source, library);
+        context.resolveCompilationUnit(source, library);
     expect(compilationUnit, isNotNull);
     expect(compilationUnit.element, isNotNull);
   }
 
   void test_resolveCompilationUnit_source() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
+    Source source = addSource("/lib.dart", "library lib;");
     CompilationUnit compilationUnit =
-        _context.resolveCompilationUnit2(source, source);
+        context.resolveCompilationUnit2(source, source);
     expect(compilationUnit, isNotNull);
   }
 
   void test_setAnalysisOptions() {
     AnalysisOptionsImpl options = new AnalysisOptionsImpl();
     options.cacheSize = 42;
     options.dart2jsHint = false;
     options.hint = false;
-    _context.analysisOptions = options;
-    AnalysisOptions result = _context.analysisOptions;
+    context.analysisOptions = options;
+    AnalysisOptions result = context.analysisOptions;
     expect(result.cacheSize, options.cacheSize);
     expect(result.dart2jsHint, options.dart2jsHint);
     expect(result.hint, options.hint);
   }
 
   void test_setAnalysisPriorityOrder_empty() {
-    _context.analysisPriorityOrder = new List<Source>();
+    context.analysisPriorityOrder = new List<Source>();
   }
 
   void test_setAnalysisPriorityOrder_nonEmpty() {
     List<Source> sources = new List<Source>();
-    sources.add(_addSource("/lib.dart", "library lib;"));
-    _context.analysisPriorityOrder = sources;
+    sources.add(addSource("/lib.dart", "library lib;"));
+    context.analysisPriorityOrder = sources;
   }
 
   void test_setChangedContents_notResolved() {
-    _context = contextWithCore();
     AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
+        new AnalysisOptionsImpl.con1(context.analysisOptions);
     options.incremental = true;
-    _context.analysisOptions = options;
-    _sourceFactory = _context.sourceFactory;
+    context.analysisOptions = options;
     String oldCode = r'''
 library lib;
 int a = 0;''';
-    Source librarySource = _addSource("/lib.dart", oldCode);
+    Source librarySource = addSource("/lib.dart", oldCode);
     int offset = oldCode.indexOf("int a") + 4;
     String newCode = r'''
 library lib;
 int ya = 0;''';
-    _context.setChangedContents(librarySource, newCode, offset, 0, 1);
-    expect(_context.getContents(librarySource).data, newCode);
-    expect(_getIncrementalAnalysisCache(_context), isNull);
+    context.setChangedContents(librarySource, newCode, offset, 0, 1);
+    expect(context.getContents(librarySource).data, newCode);
+    expect(_getIncrementalAnalysisCache(context), isNull);
   }
 
   Future test_setContents_libraryWithPart() {
-    _context = contextWithCore();
     SourcesChangedListener listener = new SourcesChangedListener();
-    _context.onSourcesChanged.listen(listener.onData);
-    _sourceFactory = _context.sourceFactory;
+    context.onSourcesChanged.listen(listener.onData);
     String libraryContents1 = r'''
 library lib;
 part 'part.dart';
 int a = 0;''';
-    Source librarySource = _addSource("/lib.dart", libraryContents1);
+    Source librarySource = addSource("/lib.dart", libraryContents1);
     String partContents1 = r'''
 part of lib;
 int b = a;''';
-    Source partSource = _addSource("/part.dart", partContents1);
-    _context.computeLibraryElement(librarySource);
+    Source partSource = addSource("/part.dart", partContents1);
+    context.computeLibraryElement(librarySource);
     IncrementalAnalysisCache incrementalCache = new IncrementalAnalysisCache(
         librarySource, librarySource, null, null, null, 0, 0, 0);
-    _setIncrementalAnalysisCache(_context, incrementalCache);
-    expect(_getIncrementalAnalysisCache(_context), same(incrementalCache));
+    _setIncrementalAnalysisCache(context, incrementalCache);
+    expect(_getIncrementalAnalysisCache(context), same(incrementalCache));
     String libraryContents2 = r'''
 library lib;
 part 'part.dart';
 int aa = 0;''';
-    _context.setContents(librarySource, libraryContents2);
-    expect(_context.getResolvedCompilationUnit2(partSource, librarySource),
-        isNull);
-    expect(_getIncrementalAnalysisCache(_context), isNull);
+    context.setContents(librarySource, libraryContents2);
+    expect(
+        context.getResolvedCompilationUnit2(partSource, librarySource), isNull);
+    expect(_getIncrementalAnalysisCache(context), isNull);
     return pumpEventQueue().then((_) {
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [librarySource]);
       listener.assertEvent(wereSourcesAdded: true);
       listener.assertEvent(changedSources: [partSource]);
       listener.assertEvent(changedSources: [librarySource]);
       listener.assertNoMoreEvents();
     });
   }
 
   void test_setContents_null() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source librarySource = _addSource("/lib.dart", r'''
+    Source librarySource = addSource("/lib.dart", r'''
 library lib;
 int a = 0;''');
-    _context.computeLibraryElement(librarySource);
+    context.computeLibraryElement(librarySource);
     IncrementalAnalysisCache incrementalCache = new IncrementalAnalysisCache(
         librarySource, librarySource, null, null, null, 0, 0, 0);
-    _setIncrementalAnalysisCache(_context, incrementalCache);
-    expect(_getIncrementalAnalysisCache(_context), same(incrementalCache));
-    _context.setContents(librarySource, null);
-    expect(_context.getResolvedCompilationUnit2(librarySource, librarySource),
+    _setIncrementalAnalysisCache(context, incrementalCache);
+    expect(_getIncrementalAnalysisCache(context), same(incrementalCache));
+    context.setContents(librarySource, null);
+    expect(context.getResolvedCompilationUnit2(librarySource, librarySource),
         isNull);
-    expect(_getIncrementalAnalysisCache(_context), isNull);
+    expect(_getIncrementalAnalysisCache(context), isNull);
   }
 
   void test_setSourceFactory() {
-    expect(_context.sourceFactory, _sourceFactory);
+    expect(context.sourceFactory, sourceFactory);
     SourceFactory factory = new SourceFactory([]);
-    _context.sourceFactory = factory;
-    expect(_context.sourceFactory, factory);
+    context.sourceFactory = factory;
+    expect(context.sourceFactory, factory);
   }
 
   void test_updateAnalysis() {
-    expect(_context.sourcesNeedingProcessing, isEmpty);
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile("/test.dart"));
+    expect(context.sourcesNeedingProcessing, isEmpty);
+    Source source = newSource('/test.dart');
     AnalysisDelta delta = new AnalysisDelta();
     delta.setAnalysisLevel(source, AnalysisLevel.ALL);
-    _context.applyAnalysisDelta(delta);
-    expect(_context.sourcesNeedingProcessing, contains(source));
+    context.applyAnalysisDelta(delta);
+    expect(context.sourcesNeedingProcessing, contains(source));
     delta = new AnalysisDelta();
     delta.setAnalysisLevel(source, AnalysisLevel.NONE);
-    _context.applyAnalysisDelta(delta);
-    expect(_context.sourcesNeedingProcessing.contains(source), isFalse);
+    context.applyAnalysisDelta(delta);
+    expect(context.sourcesNeedingProcessing.contains(source), isFalse);
   }
 
   Future xtest_computeResolvedCompilationUnitAsync() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
+    Source source = addSource("/lib.dart", "library lib;");
     // Complete all pending analysis tasks and flush the AST so that it won't
     // be available immediately.
     _performPendingAnalysisTasks();
     _flushAst(source);
     bool completed = false;
-    _context
+    context
         .computeResolvedCompilationUnitAsync(source, source)
         .then((CompilationUnit unit) {
       expect(unit, isNotNull);
       completed = true;
     });
     return pumpEventQueue().then((_) {
       expect(completed, isFalse);
       _performPendingAnalysisTasks();
     }).then((_) => pumpEventQueue()).then((_) {
       expect(completed, isTrue);
     });
   }
 
   Future xtest_computeResolvedCompilationUnitAsync_cancel() {
-    _context = contextWithCore();
-    _sourceFactory = _context.sourceFactory;
-    Source source = _addSource("/lib.dart", "library lib;");
+    Source source = addSource("/lib.dart", "library lib;");
     // Complete all pending analysis tasks and flush the AST so that it won't
     // be available immediately.
     _performPendingAnalysisTasks();
     _flushAst(source);
     CancelableFuture<CompilationUnit> future =
-        _context.computeResolvedCompilationUnitAsync(source, source);
+        context.computeResolvedCompilationUnitAsync(source, source);
     bool completed = false;
     future.then((CompilationUnit unit) {
       fail('Future should have been canceled');
     }, onError: (error) {
       expect(error, new isInstanceOf<FutureCanceledError>());
       completed = true;
     });
     expect(completed, isFalse);
-    expect(_context.pendingFutureSources_forTesting, isNotEmpty);
+    expect(context.pendingFutureSources_forTesting, isNotEmpty);
     future.cancel();
-    expect(_context.pendingFutureSources_forTesting, isEmpty);
+    expect(context.pendingFutureSources_forTesting, isEmpty);
     return pumpEventQueue().then((_) {
       expect(completed, isTrue);
-      expect(_context.pendingFutureSources_forTesting, isEmpty);
+      expect(context.pendingFutureSources_forTesting, isEmpty);
     });
   }
 
   void xtest_performAnalysisTask_stress() {
     int maxCacheSize = 4;
     AnalysisOptionsImpl options =
-        new AnalysisOptionsImpl.con1(_context.analysisOptions);
+        new AnalysisOptionsImpl.con1(context.analysisOptions);
     options.cacheSize = maxCacheSize;
-    _context.analysisOptions = options;
+    context.analysisOptions = options;
     int sourceCount = maxCacheSize + 2;
     List<Source> sources = new List<Source>();
     ChangeSet changeSet = new ChangeSet();
     for (int i = 0; i < sourceCount; i++) {
-      Source source = _addSource("/lib$i.dart", "library lib$i;");
+      Source source = addSource("/lib$i.dart", "library lib$i;");
       sources.add(source);
       changeSet.addedSource(source);
     }
-    _context.applyChanges(changeSet);
-    _context.analysisPriorityOrder = sources;
+    context.applyChanges(changeSet);
+    context.analysisPriorityOrder = sources;
     for (int i = 0; i < 1000; i++) {
-      List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices;
+      List<ChangeNotice> notice = context.performAnalysisTask().changeNotices;
       if (notice == null) {
         //System.out.println("test_performAnalysisTask_stress: " + i);
         break;
       }
     }
-    List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices;
+    List<ChangeNotice> notice = context.performAnalysisTask().changeNotices;
     if (notice != null) {
       fail(
           "performAnalysisTask failed to terminate after analyzing all sources");
     }
   }
 
-  Source _addSource(String fileName, String contents) {
-    Source source =
-        new FileBasedSource.con1(FileUtilities2.createFile(fileName));
-    ChangeSet changeSet = new ChangeSet();
-    changeSet.addedSource(source);
-    _context.applyChanges(changeSet);
-    _context.setContents(source, contents);
-    return source;
-  }
-
   TestSource _addSourceWithException(String fileName) {
     return _addSourceWithException2(fileName, "");
   }
 
   TestSource _addSourceWithException2(String fileName, String contents) {
     TestSource source = new TestSource(fileName, contents);
     source.generateExceptionOnRead = true;
     ChangeSet changeSet = new ChangeSet();
     changeSet.addedSource(source);
-    _context.applyChanges(changeSet);
+    context.applyChanges(changeSet);
     return source;
   }
 
   /**
    * Perform analysis tasks up to 512 times and asserts that that was enough.
    */
   void _analyzeAll_assertFinished() {
     _analyzeAll_assertFinished2(512);
   }
 
   /**
    * Perform analysis tasks up to the given number of times and asserts that that was enough.
    *
    * @param maxIterations the maximum number of tasks to perform
    */
   void _analyzeAll_assertFinished2(int maxIterations) {
     for (int i = 0; i < maxIterations; i++) {
-      List<ChangeNotice> notice = _context.performAnalysisTask().changeNotices;
+      List<ChangeNotice> notice = context.performAnalysisTask().changeNotices;
       if (notice == null) {
         return;
       }
     }
     fail("performAnalysisTask failed to terminate after analyzing all sources");
   }
 
   void _changeSource(TestSource source, String contents) {
     source.setContents(contents);
     ChangeSet changeSet = new ChangeSet();
     changeSet.changedSource(source);
-    _context.applyChanges(changeSet);
+    context.applyChanges(changeSet);
   }
 
   /**
    * Search the given compilation unit for a class with the given name. Return the class with the
    * given name, or `null` if the class cannot be found.
    *
    * @param unit the compilation unit being searched
    * @param className the name of the class being searched for
    * @return the class with the given name
    */
   ClassElement _findClass(CompilationUnitElement unit, String className) {
     for (ClassElement classElement in unit.types) {
       if (classElement.displayName == className) {
         return classElement;
       }
     }
     return null;
   }
 
   void _flushAst(Source source) {
-    CacheEntry entry = _context.getReadableSourceEntryOrNull(source);
+    CacheEntry entry = context.getReadableSourceEntryOrNull(source);
     entry.setState(RESOLVED_UNIT, CacheState.FLUSHED);
   }
 
   IncrementalAnalysisCache _getIncrementalAnalysisCache(
       AnalysisContextImpl context2) {
     return context2.test_incrementalAnalysisCache;
   }
 
   List<Source> _getPriorityOrder(AnalysisContextImpl context2) {
     return context2.test_priorityOrder;
   }
 
   void _performPendingAnalysisTasks([int maxTasks = 20]) {
-    for (int i = 0; _context.performAnalysisTask().hasMoreWork; i++) {
+    for (int i = 0; context.performAnalysisTask().hasMoreWork; i++) {
       if (i > maxTasks) {
         fail('Analysis did not terminate.');
       }
     }
   }
 
   void _removeSource(Source source) {
     ChangeSet changeSet = new ChangeSet();
     changeSet.removedSource(source);
-    _context.applyChanges(changeSet);
+    context.applyChanges(changeSet);
   }
 
   void _setIncrementalAnalysisCache(
       AnalysisContextImpl context, IncrementalAnalysisCache incrementalCache) {
     context.test_incrementalAnalysisCache = incrementalCache;
   }
 
   /**
    * Returns `true` if there is an [AnalysisError] with [ErrorSeverity.ERROR] in
    * the given [AnalysisErrorInfo].
@@ skipping 47 matching lines @@
       : super(name, UriKind.FILE_URI);
 
   @override
   TimestampedData<String> get contents {
     throw 'Read error';
   }
 
   @override
   bool exists() => true;
 }