Specialize message for parts as entry point

tests/compiler/dart2js/diagnostic_helper.dart

 // Copyright (c) 2015, 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 dart2js.test.diagnostic_helper;
 
 import 'dart:collection';
 
 import 'package:compiler/compiler_new.dart' show
     CompilerDiagnostics,
     Diagnostic;
 import 'package:compiler/src/diagnostics/messages.dart' show
     Message,
     MessageKind;
 import 'package:expect/expect.dart';
 
 class CollectedMessage {
   final Message message;
   final Uri uri;
   final int begin;
   final int end;
   final String text;
   final Diagnostic kind;
 
   CollectedMessage(
       this.message, this.uri, this.begin, this.end, this.text, this.kind);
 
   MessageKind get messageKind => message.kind;
 
-  String toString() => '${message.kind}:$uri:$begin:$end:$text:$kind';
+  String toString() {
+    return '${message != null ? message.kind : ''}'
+           ':$uri:$begin:$end:$text:$kind';
+  }
 }
 
 class DiagnosticCollector implements CompilerDiagnostics {
   List<CollectedMessage> messages = <CollectedMessage>[];
 
   void call(Uri uri, int begin, int end, String message, Diagnostic kind) {
     throw '';
     report(null, uri, begin, end, message, kind);
   }
 
@@ skipping 29 matching lines @@
   }
 
   /// `true` if non-verbose messages has been collected.
   bool get hasRegularMessages {
     return messages.any((m) => m.kind != Diagnostic.VERBOSE_INFO);
   }
 
   void clear() {
     messages.clear();
   }
+
+  void checkMessages(List<Expected> expectedMessages) {
+    int index = 0;
+    Iterable<CollectedMessage> messages =
+        filterMessagesByKinds(
+            [Diagnostic.ERROR,
+             Diagnostic.WARNING,
+             Diagnostic.HINT,
+             Diagnostic.INFO]);
+    for (CollectedMessage message in messages) {
+      if (index >= expectedMessages.length) {
+        Expect.fail("Unexpected messages:\n "
+                    "${messages.skip(index).join('\n ')}");
+      } else {
+        Expected expected = expectedMessages[index];
+        Expect.equals(expected.messageKind, message.messageKind,
+            "Unexpected message kind in:\n ${messages.join('\n ')}");
+        Expect.equals(expected.diagnosticKind, message.kind,
+            "Unexpected diagnostic kind in\n ${messages.join('\n ')}");
+        index++;
+      }
+    }
+  }
+}
+
+class Expected {
+  final MessageKind messageKind;
+  final Diagnostic diagnosticKind;
+
+  const Expected(this.messageKind, this.diagnosticKind);
+
+  const Expected.error(MessageKind messageKind)
+      : this(messageKind, Diagnostic.ERROR);
+
+  const Expected.warning(MessageKind messageKind)
+      : this(messageKind, Diagnostic.WARNING);
+
+  const Expected.hint(MessageKind messageKind)
+      : this(messageKind, Diagnostic.HINT);
+
+  const Expected.info(MessageKind messageKind)
+      : this(messageKind, Diagnostic.INFO);
 }
 
 
 void compareWarningKinds(String text,
                          List expectedWarnings,
                          Iterable<CollectedMessage> foundWarnings) {
   compareMessageKinds(text, expectedWarnings, foundWarnings, 'warning');
 }
 
 /// [expectedMessages] must be a list of either [MessageKind] or [CheckMessage].
@@ skipping 50 matching lines @@
       String expectedValue = '${arguments[key]}';
       String foundValue = '${message.arguments[key]}';
       if (expectedValue != foundValue) {
         return 'Expected argument $key with value $expectedValue, '
                'found $foundValue.';
       }
     }
     return null;
   };
 }