anchor.diff:  /// The tests themselves can then be provided via mixin, allowing summaries to
   /// be tested in a variety of ways.
   abstract class SummaryBaseTestStrategy {
  +  /// Add the given package bundle as a dependency so that it may be referenced
  +  /// by the files under test.
  +  void addBundle(String path, PackageBundle bundle);
  +
     /// Add the given source file so that it may be referenced by the file under
     /// test.
     void addNamedSource(String filePath, String contents);
  +
  +  /// Link together the given file, along with any other files passed to
  +  /// [addNamedSource], to form a package bundle.  Reset the state of the
  +  /// buffers accumulated by [addNamedSource] and [addBundle] so that further
  +  /// bundles can be created.
  +  PackageBundleBuilder createPackageBundle(String text,
  +      {String path: '/test.dart', String uri});
   }
   
   /// Abstract base class for black-box tests of summaries.
  
positive.code: 
    LibraryElementInBuildUnit get testLibrary;
  
    /// Add the given package bundle as a dependency so that it may be referenced
    /// by the files under test.
    void addBundle(String path, PackageBundle bundle);
  
    void createLinker(String text, {String path: '/test.dart'});
  
    /// Link together the given file, along with any other files passed to
    /// [addNamedSource], to form a package bundle.  Reset the state of the
    /// buffers accumulated by [addNamedSource] and [addBundle] so that further
    /// bundles can be created.
    PackageBundleBuilder createPackageBundle(String text,
        {String path: '/test.dart', String uri});
  }
  
  /// Implementation of [SummaryLinkerTestStrategy] that drives summary generation
  
negative.code:         _linkerInputs.getDeclaredVariable);
      linker = new Linker(linkedLibraries, _linkerInputs.getDependency,
          _linkerInputs.getUnit, null);
    }
  }
  
  /// [_FilesToLink] stores information about a set of files to be linked
  /// together.  This information is grouped into a class to allow it to be reset
  /// easily when [_SummaryBaseTestStrategyTwoPhase._createLinkerInputs] is
  /// called.
  ///
  /// The generic parameter [U] is the type of information stored for each
  /// compilation unit.
  class _FilesToLink<U> {
    /// Map from absolute URI to the [U] for each compilation unit passed to
    /// [addNamedSource].
    Map<String, U> uriToUnit = <String, U>{};
  
    /// Information about summaries to be included in the link process.
    SummaryDataStore summaryDataStore = new SummaryDataStore([]);
  }
  
  /// Instances of the class [_LinkerInputs] encapsulate the necessary information
  /// to pass to the summary linker.
  class _LinkerInputs {
    final bool _allowMissingFiles;
    final Map<String, UnlinkedUnit> _uriToUnit;
    final Uri _testDartUri;
    final UnlinkedUnit _unlinkedDefiningUnit;
    final Map<String, LinkedLibrary> _dependentLinkedLibraries;
    final Map<String, UnlinkedUnit> _dependentUnlinkedUnits;
  
    _LinkerInputs(
        this._allowMissingFiles,
        this._uriToUnit,
        this._testDartUri,
        this._unlinkedDefiningUnit,
        this._dependentLinkedLibraries,
        this._dependentUnlinkedUnits);
  
    Set<String> get linkedLibraries => _uriToUnit.keys.toSet();
  
    String getDeclaredVariable(String name) {
      return null;
    }
  
    LinkedLibrary getDependency(String absoluteUri) {
      Map<String, LinkedLibrary> sdkLibraries =
          SerializedMockSdk.instance.uriToLinkedLibrary;
      LinkedLibrary linkedLibrary =
          sdkLibraries[absoluteUri] ?? _dependentLinkedLibraries[absoluteUri];
      if (linkedLibrary == null && !_allowMissingFiles) {
        Set<String> librariesAvailable = sdkLibraries.keys.toSet();
        librariesAvailable.addAll(_dependentLinkedLibraries.keys);
        fail('Linker unexpectedly requested LinkedLibrary for "$absoluteUri".'
            '  Libraries available: ${librariesAvailable.toList()}');
      }
      return linkedLibrary;
    }
  
    UnlinkedUnit getUnit(String absoluteUri) {
      if (absoluteUri == null) {
        return null;
      }
      UnlinkedUnit unit = _uriToUnit[absoluteUri] ??
          SerializedMockSdk.instance.uriToUnlinkedUnit[absoluteUri] ??
          _dependentUnlinkedUnits[absoluteUri];
      if (unit == null && !_allowMissingFiles) {
        fail('Linker unexpectedly requested unit for "$absoluteUri".');
      }
      return unit;
    }
  }
  
  /// Implementation of [SummaryBaseTestStrategy] that drives summary generation
  /// using the old two-phase API.
  abstract class _SummaryBaseTestStrategyTwoPhase
      implements SummaryBaseTestStrategy {
    /// Information about the files to be linked.
    _FilesToLink<UnlinkedUnitBuilder> _filesToLink =
        new _FilesToLink<UnlinkedUnitBuilder>();
  
    _LinkerInputs _linkerInputs;
  
    bool get _allowMissingFiles;
  
    @override
    void addBundle(String path, PackageBundle bundle) {
      _filesToLink.summaryDataStore.addBundle(path, bundle);
    }
  
    @override
    void addNamedSource(String filePath, String contents) {
      CompilationUnit unit = _parseText(contents);
      UnlinkedUnitBuilder unlinkedUnit = serializeAstUnlinked(unit);
      _filesToLink.uriToUnit[absUri(filePath)] = unlinkedUnit;
    }
  
    @override
  