anchor.diff:          scrollable,
           moveStep,
           maxIteration: maxScrolls,
  -        duration: duration);
  +        duration: duration,
  +      );
       });
     }
   
  -  /// Repeatedly drags the `view` by `moveStep` until `finder` is visible.
  -  ///
  -  /// Between each operation, wait for `duration` time for settling.
  -  ///
  -  /// Throws a [StateError] if `finder` is not found for maximum `maxIteration`
  -  /// times.
  +  /// Repeatedly drags `view` by `moveStep` until `finder` is visible.
  +  ///
  +  /// Between each drag, advances the clock by `duration`.
  +  ///
  +  /// Throws a [StateError] if `finder` is not found after `maxIteration`
  +  /// drags.
  +  ///
  +  /// See also:
  +  ///
  +  ///  * [scrollUntilVisible], which wraps this method with an API that is more
  +  ///    convenient when dealing with a [Scrollable].
     Future<void> dragUntilVisible(
       Finder finder,
       Finder view,
  
positive.code:       Duration duration = const Duration(milliseconds: 50),
    }) {
      return TestAsyncUtils.guard<void>(() async {
        while(maxIteration > 0 && finder.evaluate().isEmpty) {
          await drag(view, moveStep);
          await pump(duration);
          maxIteration-= 1;
        }
        await Scrollable.ensureVisible(element(finder));
      });
  
negative.code:   /// Given a widget `W` specified by [finder] and a [Scrollable] widget `S` in
    /// its ancestry tree, this scrolls `S` so as to make `W` visible.
    ///
    /// Usually the `finder` for this method should be labeled `skipOffstage:
    /// false`, so that the [Finder] deals with widgets that are off the screen
    /// correctly.
    ///
    /// This does not work when `S` is long enough, and `W` far away enough from
    /// the displayed part of `S`, that `S` has not yet cached `W`'s element.
    /// Consider using [scrollUntilVisible] in such a situation.
    ///
    /// See also:
    ///
    ///  * [Scrollable.ensureVisible], which is the production API used to
    ///    implement this method.
    Future<void> ensureVisible(Finder finder) => Scrollable.ensureVisible(element(finder));
  
    /// Repeatedly scrolls a [Scrollable] by `delta` in the
    /// [Scrollable.axisDirection] direction until a widget matching `finder` is
    /// visible.
    ///
    /// Between each scroll, advances the clock by `duration` time.
    ///
    /// Scrolling is performed until the start of the `finder` is visible. This is
    /// due to the default parameter values of the [Scrollable.ensureVisible] method.
    ///
    /// If `scrollable` is `null`, a [Finder] that looks for a [Scrollable] is
    /// used instead.
    ///
    /// Throws a [StateError] if `finder` is not found after `maxScrolls` scrolls.
    ///
    /// This is different from [ensureVisible] in that this allows looking for
    /// `finder` that is not yet built. The caller must specify the scrollable
    /// that will build child specified by `finder` when there are multiple
    /// [Scrollable]s.
    ///
    /// See also:
    ///
    ///  * [dragUntilVisible], which implements the body of this method.
    Future<void> scrollUntilVisible(
      Finder finder,
      double delta, {
  