pkg/observe: wrapMicrotask should return the result the provided testCase

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';
 
 // Note: this ensures we run the dartanalyzer on the @observe package.
 // @static-clean
 
 const _VALUE = const Symbol('value');
 
-main() {
+void main() {
   // Note: to test the basic Observable system, we use ObservableBox due to its
   // simplicity. We also test a variant that is based on dirty-checking.
 
   observeTest('no observers at the start', () {
     expect(dirty_check.allObservablesCount, 0);
   });
 
-  group('WatcherModel', () { observeTests(watch: true); });
+  group('WatcherModel', () { _observeTests(watch: true); });
 
-  group('ObservableBox', () { observeTests(); });
+  group('ObservableBox', () { _observeTests(); });
 
   group('dirtyCheck loops can be debugged', () {
     var messages;
     var subscription;
     setUp(() {
       messages = [];
       subscription = Logger.root.onRecord.listen((record) {
         messages.add(record.message);
       });
     });
@@ skipping 15 matching lines @@
 
       expect(messages[0], contains('Possible loop'));
       expect(messages[1], contains('index 0'));
       expect(messages[1], contains('object: $x'));
 
       sub.cancel();
     });
   });
 }
 
-observeTests({bool watch: false}) {
-
+void _observeTests({bool watch: false}) {
   final createModel = watch ? (x) => new WatcherModel(x)
       : (x) => new ObservableBox(x);
 
   // Track the subscriptions so we can clean them up in tearDown.
   List subs;
 
   int initialObservers;
   setUp(() {
     initialObservers = dirty_check.allObservablesCount;
     subs = [];
 
     if (watch) runAsync(Observable.dirtyCheck);
   });
 
   tearDown(() {
     for (var sub in subs) sub.cancel();
     performMicrotaskCheckpoint();
 
     expect(dirty_check.allObservablesCount, initialObservers,
         reason: 'Observable object leaked');
   });
 
+  observeTest('handle future result', () {
+    var callback = expectAsync0((){});
+    return new Future(callback);
+  });
+
   observeTest('no observers', () {
     var t = createModel(123);
     expect(t.value, 123);
     t.value = 42;
     expect(t.value, 42);
     expect(t.hasObservers, false);
   });
 
   observeTest('listen adds an observer', () {
     var t = createModel(123);
@@ skipping 147 matching lines @@
 _changedValue(len) => new List.filled(len, new PropertyChangeRecord(_VALUE));
 
 // A test model based on dirty checking.
 class WatcherModel<T> extends ObservableBase {
   @observable T value;
 
   WatcherModel([T initialValue]) : value = initialValue;
 
   String toString() => '#<$runtimeType value: $value>';
 }