change_notifier_test.dart 9.33 KB
Newer Older
1
// Copyright 2016 The Chromium Authors. All rights reserved.
2 3 4 5 6 7 8 9 10 11
// 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_test/flutter_test.dart';

class TestNotifier extends ChangeNotifier {
  void notify() {
    notifyListeners();
  }
12 13

  bool get isListenedTo => hasListeners;
14 15
}

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33
class HasListenersTester<T> extends ValueNotifier<T> {
  HasListenersTester(T value) : super(value);
  bool get testHasListeners => hasListeners;
}

class A {
  bool result = false;
  void test() { result = true; }
}

class B extends A with ChangeNotifier {
  @override
  void test() {
    notifyListeners();
    super.test();
  }
}

34 35 36 37 38 39 40 41
void main() {
  testWidgets('ChangeNotifier', (WidgetTester tester) async {
    final List<String> log = <String>[];
    final VoidCallback listener = () { log.add('listener'); };
    final VoidCallback listener1 = () { log.add('listener1'); };
    final VoidCallback listener2 = () { log.add('listener2'); };
    final VoidCallback badListener = () { log.add('badListener'); throw null; };

42
    final TestNotifier test = TestNotifier();
43 44 45 46

    test.addListener(listener);
    test.addListener(listener);
    test.notify();
47
    expect(log, <String>['listener', 'listener']);
48 49 50 51
    log.clear();

    test.removeListener(listener);
    test.notify();
52
    expect(log, <String>['listener']);
53 54 55 56
    log.clear();

    test.removeListener(listener);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
57
    expect(log, <String>[]);
58 59 60 61
    log.clear();

    test.removeListener(listener);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
62
    expect(log, <String>[]);
63 64 65 66
    log.clear();

    test.addListener(listener);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
67
    expect(log, <String>['listener']);
68 69 70 71
    log.clear();

    test.addListener(listener1);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
72
    expect(log, <String>['listener', 'listener1']);
73 74 75 76
    log.clear();

    test.addListener(listener2);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
77
    expect(log, <String>['listener', 'listener1', 'listener2']);
78 79 80 81
    log.clear();

    test.removeListener(listener1);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
82
    expect(log, <String>['listener', 'listener2']);
83 84 85 86
    log.clear();

    test.addListener(listener1);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
87
    expect(log, <String>['listener', 'listener2', 'listener1']);
88 89 90 91
    log.clear();

    test.addListener(badListener);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
92
    expect(log, <String>['listener', 'listener2', 'listener1', 'badListener']);
93 94 95 96 97 98 99 100 101
    expect(tester.takeException(), isNullThrownError);
    log.clear();

    test.addListener(listener1);
    test.removeListener(listener);
    test.removeListener(listener1);
    test.removeListener(listener2);
    test.addListener(listener2);
    test.notify();
102
    expect(log, <String>['badListener', 'listener1', 'listener2']);
103 104
    expect(tester.takeException(), isNullThrownError);
    log.clear();
105
  }, skip: isBrowser);
106

107
  test('ChangeNotifier with mutating listener', () {
108
    final TestNotifier test = TestNotifier();
109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124
    final List<String> log = <String>[];

    final VoidCallback listener1 = () { log.add('listener1'); };
    final VoidCallback listener3 = () { log.add('listener3'); };
    final VoidCallback listener4 = () { log.add('listener4'); };
    final VoidCallback listener2 = () {
      log.add('listener2');
      test.removeListener(listener1);
      test.removeListener(listener3);
      test.addListener(listener4);
    };

    test.addListener(listener1);
    test.addListener(listener2);
    test.addListener(listener3);
    test.notify();
Ian Hickson's avatar
Ian Hickson committed
125
    expect(log, <String>['listener1', 'listener2']);
126 127 128
    log.clear();

    test.notify();
Ian Hickson's avatar
Ian Hickson committed
129
    expect(log, <String>['listener2', 'listener4']);
130 131 132
    log.clear();

    test.notify();
133
    expect(log, <String>['listener2', 'listener4', 'listener4']);
Ian Hickson's avatar
Ian Hickson committed
134 135 136
    log.clear();
  });

137
  test('Merging change notifiers', () {
138 139 140
    final TestNotifier source1 = TestNotifier();
    final TestNotifier source2 = TestNotifier();
    final TestNotifier source3 = TestNotifier();
Ian Hickson's avatar
Ian Hickson committed
141 142
    final List<String> log = <String>[];

143
    final Listenable merged = Listenable.merge(<Listenable>[source1, source2]);
144 145
    final VoidCallback listener1 = () { log.add('listener1'); };
    final VoidCallback listener2 = () { log.add('listener2'); };
Ian Hickson's avatar
Ian Hickson committed
146

147
    merged.addListener(listener1);
Ian Hickson's avatar
Ian Hickson committed
148 149 150
    source1.notify();
    source2.notify();
    source3.notify();
151
    expect(log, <String>['listener1', 'listener1']);
Ian Hickson's avatar
Ian Hickson committed
152 153
    log.clear();

154
    merged.removeListener(listener1);
Ian Hickson's avatar
Ian Hickson committed
155 156 157 158
    source1.notify();
    source2.notify();
    source3.notify();
    expect(log, isEmpty);
159
    log.clear();
160 161 162 163 164 165 166 167 168 169

    merged.addListener(listener1);
    merged.addListener(listener2);
    source1.notify();
    source2.notify();
    source3.notify();
    expect(log, <String>['listener1', 'listener2', 'listener1', 'listener2']);
    log.clear();
  });

170
  test('Merging change notifiers ignores null', () {
171 172
    final TestNotifier source1 = TestNotifier();
    final TestNotifier source2 = TestNotifier();
173 174
    final List<String> log = <String>[];

175
    final Listenable merged = Listenable.merge(<Listenable>[null, source1, null, source2, null]);
176 177 178 179 180 181 182
    final VoidCallback listener = () { log.add('listener'); };

    merged.addListener(listener);
    source1.notify();
    source2.notify();
    expect(log, <String>['listener', 'listener']);
    log.clear();
183
  });
184

185
  test('Can remove from merged notifier', () {
186 187
    final TestNotifier source1 = TestNotifier();
    final TestNotifier source2 = TestNotifier();
188 189
    final List<String> log = <String>[];

190
    final Listenable merged = Listenable.merge(<Listenable>[source1, source2]);
191 192 193 194 195 196 197 198
    final VoidCallback listener = () { log.add('listener'); };

    merged.addListener(listener);
    source1.notify();
    source2.notify();
    expect(log, <String>['listener', 'listener']);
    log.clear();

199
    merged.removeListener(listener);
200 201 202 203
    source1.notify();
    source2.notify();
    expect(log, isEmpty);
  });
204 205

  test('Cannot use a disposed ChangeNotifier', () {
206
    final TestNotifier source = TestNotifier();
207 208 209 210 211 212
    source.dispose();
    expect(() { source.addListener(null); }, throwsFlutterError);
    expect(() { source.removeListener(null); }, throwsFlutterError);
    expect(() { source.dispose(); }, throwsFlutterError);
    expect(() { source.notify(); }, throwsFlutterError);
  });
Adam Barth's avatar
Adam Barth committed
213 214

  test('Value notifier', () {
215
    final ValueNotifier<double> notifier = ValueNotifier<double>(2.0);
Adam Barth's avatar
Adam Barth committed
216 217 218 219 220 221 222 223 224 225 226 227 228

    final List<double> log = <double>[];
    final VoidCallback listener = () { log.add(notifier.value); };

    notifier.addListener(listener);
    notifier.value = 3.0;

    expect(log, equals(<double>[ 3.0 ]));
    log.clear();

    notifier.value = 3.0;
    expect(log, isEmpty);
  });
229 230

  test('Listenable.merge toString', () {
231 232
    final TestNotifier source1 = TestNotifier();
    final TestNotifier source2 = TestNotifier();
233

234
    Listenable listenableUnderTest = Listenable.merge(<Listenable>[]);
235 236
    expect(listenableUnderTest.toString(), 'Listenable.merge([])');

237
    listenableUnderTest = Listenable.merge(<Listenable>[null]);
238 239
    expect(listenableUnderTest.toString(), 'Listenable.merge([null])');

240
    listenableUnderTest = Listenable.merge(<Listenable>[source1]);
241
    expect(
242
      listenableUnderTest.toString(),
243 244 245
      "Listenable.merge([Instance of 'TestNotifier'])",
    );

246
    listenableUnderTest = Listenable.merge(<Listenable>[source1, source2]);
247
    expect(
248
      listenableUnderTest.toString(),
249 250 251
      "Listenable.merge([Instance of 'TestNotifier', Instance of 'TestNotifier'])",
    );

252
    listenableUnderTest = Listenable.merge(<Listenable>[null, source2]);
253
    expect(
254
      listenableUnderTest.toString(),
255 256 257
      "Listenable.merge([null, Instance of 'TestNotifier'])",
    );
  });
258

259 260 261 262 263
  test('Listenable.merge does not leak', () {
    // Regression test for https://github.com/flutter/flutter/issues/25163.

    final TestNotifier source1 = TestNotifier();
    final TestNotifier source2 = TestNotifier();
264
    final VoidCallback fakeListener = () { };
265 266 267 268 269 270 271 272 273 274 275 276 277 278

    final Listenable listenableUnderTest = Listenable.merge(<Listenable>[source1, source2]);
    expect(source1.isListenedTo, isFalse);
    expect(source2.isListenedTo, isFalse);
    listenableUnderTest.addListener(fakeListener);
    expect(source1.isListenedTo, isTrue);
    expect(source2.isListenedTo, isTrue);

    listenableUnderTest.removeListener(fakeListener);
    expect(source1.isListenedTo, isFalse);
    expect(source2.isListenedTo, isFalse);
  });


279
  test('hasListeners', () {
280
    final HasListenersTester<bool> notifier = HasListenersTester<bool>(true);
281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301
    expect(notifier.testHasListeners, isFalse);
    void test1() { }
    void test2() { }
    notifier.addListener(test1);
    expect(notifier.testHasListeners, isTrue);
    notifier.addListener(test1);
    expect(notifier.testHasListeners, isTrue);
    notifier.removeListener(test1);
    expect(notifier.testHasListeners, isTrue);
    notifier.removeListener(test1);
    expect(notifier.testHasListeners, isFalse);
    notifier.addListener(test1);
    expect(notifier.testHasListeners, isTrue);
    notifier.addListener(test2);
    expect(notifier.testHasListeners, isTrue);
    notifier.removeListener(test1);
    expect(notifier.testHasListeners, isTrue);
    notifier.removeListener(test2);
    expect(notifier.testHasListeners, isFalse);
  });

302 303 304 305 306 307 308 309 310 311 312 313 314
  test('ChangeNotifier as a mixin', () {
    // We document that this is a valid way to use this class.
    final B b = B();
    int notifications = 0;
    b.addListener(() {
      notifications += 1;
    });
    expect(b.result, isFalse);
    expect(notifications, 0);
    b.test();
    expect(b.result, isTrue);
    expect(notifications, 1);
  });
315
}