object_test.dart 8.6 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 7
import 'package:flutter/material.dart';
import 'package:flutter/rendering.dart';
8
import 'package:flutter_test/flutter_test.dart';
9

10 11
import 'rendering_tester.dart';

12
void main() {
Ian Hickson's avatar
Ian Hickson committed
13
  test('ensure frame is scheduled for markNeedsSemanticsUpdate', () {
14
    // Initialize all bindings because owner.flushSemantics() requires a window
15
    renderer;
16

17
    final TestRenderObject renderObject = TestRenderObject();
18
    int onNeedVisualUpdateCallCount = 0;
19
    final PipelineOwner owner = PipelineOwner(onNeedVisualUpdate: () {
20 21 22 23
      onNeedVisualUpdateCallCount +=1;
    });
    owner.ensureSemantics();
    renderObject.attach(owner);
24
    renderObject.layout(const BoxConstraints.tightForFinite());  // semantics are only calculated if layout information is up to date.
25 26 27 28 29 30
    owner.flushSemantics();

    expect(onNeedVisualUpdateCallCount, 1);
    renderObject.markNeedsSemanticsUpdate();
    expect(onNeedVisualUpdateCallCount, 2);
  });
31 32

  test('detached RenderObject does not do semantics', () {
33
    final TestRenderObject renderObject = TestRenderObject();
34 35 36 37 38 39
    expect(renderObject.attached, isFalse);
    expect(renderObject.describeSemanticsConfigurationCallCount, 0);

    renderObject.markNeedsSemanticsUpdate();
    expect(renderObject.describeSemanticsConfigurationCallCount, 0);
  });
40 41

  test('ensure errors processing render objects are well formatted', () {
42 43
    late FlutterErrorDetails errorDetails;
    final FlutterExceptionHandler? oldHandler = FlutterError.onError;
44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68
    FlutterError.onError = (FlutterErrorDetails details) {
      errorDetails = details;
    };
    final PipelineOwner owner = PipelineOwner();
    final TestThrowingRenderObject renderObject = TestThrowingRenderObject();
    try {
      renderObject.attach(owner);
      renderObject.layout(const BoxConstraints());
    } finally {
      FlutterError.onError = oldHandler;
    }

    expect(errorDetails, isNotNull);
    expect(errorDetails.stack, isNotNull);
    // Check the ErrorDetails without the stack trace
    final List<String> lines =  errorDetails.toString().split('\n');
    // The lines in the middle of the error message contain the stack trace
    // which will change depending on where the test is run.
    expect(lines.length, greaterThan(8));
    expect(
      lines.take(4).join('\n'),
      equalsIgnoringHashCodes(
        '══╡ EXCEPTION CAUGHT BY RENDERING LIBRARY ╞══════════════════════\n'
        'The following assertion was thrown during performLayout():\n'
        'TestThrowingRenderObject does not support performLayout.\n'
69
      ),
70 71 72 73 74 75 76 77 78 79 80 81 82 83 84
    );

    expect(
      lines.getRange(lines.length - 8, lines.length).join('\n'),
      equalsIgnoringHashCodes(
        '\n'
        'The following RenderObject was being processed when the exception was fired:\n'
        '  TestThrowingRenderObject#00000 NEEDS-PAINT:\n'
        '  parentData: MISSING\n'
        '  constraints: BoxConstraints(unconstrained)\n'
        'This RenderObject has no descendants.\n'
        '═════════════════════════════════════════════════════════════════\n'
      ),
    );
  });
85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101

  test('ContainerParentDataMixin requires nulled out pointers to siblings before detach', () {
    expect(() => TestParentData().detach(), isNot(throwsAssertionError));

    final TestParentData data1 = TestParentData()
      ..nextSibling = RenderOpacity()
      ..previousSibling = RenderOpacity();
    expect(() => data1.detach(), throwsAssertionError);

    final TestParentData data2 = TestParentData()
      ..previousSibling = RenderOpacity();
    expect(() => data2.detach(), throwsAssertionError);

    final TestParentData data3 = TestParentData()
      ..nextSibling = RenderOpacity();
    expect(() => data3.detach(), throwsAssertionError);
  });
102 103

  test('PaintingContext.pushClipRect reuses the layer', () {
104
    _testPaintingContextLayerReuse<ClipRectLayer>((PaintingContextCallback painter, PaintingContext context, Offset offset, Layer? oldLayer) {
105
      return context.pushClipRect(true, offset, Rect.zero, painter, oldLayer: oldLayer as ClipRectLayer?);
106 107 108 109
    });
  });

  test('PaintingContext.pushClipRRect reuses the layer', () {
110
    _testPaintingContextLayerReuse<ClipRRectLayer>((PaintingContextCallback painter, PaintingContext context, Offset offset, Layer? oldLayer) {
111
      return context.pushClipRRect(true, offset, Rect.zero, RRect.fromRectAndRadius(Rect.zero, const Radius.circular(1.0)), painter, oldLayer: oldLayer as ClipRRectLayer?);
112 113 114 115
    });
  });

  test('PaintingContext.pushClipPath reuses the layer', () {
116
    _testPaintingContextLayerReuse<ClipPathLayer>((PaintingContextCallback painter, PaintingContext context, Offset offset, Layer? oldLayer) {
117
      return context.pushClipPath(true, offset, Rect.zero, Path(), painter, oldLayer: oldLayer as ClipPathLayer?);
118 119 120 121
    });
  });

  test('PaintingContext.pushColorFilter reuses the layer', () {
122
    _testPaintingContextLayerReuse<ColorFilterLayer>((PaintingContextCallback painter, PaintingContext context, Offset offset, Layer? oldLayer) {
123
      return context.pushColorFilter(offset, const ColorFilter.mode(Color.fromRGBO(0, 0, 0, 1.0), BlendMode.clear), painter, oldLayer: oldLayer as ColorFilterLayer?);
124 125 126 127
    });
  });

  test('PaintingContext.pushTransform reuses the layer', () {
128
    _testPaintingContextLayerReuse<TransformLayer>((PaintingContextCallback painter, PaintingContext context, Offset offset, Layer? oldLayer) {
129
      return context.pushTransform(true, offset, Matrix4.identity(), painter, oldLayer: oldLayer as TransformLayer?);
130 131 132 133
    });
  });

  test('PaintingContext.pushOpacity reuses the layer', () {
134
    _testPaintingContextLayerReuse<OpacityLayer>((PaintingContextCallback painter, PaintingContext context, Offset offset, Layer? oldLayer) {
135
      return context.pushOpacity(offset, 100, painter, oldLayer: oldLayer as OpacityLayer?);
136 137 138 139 140 141 142 143 144 145 146 147 148 149 150
    });
  });
}

