recording_canvas.dart 7.28 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
import 'package:flutter/foundation.dart';
6
import 'package:flutter/rendering.dart';
7
import 'package:flutter/src/rendering/layer.dart';
8

9 10 11 12 13
/// An [Invocation] and the [stack] trace that led to it.
///
/// Used by [TestRecordingCanvas] to trace canvas calls.
class RecordedInvocation {
  /// Create a record for an invocation list.
14
  const RecordedInvocation(this.invocation, { required this.stack });
15 16

  /// The method that was called and its arguments.
17 18 19 20 21 22
  ///
  /// The arguments preserve identity, but not value. Thus, if two invocations
  /// were made with the same [Paint] object, but with that object configured
  /// differently each time, then they will both have the same object as their
  /// argument, and inspecting that object will return the object's current
  /// values (mostly likely those passed to the second call).
23 24 25 26 27 28 29 30 31
  final Invocation invocation;

  /// The stack trace at the time of the method call.
  final StackTrace stack;

  @override
  String toString() => _describeInvocation(invocation);

  /// Converts [stack] to a string using the [FlutterError.defaultStackFilter] logic.
32
  String stackToString({ String indent = '' }) {
33 34 35 36 37 38 39
    assert(indent != null);
    return indent + FlutterError.defaultStackFilter(
      stack.toString().trimRight().split('\n')
    ).join('\n$indent');
  }
}

40 41
/// A [Canvas] for tests that records its method calls.
///
42
/// This class can be used in conjunction with [TestRecordingPaintingContext]
43 44 45 46
/// to record the [Canvas] method calls made by a renderer. For example:
///
/// ```dart
/// RenderBox box = tester.renderObject(find.text('ABC'));
47 48
/// TestRecordingCanvas canvas = TestRecordingCanvas();
/// TestRecordingPaintingContext context = TestRecordingPaintingContext(canvas);
49 50 51 52 53
/// box.paint(context, Offset.zero);
/// // Now test the expected canvas.invocations.
/// ```
///
/// In some cases it may be useful to define a subclass that overrides the
54
/// [Canvas] methods the test is checking and squirrels away the parameters
55
/// that the test requires.
56 57 58
///
/// For simple tests, consider using the [paints] matcher, which overlays a
/// pattern matching API over [TestRecordingCanvas].
59 60
class TestRecordingCanvas implements Canvas {
  /// All of the method calls on this canvas.
61
  final List<RecordedInvocation> invocations = <RecordedInvocation>[];
62 63 64 65 66 67 68 69 70

  int _saveCount = 0;

  @override
  int getSaveCount() => _saveCount;

