Add SExpression test and share tests between dart2dart and analyzer2dart.

tests/compiler/dart2js/backend_dart/sexpr_test.dart

 // Copyright (c) 2014, 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.
 
-import '../compiler_helper.dart';
-import 'sexpr_unstringifier.dart';
+library dart_backend.sexpr_test;
+
 import 'dart:async';
-import "package:async_helper/async_helper.dart";
-import "package:expect/expect.dart";
+
+import 'package:async_helper/async_helper.dart';
 import 'package:compiler/implementation/dart2jslib.dart';
 import 'package:compiler/implementation/cps_ir/cps_ir_nodes.dart';
 import 'package:compiler/implementation/cps_ir/cps_ir_nodes_sexpr.dart';
+import 'package:expect/expect.dart';
+
+import '../compiler_helper.dart' hide compilerFor;
+import 'sexpr_unstringifier.dart';
+import 'test_helper.dart';
 
 const String CODE = """
 class Foo {
   static int x = 1;
   foo() => 42;
 }
 
 class Bar extends Foo {
   int y = 2;
   Bar() {
     Foo.x = 2;
   }
   foo() =>  this.y + super.foo();
-} 
+}
 
 class FooBar<T> {
   bool foobar() => T is int;
 }
 
 main() {
   Foo foo;
   if (foo is Foo) {
     print("Surprise");
   }
@@ skipping 39 matching lines @@
 
 bool shouldOutput(Element element) {
   return (!element.library.isPlatformLibrary &&
           !element.isSynthesized &&
           element.kind == ElementKind.FUNCTION);
 }
 
 /// Compiles the given dart code (which must include a 'main' function) and
 /// returns a list of all generated CPS IR definitions.
 Future<List<FunctionDefinition>> compile(String code) {
-  MockCompiler compiler = new MockCompiler.internal(
-      emitJavaScript: false,
-      enableMinification: false);
-
-  return compiler.init().then((_) {
-    compiler.parseScript(code);
-
-    Element element = compiler.mainApp.find('main');
-    if (element == null) return null;
-
-    compiler.mainFunction = element;
-    compiler.phase = Compiler.PHASE_RESOLVING;
-    compiler.backend.enqueueHelpers(compiler.enqueuer.resolution,
-                                    compiler.globalDependencies);
-    compiler.processQueue(compiler.enqueuer.resolution, element);
-    compiler.world.populate();
-    compiler.backend.onResolutionComplete();
-
-    compiler.irBuilder.buildNodes(useNewBackend: true);
-
+  return compilerFor(code).then((Compiler compiler) {
     return compiler.enqueuer.resolution.resolvedElements
               .where(shouldOutput)
               .map(compiler.irBuilder.getIr)
               .toList();
   });
 }
 
 /// Returns an S-expression string for each compiled function.
 List<String> stringifyAll(Iterable<FunctionDefinition> functions) {
   final stringifier = new SExpressionStringifier();
@@ skipping 63 matching lines @@
           ];
 
   asyncTest(() => testStringifier(CODE, tokens).then((List<String> sexprs) {
     final functions = testUnstringifier(sexprs);
 
     // Ensure that
     // stringified(CODE) == stringified(unstringified(stringified(CODE)))
     Expect.listEquals(sexprs, stringifyAll(functions));
   }));
 }