syncing_test.dart 5.06 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.

Adam Barth's avatar
Adam Barth committed
5
import 'package:flutter_test/flutter_test.dart';
6
import 'package:flutter/widgets.dart';
7

8
class TestWidget extends StatefulWidget {
9 10 11 12 13 14
  TestWidget({ this.child, this.persistentState, this.syncedState });

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

15
  @override
16 17 18 19
  TestWidgetState createState() => new TestWidgetState();
}

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

24
  @override
25 26
  void initState() {
    super.initState();
27 28 29 30
    persistentState = config.persistentState;
    syncedState = config.syncedState;
  }

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

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

void main() {

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

57
    final TestWidgetState state = tester.state(find.byType(TestWidget));
58

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

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

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

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

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

91
    TestWidgetState state = tester.state(find.byType(TestWidget));
92

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

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

105
    state = tester.state(find.byType(TestWidget));
106

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

110
    await tester.pumpWidget(new Container());
111
  });
112

113
  testWidgets('swap instances around', (WidgetTester tester) async {
114 115
    final Widget a = new TestWidget(persistentState: 0x61, syncedState: 0x41, child: new Text('apple'));
    final Widget b = new TestWidget(persistentState: 0x62, syncedState: 0x42, child: new Text('banana'));
116
    await tester.pumpWidget(new Column());
117

118 119
    final GlobalKey keyA = new GlobalKey();
    final GlobalKey keyB = new GlobalKey();
120

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

    TestWidgetState first, second;

    first = tester.state(find.byConfig(a));
    second = tester.state(find.byConfig(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));

148
    await tester.pumpWidget(
149 150 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 Column(
        children: <Widget>[
          new Container(
            key: keyA,
            child: a
          ),
          new Container(
            key: keyB,
            child: b
          )
        ]
      )
    );

    first = tester.state(find.byConfig(a));
    second = tester.state(find.byConfig(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

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

    first = tester.state(find.byConfig(b));
    second = tester.state(find.byConfig(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));
201
  });
202
}