memory_allocations_test.dart 3.81 KB
Newer Older
1 2 3 4 5 6 7 8
// Copyright 2014 The Flutter Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

import 'package:flutter/foundation.dart';
import 'package:flutter/widgets.dart';
import 'package:flutter_test/flutter_test.dart';

9 10 11
    int _creations = 0;
    int _disposals = 0;

12 13 14 15
void main() {
  final MemoryAllocations ma = MemoryAllocations.instance;

  test('Publishers dispatch events in debug mode', () async {
16 17 18 19 20 21 22 23
    void listener(ObjectEvent event) {
      if (event is ObjectDisposed) {
        _disposals++;
      }
      if (event is ObjectCreated) {
        _creations++;
      }
    }
24 25
    ma.addListener(listener);

26 27 28
    final _EventStats actual = await _activateFlutterObjectsAndReturnCountOfEvents();
    expect(actual.creations, _creations);
    expect(actual.disposals, _disposals);
29 30 31 32 33 34 35 36 37

    ma.removeListener(listener);
    expect(ma.hasListeners, isFalse);
  });

  testWidgets('State dispatches events in debug mode', (WidgetTester tester) async {
    bool stateCreated = false;
    bool stateDisposed = false;

38 39
    expect(ma.hasListeners, false);

40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57
    void listener(ObjectEvent event) {
      if (event is ObjectCreated && event.object is State) {
        stateCreated = true;
      }
      if (event is ObjectDisposed && event.object is State) {
        stateDisposed = true;
      }
    }
    ma.addListener(listener);

    await tester.pumpWidget(const _TestStatefulWidget());
    expect(stateCreated, isTrue);
    expect(stateDisposed, isFalse);
    await tester.pumpWidget(const SizedBox.shrink());

    expect(stateCreated, isTrue);
    expect(stateDisposed, isTrue);
    ma.removeListener(listener);
58
    expect(ma.hasListeners, false);
59 60 61 62 63 64 65 66 67 68
  });
}

class _TestLeafRenderObjectWidget extends LeafRenderObjectWidget {
  @override
  RenderObject createRenderObject(BuildContext context) {
    return _TestRenderObject();
  }
}

69
class _TestElement extends RenderObjectElement with RootElementMixin {
70 71 72
  _TestElement(): super(_TestLeafRenderObjectWidget());

  void makeInactive() {
73 74
    final FocusManager newFocusManager = FocusManager();
    assignOwner(BuildOwner(focusManager: newFocusManager));
75 76 77
    mount(null, null);
    deactivate();
  }
78 79 80 81 82 83 84 85 86

  @override
  void insertRenderObjectChild(covariant RenderObject child, covariant Object? slot) { }

  @override
  void moveRenderObjectChild(covariant RenderObject child, covariant Object? oldSlot, covariant Object? newSlot) { }

  @override
  void removeRenderObjectChild(covariant RenderObject child, covariant Object? slot) { }
87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120
}

class _TestRenderObject extends RenderObject {
  @override
  void debugAssertDoesMeetConstraints() {}

  @override
  Rect get paintBounds => throw UnimplementedError();

  @override
  void performLayout() {}

  @override
  void performResize() {}

  @override
  Rect get semanticBounds => throw UnimplementedError();
}


class _TestStatefulWidget extends StatefulWidget {
  const _TestStatefulWidget();

  @override
  State<_TestStatefulWidget> createState() => _TestStatefulWidgetState();
}

class _TestStatefulWidgetState extends State<_TestStatefulWidget> {
  @override
  Widget build(BuildContext context) {
    return Container();
  }
}

121 122 123 124 125 126

class _EventStats {
  int creations = 0;
  int disposals = 0;
}

127
/// Create and dispose Flutter objects to fire memory allocation events.
128 129
Future<_EventStats> _activateFlutterObjectsAndReturnCountOfEvents() async {
  final _EventStats result = _EventStats();
130

131 132
  final _TestElement element = _TestElement(); result.creations++;
  final RenderObject renderObject = _TestRenderObject(); result.creations++;
133

134 135 136
  element.makeInactive(); result.creations += 3; // 1 for the new BuildOwner, 1 for the new FocusManager, 1 for the new FocusScopeNode
  element.unmount(); result.disposals += 2; // 1 for the old BuildOwner, 1 for the element
  renderObject.dispose(); result.disposals += 1;
137

138
  return result;
139
}