Run 'Inline Method' refactoring tests with the new analysis driver.

pkg/analysis_server/test/services/refactoring/inline_method_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.
 
 library test.services.refactoring.inline_method;
 
 import 'dart:async';
 
 import 'package:analysis_server/plugin/protocol/protocol.dart' hide Element;
 import 'package:analysis_server/src/services/correction/status.dart';
 import 'package:analysis_server/src/services/refactoring/inline_method.dart';
 import 'package:analysis_server/src/services/refactoring/refactoring.dart';
 import 'package:analyzer/src/generated/source.dart';
 import 'package:test/test.dart';
 import 'package:test_reflective_loader/test_reflective_loader.dart';
 
 import 'abstract_refactoring.dart';
 
 main() {
   defineReflectiveSuite(() {
     defineReflectiveTests(InlineMethodTest);
+    defineReflectiveTests(InlineMethodTest_Driver);
   });
 }
 
 @reflectiveTest
 class InlineMethodTest extends RefactoringTest {
   InlineMethodRefactoringImpl refactoring;
   bool deleteSource;
   bool inlineAll;
 
   test_access_FunctionElement() async {
@@ skipping 749 matching lines @@
   }
 }
 ''');
   }
 
   test_getter_async_targetIsAsyncStar() async {
     await indexTestUnit(r'''
 import 'dart:async';
 class A {
   Future<int> get test async => 42;
-  Stream<int> foo() async {
-    return await test;
+  Stream<int> foo() async* {
+    yield await test;
   }
 }
 ''');
     _createRefactoring('test async');
     // validate change
     return _assertSuccessfulRefactoring(r'''
 import 'dart:async';
 class A {
-  Stream<int> foo() async {
-    return await 42;
+  Stream<int> foo() async* {
+    yield await 42;
   }
 }
 ''');
   }
 
   test_getter_async_targetIsSync() async {
     await indexTestUnit(r'''
 import 'dart:async';
 class A {
   Future<int> get test async => 42;
@@ skipping 153 matching lines @@
     return 42;
   }
 }
 ''');
   }
 
   test_method_async2() async {
     await indexTestUnit(r'''
 import 'dart:async';
 class A {
-  Future<int> test() async => 42;
-  Future foo() {
-    return [test(), test()];
+  Future<int> foo() async => 42;
+  Future<int> test() async => await foo();
+  Future bar() {
+    return new Future.value([test(), test()]);
   }
 }
 ''');
     _createRefactoring('test() async');
     // validate change
     return _assertSuccessfulRefactoring(r'''
 import 'dart:async';
 class A {
-  Future foo() async {
-    return [42, 42];
+  Future<int> foo() async => 42;
+  Future bar() async {
+    return new Future.value([(await foo()), (await foo())]);
   }
 }
 ''');
   }
 
   test_method_emptyBody() async {
     await indexTestUnit(r'''
 abstract class A {
   test();
 }
@@ skipping 45 matching lines @@
   }
 
   test_method_fieldStatic() async {
     await indexTestUnit(r'''
 class A {
   static var FA = 1;
 }
 class B extends A {
   static var FB = 2;
   test() {
-    print(FA);
     print(FB);
     print(A.FA);
     print(B.FB);
   }
 }
 main() {
   B b = new B();
   b.test();
 }
 ''');
     _createRefactoring('test() {');
     // validate change
     return _assertSuccessfulRefactoring(r'''
 class A {
   static var FA = 1;
 }
 class B extends A {
   static var FB = 2;
 }
 main() {
   B b = new B();
-  print(A.FA);
   print(B.FB);
   print(A.FA);
   print(B.FB);
 }
 ''');
   }
 
   test_method_fieldStatic_sameClass() async {
     await indexTestUnit(r'''
 class A {
@@ skipping 622 matching lines @@
     this.refactoringChange = change;
     assertTestChangeResult(expectedCode);
   }
 
   void _createRefactoring(String search) {
     int offset = findOffset(search);
     refactoring = new InlineMethodRefactoring(
         searchEngine, getResolvedUnitWithElement, testUnit, offset);
   }
 }
+
+@reflectiveTest
+class InlineMethodTest_Driver extends InlineMethodTest {
+  @override
+  bool get enableNewAnalysisDriver => true;
+}