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

5 6
// @dart = 2.8

7
import 'dart:async';
8
import 'dart:typed_data';
9
import 'dart:ui' as ui show Image;
10
import 'dart:ui';
11

12
import 'package:flutter/foundation.dart';
13
import 'package:flutter/painting.dart';
14 15

class TestImageInfo implements ImageInfo {
16
  const TestImageInfo(this.value, { this.image, this.scale = 1.0, this.debugLabel });
17 18

  @override
19
  final ui.Image image;
20 21

  @override
22
  final double scale;
23

24 25 26
  @override
  final String debugLabel;

27 28 29 30 31 32
  final int value;

  @override
  String toString() => '$runtimeType($value)';
}

33
class TestImageProvider extends ImageProvider<int> {
34 35 36
  const TestImageProvider(this.key, this.imageValue, { this.image = const TestImage() })
      : assert(image != null);

37
  final int key;
38
  final int imageValue;
39
  final ui.Image image;
40 41

  @override
42
  Future<int> obtainKey(ImageConfiguration configuration) {
43
    return Future<int>.value(key);
44 45 46
  }

  @override
47
  ImageStreamCompleter load(int key, DecoderCallback decode) {
48 49
    return OneFrameImageStreamCompleter(
      SynchronousFuture<ImageInfo>(TestImageInfo(imageValue, image: image))
50
    );
51 52 53
  }

  @override
54
  String toString() => '$runtimeType($key, $imageValue)';
55
}
56

57 58 59 60
class FailingTestImageProvider extends TestImageProvider {
  const FailingTestImageProvider(int key, int imageValue, { ui.Image image }) : super(key, imageValue, image: image);

  @override
61
  ImageStreamCompleter load(int key, DecoderCallback decode) {
62 63 64 65
    return OneFrameImageStreamCompleter(Future<ImageInfo>.sync(() => Future<ImageInfo>.error('loading failed!')));
  }
}

66
Future<ImageInfo> extractOneFrame(ImageStream stream) {
67
  final Completer<ImageInfo> completer = Completer<ImageInfo>();
68 69
  ImageStreamListener listener;
  listener = ImageStreamListener((ImageInfo image, bool synchronousCall) {
70 71
    completer.complete(image);
    stream.removeListener(listener);
72
  });
73 74
  stream.addListener(listener);
  return completer.future;
75
}
76 77 78 79 80 81 82 83 84

class TestImage implements ui.Image {
  const TestImage({this.height = 0, this.width = 0});
  @override
  final int height;
  @override
  final int width;

  @override
85
  void dispose() { }
86 87

  @override
88
  Future<ByteData> toByteData({ ImageByteFormat format = ImageByteFormat.rawRgba }) {
89
    throw UnimplementedError();
90 91
  }
}
92 93 94

class ErrorImageProvider extends ImageProvider<ErrorImageProvider> {
  @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 load(ObtainKeyErrorImageProvider key, DecoderCallback decode) {
108 109 110 111 112 113 114 115 116
    throw Error();
  }

  @override
  Future<ObtainKeyErrorImageProvider> obtainKey(ImageConfiguration configuration) {
    throw Error();
  }
}

117 118
class LoadErrorImageProvider extends ImageProvider<LoadErrorImageProvider> {
  @override
119
  ImageStreamCompleter load(LoadErrorImageProvider key, DecoderCallback decode) {
120 121 122
    throw Error();
  }

123
  @override
124 125 126 127 128
  Future<LoadErrorImageProvider> obtainKey(ImageConfiguration configuration) {
    return SynchronousFuture<LoadErrorImageProvider>(this);
  }
}

129
class LoadErrorCompleterImageProvider extends ImageProvider<LoadErrorCompleterImageProvider> {
130
  @override
131
  ImageStreamCompleter load(LoadErrorCompleterImageProvider key, DecoderCallback decode) {
132
    final Completer<ImageInfo> completer = Completer<ImageInfo>.sync();
133 134
    completer.completeError(Error());
    return OneFrameImageStreamCompleter(completer.future);
135 136
  }

137
  @override
138 139 140 141 142
  Future<LoadErrorCompleterImageProvider> obtainKey(ImageConfiguration configuration) {
    return SynchronousFuture<LoadErrorCompleterImageProvider>(this);
  }
}

143 144 145 146 147
class TestImageStreamCompleter extends ImageStreamCompleter {
  void testSetImage(TestImage image) {
    setImage(ImageInfo(image: image, scale: 1.0));
  }
}