mocks_for_image_cache.dart 4.48 KB
Newer Older
Ian Hickson's avatar
Ian Hickson committed
1
// Copyright 2014 The Flutter Authors. All rights reserved.
2 3 4 5 6 7
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'dart:async';
import 'dart:ui' as ui show Image;

8
import 'package:flutter/foundation.dart';
9
import 'package:flutter/painting.dart';
10

11 12
class TestImageInfo extends ImageInfo {
  const TestImageInfo(this.value, {
13 14 15 16
    required super.image,
    super.scale,
    super.debugLabel,
  });
17

18 19 20
  final int value;

  @override
Ian Hickson's avatar
Ian Hickson committed
21
  String toString() => '${objectRuntimeType(this, 'TestImageInfo')}($value)';
22 23 24 25 26 27 28

  @override
  TestImageInfo clone() {
    return TestImageInfo(value, image: image.clone(), scale: scale, debugLabel: debugLabel);
  }

  @override
29
  int get hashCode => Object.hash(value, image, scale, debugLabel);
30 31 32

  @override
  bool operator ==(Object other) {
33
    if (other.runtimeType != runtimeType) {
34
      return false;
35
    }
36 37 38 39 40 41
    return other is TestImageInfo
        && other.value == value
        && other.image.isCloneOf(image)
        && other.scale == scale
        && other.debugLabel == debugLabel;
  }
42 43
}

44
class TestImageProvider extends ImageProvider<int> {
45
  const TestImageProvider(this.key, this.imageValue, { required this.image })
46 47
      : assert(image != null);

48
  final int key;
49
  final int imageValue;
50
  final ui.Image image;
51 52

  @override
53
  Future<int> obtainKey(ImageConfiguration configuration) {
54
    return Future<int>.value(key);
55 56 57
  }

  @override
58
  ImageStreamCompleter load(int key, DecoderCallback decode) {
59
    return OneFrameImageStreamCompleter(
60
      SynchronousFuture<ImageInfo>(TestImageInfo(imageValue, image: image.clone())),
61
    );
62 63 64
  }

  @override
Ian Hickson's avatar
Ian Hickson committed
65
  String toString() => '${objectRuntimeType(this, 'TestImageProvider')}($key, $imageValue)';
66
}
67

68
class FailingTestImageProvider extends TestImageProvider {
69
  const FailingTestImageProvider(super.key, super.imageValue, { required super.image });
70 71

  @override
72
  ImageStreamCompleter load(int key, DecoderCallback decode) {
73 74 75 76
    return OneFrameImageStreamCompleter(Future<ImageInfo>.sync(() => Future<ImageInfo>.error('loading failed!')));
  }
}

77
Future<ImageInfo> extractOneFrame(ImageStream stream) {
78
  final Completer<ImageInfo> completer = Completer<ImageInfo>();
79
  late ImageStreamListener listener;
80
  listener = ImageStreamListener((ImageInfo image, bool synchronousCall) {
81 82
    completer.complete(image);
    stream.removeListener(listener);
83
  });
84 85
  stream.addListener(listener);
  return completer.future;
86
}
87

88
class ErrorImageProvider extends ImageProvider<ErrorImageProvider> {
89 90 91 92 93
  @override
  ImageStreamCompleter loadBuffer(ErrorImageProvider key, DecoderBufferCallback decode) {
    throw Error();
  }

94
  @override
95
  ImageStreamCompleter load(ErrorImageProvider key, DecoderCallback decode) {
96 97 98 99 100 101 102 103
    throw Error();
  }

  @override
  Future<ErrorImageProvider> obtainKey(ImageConfiguration configuration) {
    return SynchronousFuture<ErrorImageProvider>(this);
  }
}
104

105 106
class ObtainKeyErrorImageProvider extends ImageProvider<ObtainKeyErrorImageProvider> {
  @override
107
  ImageStreamCompleter loadBuffer(ObtainKeyErrorImageProvider key, DecoderBufferCallback decode) {
108 109 110 111 112 113 114
    throw Error();
  }

  @override
  Future<ObtainKeyErrorImageProvider> obtainKey(ImageConfiguration configuration) {
    throw Error();
  }
115 116 117 118 119

  @override
  ImageStreamCompleter load(ObtainKeyErrorImageProvider key, DecoderCallback decode) {
    throw UnimplementedError();
  }
120 121
}

122 123
class LoadErrorImageProvider extends ImageProvider<LoadErrorImageProvider> {
  @override
124
  ImageStreamCompleter loadBuffer(LoadErrorImageProvider key, DecoderBufferCallback decode) {
125 126 127
    throw Error();
  }

128
  @override
129 130 131
  Future<LoadErrorImageProvider> obtainKey(ImageConfiguration configuration) {
    return SynchronousFuture<LoadErrorImageProvider>(this);
  }
132 133 134 135 136

  @override
  ImageStreamCompleter load(LoadErrorImageProvider key, DecoderCallback decode) {
    throw UnimplementedError();
  }
137 138
}

139
class LoadErrorCompleterImageProvider extends ImageProvider<LoadErrorCompleterImageProvider> {
140
  @override
141
  ImageStreamCompleter load(LoadErrorCompleterImageProvider key, DecoderCallback decode) {
142
    final Completer<ImageInfo> completer = Completer<ImageInfo>.sync();
143 144
    completer.completeError(Error());
    return OneFrameImageStreamCompleter(completer.future);
145 146
  }

147
  @override
148 149 150 151 152
  Future<LoadErrorCompleterImageProvider> obtainKey(ImageConfiguration configuration) {
    return SynchronousFuture<LoadErrorCompleterImageProvider>(this);
  }
}

153
class TestImageStreamCompleter extends ImageStreamCompleter {
154
  void testSetImage(ui.Image image) {
155
    setImage(ImageInfo(image: image));
156 157
  }
}