  @override
  void save() {
    _saveCount += 1;
71
    invocations.add(RecordedInvocation(_MethodCall(#save), stack: StackTrace.current));
72 73
  }

74
  @override
75
  void saveLayer(Rect? bounds, Paint paint) {
76
    _saveCount += 1;
77
    invocations.add(RecordedInvocation(_MethodCall(#saveLayer, <dynamic>[bounds, paint]), stack: StackTrace.current));
78 79
  }

80 81 82 83
  @override
  void restore() {
    _saveCount -= 1;
    assert(_saveCount >= 0);
84
    invocations.add(RecordedInvocation(_MethodCall(#restore), stack: StackTrace.current));
85 86 87 88
  }

  @override
  void noSuchMethod(Invocation invocation) {
89
    invocations.add(RecordedInvocation(invocation, stack: StackTrace.current));
90 91 92 93
  }
}

/// A [PaintingContext] for tests that use [TestRecordingCanvas].
94
class TestRecordingPaintingContext extends ClipContext implements PaintingContext {
95 96 97 98 99 100 101 102 103 104 105 106
  /// Creates a [PaintingContext] for tests that use [TestRecordingCanvas].
  TestRecordingPaintingContext(this.canvas);

  @override
  final Canvas canvas;

  @override
  void paintChild(RenderObject child, Offset offset) {
    child.paint(this, offset);
  }

  @override
107
  ClipRectLayer? pushClipRect(
108 109 110 111 112
    bool needsCompositing,
    Offset offset,
    Rect clipRect,
    PaintingContextCallback painter, {
    Clip clipBehavior = Clip.hardEdge,
113
    ClipRectLayer? oldLayer,
114
  }) {
115
    clipRectAndPaint(clipRect.shift(offset), clipBehavior, clipRect.shift(offset), () => painter(this, offset));
116
    return null;
117 118
  }

119
  @override
120
  ClipRRectLayer? pushClipRRect(
121 122 123 124 125 126
    bool needsCompositing,
    Offset offset,
    Rect bounds,
    RRect clipRRect,
    PaintingContextCallback painter, {
    Clip clipBehavior = Clip.antiAlias,
127
    ClipRRectLayer? oldLayer,
128
  }) {
129 130
    assert(clipBehavior != null);
    clipRRectAndPaint(clipRRect.shift(offset), clipBehavior, bounds.shift(offset), () => painter(this, offset));
131
    return null;
132 133
  }

134
  @override
135
  ClipPathLayer? pushClipPath(
136 137 138 139 140 141
    bool needsCompositing,
    Offset offset,
    Rect bounds,
    Path clipPath,
    PaintingContextCallback painter, {
    Clip clipBehavior = Clip.antiAlias,
142
    ClipPathLayer? oldLayer,
143
  }) {
144
    clipPathAndPaint(clipPath.shift(offset), clipBehavior, bounds.shift(offset), () => painter(this, offset));
145
    return null;
146 147
  }

148
  @override
149
  TransformLayer? pushTransform(
150 151 152 153
    bool needsCompositing,
    Offset offset,
    Matrix4 transform,
    PaintingContextCallback painter, {
154
    TransformLayer? oldLayer,
155
  }) {
156 157 158 159
    canvas.save();
    canvas.transform(transform.storage);
    painter(this, offset);
    canvas.restore();
160
    return null;
161
  }
162 163

  @override
164 165 166 167 168 169 170
  OpacityLayer pushOpacity(
    Offset offset,
    int alpha,
    PaintingContextCallback painter, {
    OpacityLayer? oldLayer,
  }) {
    canvas.saveLayer(null, Paint()); // TODO(ianh): Expose the alpha somewhere.
171 172
    painter(this, offset);
    canvas.restore();
173
    return OpacityLayer();
174
  }
175

176
  @override
177 178 179 180 181 182
  void pushLayer(
    Layer childLayer,
    PaintingContextCallback painter,
    Offset offset, {
    Rect? childPaintBounds,
  }) {
183 184 185
    painter(this, offset);
  }

186
  @override
187
  void noSuchMethod(Invocation invocation) { }
188 189 190
}

class _MethodCall implements Invocation {
191
  _MethodCall(this._name, [ this._arguments = const <dynamic>[], this._typeArguments = const <Type> []]);
192
  final Symbol _name;
193
  final List<dynamic> _arguments;
194
  final List<Type> _typeArguments;
195 196 197 198 199 200 201 202 203 204 205 206 207
  @override
  bool get isAccessor => false;
  @override
  bool get isGetter => false;
  @override
  bool get isMethod => true;
  @override
  bool get isSetter => false;
  @override
  Symbol get memberName => _name;
  @override
  Map<Symbol, dynamic> get namedArguments => <Symbol, dynamic>{};
  @override
208
  List<dynamic> get positionalArguments => _arguments;
209 210
  @override
  List<Type> get typeArguments => _typeArguments;
211
}
212

213
String _valueName(Object? value) {
214 215 216 217 218 219 220 221 222 223 224 225 226 227 228
  if (value is double)
    return value.toStringAsFixed(1);
  return value.toString();
}

// Workaround for https://github.com/dart-lang/sdk/issues/28372
String _symbolName(Symbol symbol) {
  // WARNING: Assumes a fixed format for Symbol.toString which is *not*
  // guaranteed anywhere.
  final String s = '$symbol';
  return s.substring(8, s.length - 2);
}

// Workaround for https://github.com/dart-lang/sdk/issues/28373
String _describeInvocation(Invocation call) {
229
  final StringBuffer buffer = StringBuffer();
230 231 232 233 234 235 236
  buffer.write(_symbolName(call.memberName));
  if (call.isSetter) {
    buffer.write(call.positionalArguments[0].toString());
  } else if (call.isMethod) {
    buffer.write('(');
    buffer.writeAll(call.positionalArguments.map<String>(_valueName), ', ');
    String separator = call.positionalArguments.isEmpty ? '' : ', ';
237
    call.namedArguments.forEach((Symbol name, Object? value) {
238 239 240 241 242 243 244 245 246 247
      buffer.write(separator);
      buffer.write(_symbolName(name));
      buffer.write(': ');
      buffer.write(_valueName(value));
      separator = ', ';
    });
    buffer.write(')');
  }
  return buffer.toString();
}