change_notifier_test.dart 9.35 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
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'); };
40 41 42 43
    final VoidCallback badListener = () {
      log.add('badListener');
      throw null;
    };
44

45
    final TestNotifier test = TestNotifier();
46 47 48 49

    test.addListener(listener);
    test.addListener(listener);
    test.notify();
50
    expect(log, <String>['listener', 'listener']);
51 52 53 54
    log.clear();

    test.removeListener(listener);
    test.notify();
55
    expect(log, <String>['listener']);
56 57 58 59
    log.clear();

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

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

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

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

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

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

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

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

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

110
  test('ChangeNotifier with mutating listener', () {
111
    final TestNotifier test = TestNotifier();
112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
    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
128
    expect(log, <String>['listener1', 'listener2']);
129 130 131
    log.clear();

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

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

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

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

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

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

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

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

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

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

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

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

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

202
    merged.removeListener(listener);
203 204 205 206
    source1.notify();
    source2.notify();
    expect(log, isEmpty);
  });
207 208

  test('Cannot use a disposed ChangeNotifier', () {
209
    final TestNotifier source = TestNotifier();
210 211 212 213 214 215
    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
216 217

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

    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);
  });
232 233

  test('Listenable.merge toString', () {
234 235
    final TestNotifier source1 = TestNotifier();
    final TestNotifier source2 = TestNotifier();
236

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

240
    listenableUnderTest = Listenable.merge(<Listenable>[null]);
241 242
    expect(listenableUnderTest.toString(), 'Listenable.merge([null])');

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

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

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

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

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

    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);
  });


282
  test('hasListeners', () {
283
    final HasListenersTester<bool> notifier = HasListenersTester<bool>(true);
284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304
    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);
  });

305 306 307 308 309 310 311 312 313 314 315 316 317
  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);
  });
318
}