anchor.diff:      } on InputError catch (e, s) {
         return fail(null, e.error, s);
       }
  -
       return pass(p);
     }
   }
  
positive.code: 
  import 'dart:io' show File;
  
  import 'package:analyzer/src/generated/sdk.dart' show DartSdk;
  
  import 'package:analyzer/src/kernel/loader.dart' show DartLoader;
  
  import 'package:testing/testing.dart'
      show Chain, Result, Step, TestDescription, runMe;
  
  import 'package:kernel/ast.dart' show Program, Library;
  
  import 'package:kernel/target/targets.dart' show Target, TargetFlags, getTarget;
  
  import 'package:front_end/src/fasta/testing/kernel_chain.dart';
  
  import 'package:front_end/src/fasta/ticker.dart' show Ticker;
  
  
negative.code: 
  import 'package:front_end/src/fasta/errors.dart' show InputError;
  
  import 'package:front_end/src/fasta/testing/patched_sdk_location.dart';
  
  import 'package:kernel/kernel.dart' show loadProgramFromBinary;
  
  import 'package:kernel/interpreter/interpreter.dart';
  
  const String STRONG_MODE = " strong mode ";
  
  class InterpreterContext extends ChainContext {
    final bool strongMode;
  
    final TranslateUri uriTranslator;
  
    final List<Step> steps;
  
    Future<Program> platform;
  
    InterpreterContext(this.strongMode, this.uriTranslator)
        : steps = <Step>[
            const FastaCompile(),
            const Interpret(),
            const MatchLogExpectation(".expect"),
          ];
  
    Future<Program> loadPlatform() async {
      Uri sdk = await computePatchedSdk();
      return loadProgramFromBinary(sdk.resolve('platform.dill').toFilePath());
    }
  
    static Future<InterpreterContext> create(
        Chain suite, Map<String, String> environment) async {
      Uri packages = Uri.base.resolve(".packages");
      bool strongMode = environment.containsKey(STRONG_MODE);
      TranslateUri uriTranslator = await TranslateUri.parse(packages);
      return new InterpreterContext(strongMode, uriTranslator);
    }
  }
  
  