syncing_test.dart 5.09 KB
Newer Older
Hixie's avatar
Hixie committed
1 2 3 4
// Copyright 2015 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

5
import 'package:flutter/widgets.dart';
6 7
import 'package:test/test.dart';

Adam Barth's avatar
Adam Barth committed
8
import 'widget_tester.dart';
9

10 11 12 13 14 15 16 17 18 19 20
class TestWidget extends StatefulComponent {
  TestWidget({ this.child, this.persistentState, this.syncedState });

  final Widget child;
  final int persistentState;
  final int syncedState;

  TestWidgetState createState() => new TestWidgetState();
}

class TestWidgetState extends State<TestWidget> {
21 22
  int persistentState;
  int syncedState;
23 24
  int updates = 0;

25 26
  void initState() {
    super.initState();
27 28 29 30 31 32
    persistentState = config.persistentState;
    syncedState = config.syncedState;
  }

  void didUpdateConfig(TestWidget oldConfig) {
    syncedState = config.syncedState;
33
    // we explicitly do NOT sync the persistentState from the new instance
34
    // because we're using that to track whether we got recreated
35
    updates += 1;
36
  }
37 38

  Widget build(BuildContext context) => config.child;
39 40 41 42 43
}

void main() {

  test('no change', () {
44 45 46 47 48 49 50 51
    testWidgets((WidgetTester tester) {
      tester.pumpWidget(
        new Container(
          child: new Container(
            child: new TestWidget(
              persistentState: 1,
              child: new Container()
            )
52 53
          )
        )
54
      );
55

56
      TestWidgetState state = tester.findStateOfType(TestWidgetState);
57

58 59
      expect(state.persistentState, equals(1));
      expect(state.updates, equals(0));
60

61 62 63 64 65 66 67
      tester.pumpWidget(
        new Container(
          child: new Container(
            child: new TestWidget(
              persistentState: 2,
              child: new Container()
            )
68 69
          )
        )
70
      );
71

72 73
      expect(state.persistentState, equals(1));
      expect(state.updates, equals(1));
74

75 76
      tester.pumpWidget(new Container());
    });
77 78
  });

79
  test('remove one', () {
80 81 82 83 84 85 86 87
    testWidgets((WidgetTester tester) {
      tester.pumpWidget(
        new Container(
          child: new Container(
            child: new TestWidget(
              persistentState: 10,
              child: new Container()
            )
88 89
          )
        )
90
      );
91

92
      TestWidgetState state = tester.findStateOfType(TestWidgetState);
93

94 95
      expect(state.persistentState, equals(10));
      expect(state.updates, equals(0));
96

97 98 99 100 101 102
      tester.pumpWidget(
        new Container(
          child: new TestWidget(
            persistentState: 11,
            child: new Container()
          )
103
        )
104
      );
105

106
      state = tester.findStateOfType(TestWidgetState);
107

108 109
      expect(state.persistentState, equals(11));
      expect(state.updates, equals(0));
110

111 112
      tester.pumpWidget(new Container());
    });
113
  });
114

115
  test('swap instances around', () {
116 117 118
    testWidgets((WidgetTester tester) {
      Widget a = new TestWidget(persistentState: 0x61, syncedState: 0x41, child: new Text('apple'));
      Widget b = new TestWidget(persistentState: 0x62, syncedState: 0x42, child: new Text('banana'));
119
      tester.pumpWidget(new Column(<Widget>[]));
120 121 122 123 124

      GlobalKey keyA = new GlobalKey();
      GlobalKey keyB = new GlobalKey();

      tester.pumpWidget(
125
        new Column(<Widget>[
126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149
          new Container(
            key: keyA,
            child: a
          ),
          new Container(
            key: keyB,
            child: b
          )
        ])
      );

      TestWidgetState first, second;

      first = tester.findStateByConfig(a);
      second = tester.findStateByConfig(b);

      expect(first.config, equals(a));
      expect(first.persistentState, equals(0x61));
      expect(first.syncedState, equals(0x41));
      expect(second.config, equals(b));
      expect(second.persistentState, equals(0x62));
      expect(second.syncedState, equals(0x42));

      tester.pumpWidget(
150
        new Column(<Widget>[
151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176
          new Container(
            key: keyA,
            child: a
          ),
          new Container(
            key: keyB,
            child: b
          )
        ])
      );

      first = tester.findStateByConfig(a);
      second = tester.findStateByConfig(b);

      // same as before
      expect(first.config, equals(a));
      expect(first.persistentState, equals(0x61));
      expect(first.syncedState, equals(0x41));
      expect(second.config, equals(b));
      expect(second.persistentState, equals(0x62));
      expect(second.syncedState, equals(0x42));

      // now we swap the nodes over
      // since they are both "old" nodes, they shouldn't sync with each other even though they look alike

      tester.pumpWidget(
177
        new Column(<Widget>[
178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198
          new Container(
            key: keyA,
            child: b
          ),
          new Container(
            key: keyB,
            child: a
          )
        ])
      );

      first = tester.findStateByConfig(b);
      second = tester.findStateByConfig(a);

      expect(first.config, equals(b));
      expect(first.persistentState, equals(0x61));
      expect(first.syncedState, equals(0x42));
      expect(second.config, equals(a));
      expect(second.persistentState, equals(0x62));
      expect(second.syncedState, equals(0x41));
    });
199
  });
200
}