// Tests the create-update cycle by pumping two frames. The first frame has no
// prior layer and forces the painting context to create a new one. The second
// frame reuses the layer painted on the first frame.
void _testPaintingContextLayerReuse<L extends Layer>(_LayerTestPaintCallback painter) {
  final _TestCustomLayerBox box = _TestCustomLayerBox(painter);
  layout(box, phase: EnginePhase.paint);

  // Force a repaint. Otherwise, pumpFrame is a noop.
  box.markNeedsPaint();
  pumpFrame(phase: EnginePhase.paint);
  expect(box.paintedLayers, hasLength(2));
Dan Field's avatar
Dan Field committed
151
  expect(box.paintedLayers[0], isA<L>());
152 153 154
  expect(box.paintedLayers[0], same(box.paintedLayers[1]));
}

155
typedef _LayerTestPaintCallback = Layer? Function(PaintingContextCallback painter, PaintingContext context, Offset offset, Layer? oldLayer);
156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172

class _TestCustomLayerBox extends RenderBox {
  _TestCustomLayerBox(this.painter);

  final _LayerTestPaintCallback painter;
  final List<Layer> paintedLayers = <Layer>[];

  @override
  bool get isRepaintBoundary => false;

  @override
  void performLayout() {
    size = constraints.smallest;
  }

  @override
  void paint(PaintingContext context, Offset offset) {
173
    final Layer paintedLayer = painter(super.paint, context, offset, layer)!;
174
    paintedLayers.add(paintedLayer);
175
    layer = paintedLayer as ContainerLayer;
176
  }
177 178
}

179 180
class TestParentData extends ParentData with ContainerParentDataMixin<RenderBox> { }

181 182
class TestRenderObject extends RenderObject {
  @override
183
  void debugAssertDoesMeetConstraints() { }
184 185

  @override
186 187 188 189
  Rect get paintBounds {
    assert(false); // The test shouldn't call this.
    return Rect.zero;
  }
190 191

  @override
192
  void performLayout() { }
193 194

  @override
195
  void performResize() { }
196 197

  @override
Dan Field's avatar
Dan Field committed
198
  Rect get semanticBounds => const Rect.fromLTWH(0.0, 0.0, 10.0, 20.0);
199

200 201
  int describeSemanticsConfigurationCallCount = 0;

202
  @override
203 204 205
  void describeSemanticsConfiguration(SemanticsConfiguration config) {
    super.describeSemanticsConfiguration(config);
    config.isSemanticBoundary = true;
206
    describeSemanticsConfigurationCallCount++;
207
  }
208
}
209 210 211 212 213 214 215 216 217 218 219

class TestThrowingRenderObject extends RenderObject {
  @override
  void performLayout() {
    throw FlutterError('TestThrowingRenderObject does not support performLayout.');
  }

  @override
  void debugAssertDoesMeetConstraints() { }

  @override
220 221 222 223
  Rect get paintBounds {
    assert(false); // The test shouldn't call this.
    return Rect.zero;
  }
224 225 226 227 228

  @override
  void performResize() { }

  @override
229 230 231 232
  Rect get semanticBounds {
    assert(false); // The test shouldn't call this.
    return Rect.zero;
  }
233
}