Replace expect() with outOfTestExpect() in Analysis Server performance benchmark.

pkg/analysis_server/test/integration/integration_tests.dart

 // Copyright (c) 2014, 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 test.integration.analysis;
 
 import 'dart:async';
 import 'dart:collection';
 import 'dart:convert';
 import 'dart:io';
@@ skipping 22 matching lines @@
     optionalFields: {'result': anything, 'error': isRequestError});
 
 Matcher isListOf(Matcher elementMatcher) => new _ListOf(elementMatcher);
 
 Matcher isMapOf(Matcher keyMatcher, Matcher valueMatcher) =>
     new _MapOf(keyMatcher, valueMatcher);
 
 Matcher isOneOf(List<Matcher> choiceMatchers) => new _OneOf(choiceMatchers);
 
 /**
+ * Assert that [actual] matches [matcher].
+ */
+void outOfTestExpect(actual, matcher,
+    {String reason, skip, bool verbose: false}) {
+  var matchState = {};
+  try {
+    if (matcher.matches(actual, matchState)) return;
+  } catch (e, trace) {
+    if (reason == null) {
+      reason = '${(e is String) ? e : e.toString()} at $trace';
+    }
+  }
+  fail(_defaultFailFormatter(actual, matcher, reason, matchState, verbose));
+}
+
+String _defaultFailFormatter(
+    actual, Matcher matcher, String reason, Map matchState, bool verbose) {
+  var description = new StringDescription();
+  description.add('Expected: ').addDescriptionOf(matcher).add('\n');
+  description.add('  Actual: ').addDescriptionOf(actual).add('\n');
+
+  var mismatchDescription = new StringDescription();
+  matcher.describeMismatch(actual, mismatchDescription, matchState, verbose);
+
+  if (mismatchDescription.length > 0) {
+    description.add('   Which: $mismatchDescription\n');
+  }
+  if (reason != null) description.add(reason).add('\n');
+  return description.toString();
+}
+
+/**
  * Type of closures used by LazyMatcher.
  */
 typedef Matcher MatcherCreator();
 
 /**
  * Type of closures used by MatchesJsonObject to record field mismatches.
  */
 typedef Description MismatchDescriber(Description mismatchDescription);
 
 /**
@@ skipping 51 matching lines @@
    * The future will only be completed by 'server.status' notifications that are
    * received after this function call.  So it is safe to use this getter
    * multiple times in one test; each time it is used it will wait afresh for
    * analysis to finish.
    */
   Future get analysisFinished {
     Completer completer = new Completer();
     StreamSubscription subscription;
     // This will only work if the caller has already subscribed to
     // SERVER_STATUS (e.g. using sendServerSetSubscriptions(['STATUS']))
-    expect(_subscribedToServerStatus, isTrue);
+    outOfTestExpect(_subscribedToServerStatus, isTrue);
     subscription = onServerStatus.listen((ServerStatusParams params) {
       if (params.analysis != null && !params.analysis.isAnalyzing) {
         completer.complete(params);
         subscription.cancel();
       }
     });
     return completer.future;
   }
 
   /**
@@ skipping 15 matching lines @@
    * [sourceDirectory] is created.
    */
   Future setUp() {
     sourceDirectory = Directory.systemTemp.createTempSync('analysisServer');
 
     onAnalysisErrors.listen((AnalysisErrorsParams params) {
       currentAnalysisErrors[params.file] = params.errors;
     });
     Completer serverConnected = new Completer();
     onServerConnected.listen((_) {
-      expect(serverConnected.isCompleted, isFalse);
+      outOfTestExpect(serverConnected.isCompleted, isFalse);
       serverConnected.complete();
     });
     onServerError.listen((ServerErrorParams params) {
       // A server error should never happen during an integration test.
       fail('${params.message}\n${params.stackTrace}');
     });
     return startServer().then((_) {
       server.listenToOutput(dispatchNotification);
       server.exitCode.then((_) {
         skipShutdown = true;
@@ skipping 357 matching lines @@
         return;
       }
       _recordStdio('RECV: $trimmedLine');
       var message;
       try {
         message = JSON.decoder.convert(trimmedLine);
       } catch (exception) {
         _badDataFromServer('JSON decode failure: $exception');
         return;
       }
-      expect(message, isMap);
+      outOfTestExpect(message, isMap);
       Map messageAsMap = message;
       if (messageAsMap.containsKey('id')) {
-        expect(messageAsMap['id'], isString);
+        outOfTestExpect(messageAsMap['id'], isString);
         String id = message['id'];
         Completer completer = _pendingCommands[id];
         if (completer == null) {
           fail('Unexpected response from server: id=$id');
         } else {
           _pendingCommands.remove(id);
         }
         if (messageAsMap.containsKey('error')) {
           // TODO(paulberry): propagate the error info to the completer.
           completer.completeError(new UnimplementedError(
               'Server responded with an error: ${JSON.encode(message)}'));
         } else {
           completer.complete(messageAsMap['result']);
         }
         // Check that the message is well-formed.  We do this after calling
         // completer.complete() or completer.completeError() so that we don't
         // stall the test in the event of an error.
-        expect(message, isResponse);
+        outOfTestExpect(message, isResponse);
       } else {
         // Message is a notification.  It should have an event and possibly
         // params.
-        expect(messageAsMap, contains('event'));
-        expect(messageAsMap['event'], isString);
+        outOfTestExpect(messageAsMap, contains('event'));
+        outOfTestExpect(messageAsMap['event'], isString);
         notificationProcessor(messageAsMap['event'], messageAsMap['params']);
         // Check that the message is well-formed.  We do this after calling
         // notificationController.add() so that we don't stall the test in the
         // event of an error.
-        expect(message, isNotification);
+        outOfTestExpect(message, isNotification);
       }
     });
     _process.stderr
         .transform((new Utf8Codec()).decoder)
         .transform(new LineSplitter())
         .listen((String line) {
       String trimmedLine = line.trim();
       _recordStdio('ERR:  $trimmedLine');
       _badDataFromServer('Message received on stderr', silent: true);
     });
@@ skipping 350 matching lines @@
   void populateMismatches(item, List<MismatchDescriber> mismatches);
 
   /**
    * Create a [MismatchDescriber] describing a mismatch with a simple string.
    */
   MismatchDescriber simpleDescription(String description) =>
       (Description mismatchDescription) {
         mismatchDescription.add(description);
       };
 }