Rename "description" to "failure" in the scheduled_test stream matchers.

pkg/scheduled_test/lib/src/stream_matcher.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.
 
 library scheduled_test.stream_matcher;
 
 import 'dart:async';
 import 'dart:collection';
 
 import '../scheduled_stream.dart';
@@ skipping 122 matching lines @@
       return stream.hasNext.then((hasNext) {
         if (!hasNext) return new StringDescription('unexpected end of stream');
 
         return stream.next().then((value) {
           collectedValues.add(value);
           return collectValues(count - 1);
         });
       });
     }
 
-    return collectValues(_n).then((description) {
-      if (description != null) return description;
+    return collectValues(_n).then((failure) {
+      if (failure != null) return failure;
       var matchState = {};
       if (_matcher.matches(collectedValues, matchState)) return null;
       return _matcher.describeMismatch(collectedValues, new StringDescription(),
           matchState, false);
     });
   }
 
   String toString() {
     return new StringDescription('$_n values that ')
         .addDescriptionOf(_matcher)
         .toString();
   }
 }
 
 /// See [inOrder].
 class _InOrderMatcher implements StreamMatcher {
   final List<StreamMatcher> _matchers;
 
   _InOrderMatcher(Iterable streamMatchers)
       : _matchers = streamMatchers.map((matcher) =>
           new StreamMatcher.wrap(matcher)).toList();
 
   Future<Description> tryMatch(ScheduledStream stream) {
     var matchers = new Queue.from(_matchers);
 
     matchNext() {
       if (matchers.isEmpty) return new Future.value();
       var matcher = matchers.removeFirst();
-      return matcher.tryMatch(stream).then((description) {
-        if (description == null) return matchNext();
-        var newDescription = new StringDescription(
+      return matcher.tryMatch(stream).then((failure) {
+        if (failure == null) return matchNext();
+        var newFailure = new StringDescription(
               'matcher #${_matchers.length - matchers.length} failed');
-        if (description.length != 0) newDescription.add(':\n$description');
-        return newDescription;
+        if (failure.length != 0) newFailure.add(':\n$failure');
+        return newFailure;
       });
     }
 
     return matchNext();
   }
 
   String toString() => _matchers
       .map((matcher) => prefixLines(matcher.toString(), firstPrefix: '* '))
       .join('\n');
 }
@@ skipping 35 matching lines @@
       : _matcher1 = new StreamMatcher.wrap(streamMatcher1),
         _matcher2 = new StreamMatcher.wrap(streamMatcher2);
 
   Future<Description> tryMatch(ScheduledStream stream) {
     var stream1 = stream.fork();
     var stream2 = stream.fork();
 
     return Future.wait([
       _matcher1.tryMatch(stream1).whenComplete(stream1.close),
       _matcher2.tryMatch(stream2).whenComplete(stream2.close)
-    ]).then((descriptions) {
-      var description1 = descriptions.first;
-      var description2 = descriptions.last;
+    ]).then((failures) {
+      var failure1 = failures.first;
+      var failure2 = failures.last;
 
       // If both matchers matched, use the one that consumed more of the stream.
-      if (description1 == null && description2 == null) {
+      if (failure1 == null && failure2 == null) {
         if (stream1.emittedValues.length >= stream2.emittedValues.length) {
           return _matcher1.tryMatch(stream);
         } else {
           return _matcher2.tryMatch(stream);
         }
-      } else if (description1 == null) {
+      } else if (failure1 == null) {
         return _matcher1.tryMatch(stream);
-      } else if (description2 == null) {
+      } else if (failure2 == null) {
         return _matcher2.tryMatch(stream);
       } else {
         return new StringDescription('both\n')
-            .add(prefixLines(description1.toString(), prefix: '  '))
+            .add(prefixLines(failure1.toString(), prefix: '  '))
             .add('\nand\n')
-            .add(prefixLines(description2.toString(), prefix: '  '))
+            .add(prefixLines(failure2.toString(), prefix: '  '))
             .toString();
       }
     });
   }
 
   String toString() {
     return new StringDescription('either\n')
         .add(prefixLines(_matcher1.toString(), prefix: '  '))
         .add('\nor\n')
         .add(prefixLines(_matcher2.toString(), prefix: '  '))
         .toString();
   }
 }
 
 /// See [allow].
 class _AllowMatcher implements StreamMatcher {
   final StreamMatcher _matcher;
 
   _AllowMatcher(streamMatcher)
       : _matcher = new StreamMatcher.wrap(streamMatcher);
 
   Future<Description> tryMatch(ScheduledStream stream) {
     var fork = stream.fork();
-    return _matcher.tryMatch(fork).whenComplete(fork.close).then((description) {
-      if (description != null) return null;
+    return _matcher.tryMatch(fork).whenComplete(fork.close).then((failure) {
+      if (failure != null) return null;
       return _matcher.tryMatch(stream);
     });
   }
 
   String toString() {
     return new StringDescription('allow\n')
         .add(prefixLines(_matcher.toString()))
         .toString();
   }
 }
 
 /// See [never].
 class _NeverMatcher implements StreamMatcher {
   final StreamMatcher _matcher;
 
   _NeverMatcher(streamMatcher)
       : _matcher = new StreamMatcher.wrap(streamMatcher);
 
   Future<Description> tryMatch(ScheduledStream stream) {
     consumeNext() {
       return stream.hasNext.then((hasNext) {
         if (!hasNext) return new Future.value();
 
         var fork = stream.fork();
         return _matcher.tryMatch(fork).whenComplete(fork.close)
-            .then((description) {
-          if (description != null) {
+            .then((failure) {
+          if (failure != null) {
             return stream.next().then((_) => consumeNext());
           }
 
           return new StringDescription("matched\n")
               .add(prefixLines(_matcher.toString(), prefix: '  '));
         });
       });
     }
 
     return consumeNext();
   }
 
   String toString() =>
     'never\n${prefixLines(_matcher.toString(), prefix: '  ')}';
 }
 
 /// See [isDone].
 class _IsDoneMatcher implements StreamMatcher {
   _IsDoneMatcher();
 
   Future<Description> tryMatch(ScheduledStream stream) {
     return stream.hasNext.then((hasNext) {
       if (!hasNext) return null;
       return new StringDescription("stream wasn't finished");
     });
   }
 
   String toString() => 'is done';
 }