Introduce a testing framework for use with fasta type inference.

pkg/front_end/lib/src/fasta/testing/suite.dart

 // Copyright (c) 2016, 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.md file.
 
 library fasta.testing.suite;
 
 import 'dart:async' show Future;
 
 import 'dart:convert' show JSON;
 
 import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
 
+import 'package:front_end/src/fasta/testing/validating_instrumentation.dart'
+    show ValidatingInstrumentation;
+
 import 'package:kernel/ast.dart' show Library, Program;
 
 import 'package:analyzer/src/kernel/loader.dart' show DartLoader;
 
 import 'package:kernel/target/targets.dart' show Target, TargetFlags, getTarget;
 
 import 'package:testing/testing.dart'
     show Chain, ExpectationSet, Result, Step, TestDescription;
 
 import '../errors.dart' show InputError;
@@ skipping 131 matching lines @@
   }
 }
 
 class Outline extends Step<TestDescription, Program, FastaContext> {
   final bool fullCompile;
 
   final AstKind astKind;
 
   final bool strongMode;
 
-  const Outline(this.fullCompile, this.astKind, this.strongMode);
+  const Outline(this.fullCompile, this.astKind, this.strongMode,
+      {this.updateExpectations: false});
+
+  final bool updateExpectations;
 
   String get name {
     return fullCompile ? "${astKind} compile" : "outline";
   }
 
   bool get isCompiler => fullCompile;
 
   Future<Result<Program>> run(
       TestDescription description, FastaContext context) async {
     Program platform = await context.createPlatform();
     Ticker ticker = new Ticker();
     DillTarget dillTarget = new DillTarget(ticker, context.uriTranslator);
     dillTarget.loader
       ..input = Uri.parse("org.dartlang:platform") // Make up a name.
       ..setProgram(platform);
     KernelTarget sourceTarget = astKind == AstKind.Analyzer
         ? new AnalyzerTarget(dillTarget, context.uriTranslator, strongMode)
         : new KernelTarget(dillTarget, context.uriTranslator, strongMode);
 
     Program p;
     try {
       sourceTarget.read(description.uri);
       await dillTarget.writeOutline(null);
+      var instrumentation = new ValidatingInstrumentation();
+      await instrumentation.loadExpectations(description.uri);
+      sourceTarget.loader.instrumentation = instrumentation;
       p = await sourceTarget.writeOutline(null);
       if (fullCompile) {
         p = await sourceTarget.writeProgram(null);
+        instrumentation.finish();
+        if (instrumentation.hasProblems) {
+          if (updateExpectations) {
+            await instrumentation.fixSource(description.uri);
+          } else {
+            return fail(null, instrumentation.problemsAsString);
+          }
+        }
       }
     } on InputError catch (e, s) {
       return fail(null, e.error, s);
     }
     return pass(p);
   }
 }