package:observe fix various api issues

pkg/observe/test/observe_test.dart

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 import 'dart:async';
 import 'package:logging/logging.dart';
 import 'package:observe/observe.dart';
 import 'package:observe/src/dirty_check.dart' as dirty_check;
 import 'package:unittest/unittest.dart';
 import 'observe_test_utils.dart';
@@ skipping 43 matching lines @@
       expect(messages[0], contains('Possible loop'));
       expect(messages[1], contains('index 0'));
       expect(messages[1], contains('object: $x'));
 
       sub.cancel();
     });
   });
 }
 
 void _observeTests(createModel(x)) {
-  final watch = createModel(null) is! ChangeNotifierMixin;
+  final watch = createModel(null) is! ChangeNotifier;
 
   // Track the subscriptions so we can clean them up in tearDown.
   List subs;
 
   int initialObservers;
   setUp(() {
     initialObservers = dirty_check.allObservablesCount;
     subs = [];
 
     if (watch) scheduleMicrotask(Observable.dirtyCheck);
@@ skipping 27 matching lines @@
     subs.add(t.changes.listen((n) {}));
     expect(t.hasObservers, true);
   });
 
   observeTest('changes delived async', () {
     var t = createModel(123);
     int called = 0;
 
     subs.add(t.changes.listen(expectAsync1((records) {
       called++;
-      expectChanges(records, _changedValue(watch ? 1 : 2));
+      expectPropertyChanges(records, watch ? 1 : 2);
     })));
 
     t.value = 41;
     t.value = 42;
     expect(called, 0);
   });
 
   observeTest('cause changes in handler', () {
     var t = createModel(123);
     int called = 0;
 
     subs.add(t.changes.listen(expectAsync1((records) {
       called++;
-      expectChanges(records, _changedValue(1));
+      expectPropertyChanges(records, 1);
       if (called == 1) {
         // Cause another change
         t.value = 777;
       }
     }, count: 2)));
 
     t.value = 42;
   });
 
   observeTest('multiple observers', () {
     var t = createModel(123);
 
     verifyRecords(records) {
-      expectChanges(records, _changedValue(watch ? 1 : 2));
+      expectPropertyChanges(records, watch ? 1 : 2);
     };
 
     subs.add(t.changes.listen(expectAsync1(verifyRecords)));
     subs.add(t.changes.listen(expectAsync1(verifyRecords)));
 
     t.value = 41;
     t.value = 42;
   });
 
   observeTest('performMicrotaskCheckpoint', () {
     var t = createModel(123);
     var records = [];
     subs.add(t.changes.listen((r) { records.addAll(r); }));
     t.value = 41;
     t.value = 42;
     expectChanges(records, [], reason: 'changes delived async');
 
     performMicrotaskCheckpoint();
-    expectChanges(records, _changedValue(watch ? 1 : 2));
+    expectPropertyChanges(records, watch ? 1 : 2);
     records.clear();
 
     t.value = 777;
     expectChanges(records, [], reason: 'changes delived async');
 
     performMicrotaskCheckpoint();
-    expectChanges(records, _changedValue(1));
+    expectPropertyChanges(records, 1);
 
     // Has no effect if there are no changes
     performMicrotaskCheckpoint();
-    expectChanges(records, _changedValue(1));
+    expectPropertyChanges(records, 1);
   });
 
   observeTest('cancel listening', () {
     var t = createModel(123);
     var sub;
     sub = t.changes.listen(expectAsync1((records) {
-      expectChanges(records, _changedValue(1));
+      expectPropertyChanges(records, 1);
       sub.cancel();
       t.value = 777;
       scheduleMicrotask(Observable.dirtyCheck);
     }));
     t.value = 42;
   });
 
   observeTest('cancel and reobserve', () {
     var t = createModel(123);
     var sub;
     sub = t.changes.listen(expectAsync1((records) {
-      expectChanges(records, _changedValue(1));
+      expectPropertyChanges(records, 1);
       sub.cancel();
 
       scheduleMicrotask(expectAsync0(() {
         subs.add(t.changes.listen(expectAsync1((records) {
-          expectChanges(records, _changedValue(1));
+          expectPropertyChanges(records, 1);
         })));
         t.value = 777;
         scheduleMicrotask(Observable.dirtyCheck);
       }));
     }));
     t.value = 42;
   });
 
   observeTest('cannot modify changes list', () {
     var t = createModel(123);
     var records = null;
     subs.add(t.changes.listen((r) { records = r; }));
     t.value = 42;
 
     performMicrotaskCheckpoint();
-    expectChanges(records, _changedValue(1));
+    expectPropertyChanges(records, 1);
 
     // Verify that mutation operations on the list fail:
 
     expect(() {
-      records[0] = new PropertyChangeRecord(#value);
+      records[0] = new PropertyChangeRecord(t, #value, 0, 1);
     }, throwsUnsupportedError);
 
     expect(() { records.clear(); }, throwsUnsupportedError);
 
     expect(() { records.length = 0; }, throwsUnsupportedError);
   });
 
   observeTest('notifyChange', () {
     var t = createModel(123);
     var records = [];
     subs.add(t.changes.listen((r) { records.addAll(r); }));
-    t.notifyChange(new PropertyChangeRecord(#value));
+    t.notifyChange(new PropertyChangeRecord(t, #value, 123, 42));
 
     performMicrotaskCheckpoint();
-    expectChanges(records, _changedValue(1));
+    expectPropertyChanges(records, 1);
     expect(t.value, 123, reason: 'value did not actually change.');
   });
 
   observeTest('notifyPropertyChange', () {
     var t = createModel(123);
     var records = null;
     subs.add(t.changes.listen((r) { records = r; }));
     expect(t.notifyPropertyChange(#value, t.value, 42), 42,
         reason: 'notifyPropertyChange returns newValue');
 
     performMicrotaskCheckpoint();
-    expectChanges(records, _changedValue(1));
+    expectPropertyChanges(records, 1);
     expect(t.value, 123, reason: 'value did not actually change.');
   });
 }
 
-_changedValue(len) => new List.filled(len, new PropertyChangeRecord(#value));
+expectPropertyChanges(records, int number) {
+  expect(records.length, number, reason: 'expected $number change records');
+  for (var record in records) {
+    expect(record is PropertyChangeRecord, true, reason:
+        'record should be PropertyChangeRecord');
+    expect((record as PropertyChangeRecord).name, #value, reason:
+        'record should indicate a change to the "value" property');
+  }
+}
 
 // A test model based on dirty checking.
-class WatcherModel<T> extends ObservableBase {
+class WatcherModel<T> extends Observable {
   @observable T value;
 
   WatcherModel([T initialValue]) : value = initialValue;
 
   String toString() => '#<$runtimeType value: $value>';
 }
 
 class ModelSubclass<T> extends WatcherModel<T> {
   ModelSubclass([T initialValue]) : super(initialValue);
 }