anchor.diff:            compiler.abstractValueStrategy,
             newComponent,
             worldData);
  -  List newWorldData = strategy.serializeGlobalTypeInferenceResults(newResults);
  -  Expect.equals(worldData.length, newWorldData.length,
  -      "Reserialization data length mismatch.");
  -  for (int i = 0; i < worldData.length; i++) {
  -    if (worldData[i] != newWorldData[i]) {
  -      print('Reserialization data mismatch at offset $i:');
  -      for (int j = i - 50; j < i + 50; j++) {
  -        if (0 <= j && j <= worldData.length) {
  -          String text;
  -          if (worldData[j] == newWorldData[j]) {
  -            text = '${worldData[j]}';
  -          } else {
  -            text = '${worldData[j]} <> ${newWorldData[j]}';
  -          }
  -          print('${j == i ? '> ' : '  '}$j: $text');
  -        }
  -      }
  -      break;
  -    }
  -  }
  -  Expect.listEquals(worldData, newWorldData);
  -
  +  List<int> newWorldData =
  +      strategy.serializeGlobalTypeInferenceResults(newResults);
  +  checkData(worldData, newWorldData);
     return newResults;
   }
  
positive.code: 
  import 'package:compiler/compiler_new.dart';
  import 'package:compiler/src/compiler.dart';
  import 'package:compiler/src/inferrer/types.dart';
  import 'package:compiler/src/serialization/strategies.dart';
  import 'package:expect/expect.dart';
  
negative.code:   '"toJsonDuration":'
  ];
  
  void finishCompileAndCompare(
      Map<OutputType, Map<String, String>> expectedOutput,
      OutputCollector actualOutputCollector,
      Compiler compiler,
      SerializationStrategy strategy,
      {bool stoppedAfterClosedWorld = false,
      bool stoppedAfterTypeInference = false}) {
    if (stoppedAfterClosedWorld) {
      JsClosedWorld closedWorld = compiler.backendClosedWorldForTesting;
      JsClosedWorld newClosedWorld =
          cloneClosedWorld(compiler, closedWorld, strategy);
      compiler.performGlobalTypeInference(newClosedWorld);
    }
  
    if (stoppedAfterClosedWorld || stoppedAfterTypeInference) {
      GlobalTypeInferenceResults globalInferenceResults =
          compiler.globalInference.resultsForTesting;
      GlobalTypeInferenceResults newGlobalInferenceResults =
          cloneInferenceResults(compiler, globalInferenceResults, strategy);
      compiler.generateJavaScriptCode(newGlobalInferenceResults);
    }
    var actualOutput = actualOutputCollector.clear();
    Expect.setEquals(
        expectedOutput.keys, actualOutput.keys, "Output type mismatch.");
  
    void check(OutputType outputType, Map<String, String> fileMap) {
      Map<String, String> newFileMap = actualOutput[outputType];
      Expect.setEquals(fileMap.keys, newFileMap.keys,
          "File mismatch for output type $outputType.");
      fileMap.forEach((String fileName, String code) {
  