Fix analyzer warnings!

pkg/async/test/result_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 "dart:collection";
 import "package:async/result.dart";
 import "package:unittest/unittest.dart";
 
 void main() {
@@ skipping 19 matching lines @@
   test("create result error", () {
     Result<bool> result = new Result<bool>.error("BAD", stack);
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
     ErrorResult error = result.asError;
     expect(error.error, equals("BAD"));
     expect(error.stackTrace, same(stack));
   });
 
   test("create result error 2", () {
-    Result<bool> result = new ErrorResult<bool>("BAD", stack);
+    Result<bool> result = new ErrorResult("BAD", stack);
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
     ErrorResult error = result.asError;
     expect(error.error, equals("BAD"));
     expect(error.stackTrace, same(stack));
   });
 
   test("create result error no stack", () {
     Result<bool> result = new Result<bool>.error("BAD");
     expect(result.isValue, isFalse);
     expect(result.isError, isTrue);
     ErrorResult error = result.asError;
     expect(error.error, equals("BAD"));
     expect(error.stackTrace, isNull);
   });
 
   test("complete with value", () {
     Result<int> result = new ValueResult<int>(42);
     Completer c = new Completer<int>();
     c.future.then(expectAsync((int v) { expect(v, equals(42)); }),
                   onError: (e, s) { fail("Unexpected error"); });
     result.complete(c);
   });
 
   test("complete with error", () {
     Result<bool> result = new ErrorResult("BAD", stack);
     Completer c = new Completer<bool>();
-    c.future.then((bool v) { Expect.fail("Unexpected value $v"); },
+    c.future.then((bool v) { fail("Unexpected value $v"); },
                   onError: expectAsync((e, s) {
                     expect(e, equals("BAD"));
                     expect(s, same(stack));
                   }));
     result.complete(c);
   });
 
   test("add sink value", () {
     Result<int> result = new ValueResult<int>(42);
     EventSink<int> sink = new TestSink(
@@ skipping 14 matching lines @@
   });
 
   test("value as future", () {
     Result<int> result = new ValueResult<int>(42);
     result.asFuture.then(expectAsync((int v) { expect(v, equals(42)); }),
                          onError: (e, s) { fail("Unexpected error"); });
   });
 
   test("error as future", () {
     Result<bool> result = new ErrorResult("BAD", stack);
-    result.asFuture.then((bool v) { Expect.fail("Unexpected value $v"); },
+    result.asFuture.then((bool v) { fail("Unexpected value $v"); },
                          onError: expectAsync((e, s) {
                            expect(e, equals("BAD"));
                            expect(s, same(stack));
                          }));
   });
 
   test("capture future value", () {
     Future<int> value = new Future<int>.value(42);
     Result.capture(value).then(expectAsync((Result result) {
       expect(result.isValue, isTrue);
       expect(result.isError, isFalse);
       ValueResult value = result.asValue;
       expect(value.value, equals(42));
     }), onError: (e, s) {
-      Expect.fail("Unexpected error: $e");
+      fail("Unexpected error: $e");
     });
   });
 
   test("capture future error", () {
     Future<bool> value = new Future<bool>.error("BAD", stack);
     Result.capture(value).then(expectAsync((Result result) {
       expect(result.isValue, isFalse);
       expect(result.isError, isTrue);
       ErrorResult error = result.asError;
       expect(error.error, equals("BAD"));
       expect(error.stackTrace, same(stack));
     }), onError: (e, s) {
-      Expect.fail("Unexpected error: $e");
+      fail("Unexpected error: $e");
     });
   });
 
   test("release future value", () {
     Future<Result<int>> future =
         new Future<Result<int>>.value(new Result<int>.value(42));
     Result.release(future).then(expectAsync((v) {
       expect(v, equals(42));
     }), onError: (e, s) {
-      Expect.fail("Unexpected error: $e");
+      fail("Unexpected error: $e");
     });
   });
 
   test("release future error", () {
     // An error in the result is unwrapped and reified by release.
     Future<Result<bool>> future =
         new Future<Result<bool>>.value(new Result<bool>.error("BAD", stack));
     Result.release(future).then((v) {
-      Expect.fail("Unexpected value: $v");
+      fail("Unexpected value: $v");
     }, onError: expectAsync((e, s) {
       expect(e, equals("BAD"));
       expect(s, same(stack));
     }));
   });
 
   test("release future real error", () {
     // An error in the error lane is passed through by release.
     Future<Result<bool>> future = new Future<Result<bool>>.error("BAD", stack);
     Result.release(future).then((v) {
-      Expect.fail("Unexpected value: $v");
+      fail("Unexpected value: $v");
     }, onError: expectAsync((e, s) {
       expect(e, equals("BAD"));
       expect(s, same(stack));
     }));
   });
 
   test("capture stream", () {
     StreamController<int> c = new StreamController<int>();
     Stream<Result> stream = Result.captureStream(c.stream);
     var expectedList = new Queue.from([new Result.value(42),
@@ skipping 56 matching lines @@
                   cancelOnError: true);
     c.add(new Result.value(42));
     c.add(new Result.error("BAD", stack));
     c.add(new Result.value(37));
     c.close();
   });
 
 
   test("flatten error 1", () {
     Result<int> error = new Result<int>.error("BAD", stack);
-    Result<int> flattened = Result.flatten(error);
+    Result<int> flattened =
+        Result.flatten(new Result<Result<int>>.error(error));
     expectResult(flattened, error);
   });
 
   test("flatten error 2", () {
     Result<int> error = new Result<int>.error("BAD", stack);
     Result<Result<int>> result = new Result<Result<int>>.value(error);
     Result<int> flattened = Result.flatten(result);
     expectResult(flattened, error);
   });
 
@@ skipping 21 matching lines @@
   final Function onDone;
 
   TestSink({void this.onData(T data) : _nullData,
             void this.onError(e, StackTrace s) : _nullError,
             void this.onDone() : _nullDone });
 
   void add(T value) { onData(value); }
   void addError(error, [StackTrace stack]) { onError(error, stack); }
   void close() { onDone(); }
 
-  static void _nullData(value) { Expect.fail("Unexpected sink add: $value"); }
+  static void _nullData(value) { fail("Unexpected sink add: $value"); }
   static void _nullError(e, StackTrace s) {
-    Expect.fail("Unexpected sink addError: $e");
+    fail("Unexpected sink addError: $e");
   }
-  static void _nullDone() { Expect.fail("Unepxected sink close"); }
+  static void _nullDone() { fail("Unepxected sink close"); }
 }