anchor.diff:  }
   
   /// A mocked [HttpClientResponse] which is empty and has a [statusCode] of 400.
  -class _MockHttpResponse extends Stream<List<int>> implements HttpClientResponse {
  +// TODO(tvolkert): Change to `extends Stream<Uint8List>` once
  +// https://dart-review.googlesource.com/c/sdk/+/104525 is rolled into the framework.
  +class _MockHttpResponse implements HttpClientResponse {
  +  final Stream<Uint8List> _delegate = Stream<Uint8List>.fromIterable(const Iterable<Uint8List>.empty());
  +
     @override
     final HttpHeaders headers = _MockHttpHeaders();
   
  
positive.code:   bool get isRedirect => false;
  
    @override
    StreamSubscription<List<int>> listen(void Function(List<int> event) onData, { Function onError, void Function() onDone, bool cancelOnError }) {
      return const Stream<List<int>>.empty().listen(onData, onError: onError, onDone: onDone, cancelOnError: cancelOnError);
    }
  
    @override
  
negative.code: 
    @override
    int get statusCode => 400;
  
    @override
    Future<bool> any(bool Function(Uint8List element) test) {
      return _delegate.any(test);
    }
  
    @override
    Stream<Uint8List> asBroadcastStream({
      void Function(StreamSubscription<Uint8List> subscription) onListen,
      void Function(StreamSubscription<Uint8List> subscription) onCancel,
    }) {
      return _delegate.asBroadcastStream(onListen: onListen, onCancel: onCancel);
    }
  
    @override
    Stream<E> asyncExpand<E>(Stream<E> Function(Uint8List event) convert) {
      return _delegate.asyncExpand<E>(convert);
    }
  
    @override
    Stream<E> asyncMap<E>(FutureOr<E> Function(Uint8List event) convert) {
      return _delegate.asyncMap<E>(convert);
    }
  
    @override
    Stream<R> cast<R>() {
      return _delegate.cast<R>();
    }
  
    @override
    Future<bool> contains(Object needle) {
      return _delegate.contains(needle);
    }
  
    @override
    Stream<Uint8List> distinct([bool Function(Uint8List previous, Uint8List next) equals]) {
      return _delegate.distinct(equals);
    }
  
    @override
    Future<E> drain<E>([E futureValue]) {
      return _delegate.drain<E>(futureValue);
    }
  
    @override
    Future<Uint8List> elementAt(int index) {
      return _delegate.elementAt(index);
    }
  
    @override
    Future<bool> every(bool Function(Uint8List element) test) {
      return _delegate.every(test);
    }
  
    @override
    Stream<S> expand<S>(Iterable<S> Function(Uint8List element) convert) {
      return _delegate.expand(convert);
    }
  
    @override
    Future<Uint8List> get first => _delegate.first;
  
    @override
    Future<Uint8List> firstWhere(
      bool Function(Uint8List element) test, {
      List<int> Function() orElse,
    }) {
      return _delegate.firstWhere(test, orElse: orElse);
    }
  
    @override
    Future<S> fold<S>(S initialValue, S Function(S previous, Uint8List element) combine) {
      return _delegate.fold<S>(initialValue, combine);
    }
  
    @override
    Future<dynamic> forEach(void Function(Uint8List element) action) {
      return _delegate.forEach(action);
    }
  
    @override
    Stream<Uint8List> handleError(
      Function onError, {
      bool Function(dynamic error) test,
    }) {
      return _delegate.handleError(onError, test: test);
    }
  
    @override
    bool get isBroadcast => _delegate.isBroadcast;
  
    @override
    Future<bool> get isEmpty => _delegate.isEmpty;
  
    @override
    Future<String> join([String separator = '']) {
      return _delegate.join(separator);
    }
  
    @override
    Future<Uint8List> get last => _delegate.last;
  
    @override
    Future<Uint8List> lastWhere(
      bool Function(Uint8List element) test, {
      List<int> Function() orElse,
    }) {
      return _delegate.lastWhere(test, orElse: orElse);
    }
  
    @override
    Future<int> get length => _delegate.length;
  
    @override
    Stream<S> map<S>(S Function(Uint8List event) convert) {
      return _delegate.map<S>(convert);
    }
  
    @override
    Future<dynamic> pipe(StreamConsumer<List<int>> streamConsumer) {
      return _delegate.pipe(streamConsumer);
    }
  
    @override
    Future<Uint8List> reduce(List<int> Function(Uint8List previous, Uint8List element) combine) {
      return _delegate.reduce(combine);
    }
  
    @override
    Future<Uint8List> get single => _delegate.single;
  
    @override
    Future<Uint8List> singleWhere(bool Function(Uint8List element) test, {List<int> Function() orElse}) {
      return _delegate.singleWhere(test, orElse: orElse);
    }
  
    @override
    Stream<Uint8List> skip(int count) {
      return _delegate.skip(count);
    }
  
    @override
    Stream<Uint8List> skipWhile(bool Function(Uint8List element) test) {
      return _delegate.skipWhile(test);
    }
  
    @override
    Stream<Uint8List> take(int count) {
      return _delegate.take(count);
    }
  
    @override
    Stream<Uint8List> takeWhile(bool Function(Uint8List element) test) {
      return _delegate.takeWhile(test);
    }
  
    @override
    Stream<Uint8List> timeout(
      Duration timeLimit, {
      void Function(EventSink<Uint8List> sink) onTimeout,
    }) {
      return _delegate.timeout(timeLimit, onTimeout: onTimeout);
    }
  
    @override
    Future<List<Uint8List>> toList() {
      return _delegate.toList();
    }
  
    @override
    Future<Set<Uint8List>> toSet() {
      return _delegate.toSet();
    }
  
    @override
    Stream<S> transform<S>(StreamTransformer<List<int>, S> streamTransformer) {
      return _delegate.transform<S>(streamTransformer);
    }
  
    @override
    Stream<Uint8List> where(bool Function(Uint8List event) test) {
      return _delegate.where(test);
    }
  }
  
  /// A mocked [HttpHeaders] that ignores all writes.
  