Use ansi color in the dartanalyzer cli output.

pkg/analyzer_cli/test/driver_test.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 analyzer_cli.test.driver;
 
 import 'dart:async';
 import 'dart:io';
 
 import 'package:analyzer/error/error.dart';
 import 'package:analyzer/source/analysis_options_provider.dart';
 import 'package:analyzer/source/error_processor.dart';
 import 'package:analyzer/src/error/codes.dart';
 import 'package:analyzer/src/generated/engine.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:analyzer/src/services/lint.dart';
+import 'package:analyzer_cli/src/ansi.dart' as ansi;
 import 'package:analyzer_cli/src/driver.dart';
 import 'package:analyzer_cli/src/options.dart';
 import 'package:cli_util/cli_util.dart' show getSdkDir;
 import 'package:path/path.dart' as path;
 import 'package:test/test.dart';
 import 'package:yaml/src/yaml_node.dart';
 
 import 'utils.dart';
 
 main() {
   StringSink savedOutSink, savedErrorSink;
   int savedExitCode;
   ExitHandler savedExitHandler;
 
   /// Base setup.
   _setUp() {
+    ansi.runningTests = true;
     savedOutSink = outSink;
     savedErrorSink = errorSink;
     savedExitHandler = exitHandler;
     savedExitCode = exitCode;
     exitHandler = (code) => exitCode = code;
     outSink = new StringBuffer();
     errorSink = new StringBuffer();
   }
 
   /// Base teardown.
   _tearDown() {
     outSink = savedOutSink;
     errorSink = savedErrorSink;
     exitCode = savedExitCode;
     exitHandler = savedExitHandler;
+    ansi.runningTests = false;
   }
 
   setUp(() => _setUp());
 
   tearDown(() => _tearDown());
 
   group('Driver', () {
     group('options', () {
       test('todos', () async {
         await drive('data/file_with_todo.dart');
@@ skipping 112 matching lines @@
             expect(driver.context.analysisOptions.lint, isTrue);
 
             /// The analysis options file only specifies 'camel_case_types'.
             var lintNames = getLints(driver.context).map((r) => r.name);
             expect(lintNames, orderedEquals(['camel_case_types']));
           });
 
           test('generates lints', () async {
             await runLinter();
             expect(outSink.toString(),
-                contains('[lint] Name types using UpperCamelCase'));
+                contains('lint • Name types using UpperCamelCase'));

[Brian Wilkerson, 2017/03/23 17:09:51]

Will this work on Windows? Perhaps we should expect the error severity and
message separately.

[devoncarew, 2017/03/25 22:33:17]

There is some checking for 'ansi.runningTests' in order to normalize output a 
bit when testing, so should still pass on windows. I think it does make sense to
split the two checks however, so will do that.

           });
         });
 
         group('default lints - $designator', () {
           // Shared lint command.
           Future<Null> runLinter() async {
             return await drive('data/linter_project/test_file.dart',
                 options: 'data/linter_project/$optionsFileName',
                 args: ['--lints']);
           }
 
           test('gets default lints', () async {
             await runLinter();
 
             /// Lints should be enabled.
             expect(driver.context.analysisOptions.lint, isTrue);
 
             /// Default list should include camel_case_types.
             var lintNames = getLints(driver.context).map((r) => r.name);
             expect(lintNames, contains('camel_case_types'));
           });
 
           test('generates lints', () async {
             await runLinter();
             expect(outSink.toString(),
-                contains('[lint] Name types using UpperCamelCase'));
+                contains('lint • Name types using UpperCamelCase'));
           });
         });
 
         group('no `--lints` flag (none in options) - $designator', () {
           // Shared lint command.
           Future<Null> runLinter() async {
             return await drive('data/no_lints_project/test_file.dart',
                 options: 'data/no_lints_project/$optionsFileName');
           }
 
@@ skipping 65 matching lines @@
 
             // missing_return: error
             var missing_return = new AnalysisError(
                 new TestSource(), 0, 1, HintCode.MISSING_RETURN, [
               ['x']
             ]);
             expect(processorFor(missing_return).severity, ErrorSeverity.ERROR);
             expect(
                 outSink.toString(),
                 contains(
-                    "[error] This function declares a return type of 'int'"));
+                    "error • This function declares a return type of 'int'"));
             expect(
                 outSink.toString(), contains("1 error and 1 warning found."));
           });
 
           test('language', () async {
             await doDrive();
             expect(driver.context.analysisOptions.enableSuperMixins, isTrue);
           });
 
           test('strongMode', () async {
@@ skipping 18 matching lines @@
             await doDrive();
             // missing_return: error
             var undefined_function = new AnalysisError(new TestSource(), 0, 1,
                 StaticTypeWarningCode.UNDEFINED_FUNCTION, [
               ['x']
             ]);
             expect(processorFor(undefined_function).severity,
                 ErrorSeverity.WARNING);
             // Should not be made fatal by `--fatal-warnings`.
             expect(outSink.toString(),
-                contains("[warning] The function 'baz' isn't defined"));
+                contains("warning • The function 'baz' isn't defined"));
             expect(
                 outSink.toString(), contains("1 error and 1 warning found."));
           });
         });
       }
 
       createTests('old', AnalysisEngine.ANALYSIS_OPTIONS_FILE);
       createTests('new', AnalysisEngine.ANALYSIS_OPTIONS_YAML_FILE);
 
       test('include directive', () async {
@@ skipping 219 matching lines @@
 
 ErrorProcessor processorFor(AnalysisError error) =>
     processors.firstWhere((p) => p.appliesTo(error));
 
 class TestSource implements Source {
   TestSource();
 
   @override
   noSuchMethod(Invocation invocation) => super.noSuchMethod(invocation);
 }