anchor.diff:  
     Future<Result<Program>> run(
         TestDescription description, InterpreterContext context) async {
  -    Program platform = await context.createPlatform();
  +    Program platform = await context.loadPlatform();
       Ticker ticker = new Ticker();
       DillTarget dillTarget = new DillTarget(ticker, context.uriTranslator);
       dillTarget.loader
  -      ..input = Uri.parse("org.dartlang:platform")
  +      ..input = Uri.parse("org.dartlang:platform") // Make up a name.
         ..setProgram(platform);
       KernelTarget sourceTarget =
  -        new KernelTarget(dillTarget, context.uriTranslator, false);
  +        new KernelTarget(dillTarget, context.uriTranslator, context.strongMode);
   
       Program p;
       try {
  
positive.code: 
  import 'package:front_end/src/fasta/errors.dart' show InputError;
  
  import 'package:kernel/interpreter/interpreter.dart';
  
  class InterpreterContext extends TestContext {
    final TranslateUri uriTranslator;
  
    final List<Step> steps;
  
    Future<Program> platform;
  
    InterpreterContext(Uri sdk, Uri vm, Uri packages, bool strongMode,
        DartSdk dartSdk, this.uriTranslator)
        : steps = <Step>[
            const FastaCompile(),
            const Interpret(),
            const MatchLogExpectation(".expect"),
          ],
          super(sdk, vm, packages, strongMode, dartSdk);
  
    Future<Program> createPlatform() {
      return new Future<Program>(() async {
        DartLoader loader = await createLoader();
        Target target =
            getTarget("vm", new TargetFlags(strongMode: options.strongMode));
        loader.loadProgram(Uri.base.resolve("pkg/fasta/test/platform.dart"),
            target: target);
        var program = loader.program;
        if (loader.errors.isNotEmpty) {
          throw loader.errors.join("\n");
        }
        Library mainLibrary = program.mainMethod.enclosingLibrary;
        program.uriToSource.remove(mainLibrary.fileUri);
        program = new Program(
            program.libraries.where((Library l) => l != mainLibrary).toList(),
            program.uriToSource);
        target.performModularTransformations(program);
        target.performGlobalTransformations(program);
        return program;
      });
    }
  
    static Future<InterpreterContext> create(
        Chain suite, Map<String, String> environment) async {
      return TestContext.create(suite, environment, (Chain suite,
          Map<String, String> environment,
          Uri sdk,
          Uri vm,
          Uri packages,
          bool strongMode,
          DartSdk dartSdk,
          bool updateExpectations) async {
        TranslateUri uriTranslator = await TranslateUri.parse(packages);
        return new InterpreterContext(
            sdk, vm, packages, strongMode, dartSdk, uriTranslator);
      });
    }
  }
  
  
negative.code:     } on InputError catch (e, s) {
        return fail(null, e.error, s);
      }
      return pass(p);
    }
  }
  