Add @assertFailingTest annotation support.

pkg/analyzer/test/reflective_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 analyzer.test.reflective_tests;
 
 import 'dart:async';
-@MirrorsUsed(metaTargets: 'ReflectiveTest')
 import 'dart:mirrors';
 
 import 'package:unittest/unittest.dart';
 
 /**
  * A marker annotation used to annotate overridden test methods (so we cannot
+ * rename them to `fail_`) which are expected to fail at `assert` in the
+ * checked mode.
+ */
+const _AssertFailingTest assertFailingTest = const _AssertFailingTest();
+
+/**
+ * A marker annotation used to annotate overridden test methods (so we cannot
  * rename them to `fail_`) which are expected to fail.
  */
 const _FailingTest failingTest = const _FailingTest();
 
 /**
  * A marker annotation used to instruct dart2js to keep reflection information
  * for the annotated classes.
  */
 const ReflectiveTest reflectiveTest = const ReflectiveTest();
 
 /**
+ * Is `true` the application runs in the checked mode.

[Paul Berry, 2016/04/29 17:57:31]

s/runs/is running/

("runs" implies that the app "normally runs" in checked mode, or "is able to
run" in checked mode; "is running" refers to the state of the current run)

[scheglov, 2016/04/29 18:04:07]

Done.
Thanks!

+ */
+final bool _isCheckedMode = () {
+  try {
+    assert(false);
+    return false;
+  } catch (_) {
+    return true;
+  }
+}();
+
+/**
  * Runs test methods existing in the given [type].
  *
  * Methods with names starting with `test` are run using [test] function.
  * Methods with names starting with `solo_test` are run using [solo_test] function.
  *
  * Each method is run with a new instance of [type].
  * So, [type] should have a default constructor.
  *
  * If [type] declares method `setUp`, it methods will be invoked before any test
  * method invocation.
@@ skipping 15 matching lines @@
     classMirror.instanceMembers
         .forEach((Symbol symbol, MethodMirror memberMirror) {
       // we need only methods
       if (memberMirror is! MethodMirror || !memberMirror.isRegularMethod) {
         return;
       }
       String memberName = MirrorSystem.getName(symbol);
       // test_
       if (memberName.startsWith('test_')) {
         test(memberName, () {
-          if (_hasFailingTestAnnotation(memberMirror)) {
+          if (_hasFailingTestAnnotation(memberMirror) ||
+              _isCheckedMode && _hasAssertFailingTestAnnotation(memberMirror)) {
             return _runFailingTest(classMirror, symbol);
           } else {
             return _runTest(classMirror, symbol);
           }
         });
         return;
       }
       // solo_test_
       if (memberName.startsWith('solo_test_')) {
         solo_test(memberName, () {
           return _runTest(classMirror, symbol);
         });
       }
       // fail_test_
       if (memberName.startsWith('fail_')) {
         test(memberName, () {
           return _runFailingTest(classMirror, symbol);
         });
       }
       // solo_fail_test_
       if (memberName.startsWith('solo_fail_')) {
         solo_test(memberName, () {
           return _runFailingTest(classMirror, symbol);
         });
       }
     });
   });
 }
 
-bool _hasFailingTestAnnotation(MethodMirror method) {
-  return method.metadata.any((InstanceMirror annotation) =>
-      annotation.type.reflectedType == _FailingTest);
-}
+bool _hasAnnotationInstance(DeclarationMirror declaration, instance) =>
+    declaration.metadata.any((InstanceMirror annotation) =>
+        identical(annotation.reflectee, instance));
+
+bool _hasAssertFailingTestAnnotation(MethodMirror method) =>
+    _hasAnnotationInstance(method, assertFailingTest);
+
+bool _hasFailingTestAnnotation(MethodMirror method) =>
+    _hasAnnotationInstance(method, failingTest);
 
 Future _invokeSymbolIfExists(InstanceMirror instanceMirror, Symbol symbol) {
   var invocationResult = null;
   InstanceMirror closure;
   try {
     closure = instanceMirror.getField(symbol);
   } on NoSuchMethodError {}
 
   if (closure is ClosureMirror) {
     invocationResult = closure.apply([]).reflectee;
@@ skipping 27 matching lines @@
 /**
  * A marker annotation used to instruct dart2js to keep reflection information
  * for the annotated classes.
  */
 class ReflectiveTest {
   const ReflectiveTest();
 }
 
 /**
  * A marker annotation used to annotate overridden test methods (so we cannot
+ * rename them to `fail_`) which are expected to fail at `assert` in the
+ * checked mode.
+ */
+class _AssertFailingTest {
+  const _AssertFailingTest();
+}
+
+/**
+ * A marker annotation used to annotate overridden test methods (so we cannot
  * rename them to `fail_`) which are expected to fail.
  */
 class _FailingTest {
   const _FailingTest();
 }