Add handle method to ErrorResult.

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:stack_trace/stack_trace.dart";
 import "package:test/test.dart";
@@ skipping 239 matching lines @@
     Result<Result<int>> result = new Result<Result<int>>.value(error);
     Result<int> flattened = Result.flatten(result);
     expectResult(flattened, error);
   });
 
   test("flatten value", () {
     Result<Result<int>> result =
         new Result<Result<int>>.value(new Result<int>.value(42));
     expectResult(Result.flatten(result), new Result<int>.value(42));
   });
+
+  test("handle unary", () {
+    var result = new Result.error("error", stack);
+    bool called = false;
+    result.handle((error) {
+      called = true;
+      expect(error, "error");
+    });
+    expect(called, isTrue);
+  });
+
+  test("handle binary", () {
+    var result = new Result.error("error", stack);
+    bool called = false;
+    result.handle((error, stackTrace) {
+      called = true;
+      expect(error, "error");
+      expect(stackTrace, same(stack));
+    });
+    expect(called, isTrue);
+  });
+
+  test("handle unary and binary", () {
+    var result = new Result.error("error", stack);
+    bool called = false;
+    result.handle((error, [stackTrace]) {
+      called = true;
+      expect(error, "error");
+      expect(stackTrace, same(stack));
+    });
+    expect(called, isTrue);
+  });
+
+  test("handle neither unary nor binary", () {
+    var result = new Result.error("error", stack);
+    expect(() => result.handle(() => fail("unreachable")),
+           throws);
+    expect(() => result.handle((a, b, c) => fail("unreachable")),
+           throws);
+    expect(() => result.handle((a, b, {c}) => fail("unreachable")),
+           throws);
+    expect(() => result.handle((a, {b}) => fail("unreachable")),
+           throws);
+    expect(() => result.handle(({a, b}) => fail("unreachable")),
+           throws);
+    expect(() => result.handle(({a}) => fail("unreachable")),
+           throws);
+  });
 }
 
 void expectResult(Result actual, Result expected) {
   expect(actual.isValue, equals(expected.isValue));
   expect(actual.isError, equals(expected.isError));
   if (actual.isValue) {
     expect(actual.asValue.value, equals(expected.asValue.value));
   } else {
     expect(actual.asError.error, equals(expected.asError.error));
     expect(actual.asError.stackTrace, same(expected.asError.stackTrace));
@@ skipping 12 matching lines @@
   void add(T value) { onData(value); }
   void addError(error, [StackTrace stack]) { onError(error, stack); }
   void close() { onDone(); }
 
   static void _nullData(value) { fail("Unexpected sink add: $value"); }
   static void _nullError(e, StackTrace s) {
     fail("Unexpected sink addError: $e");
   }
   static void _nullDone() { fail("Unepxected sink close"); }
 }