Refactor service tests in preparation of running on sky_shell

runtime/observatory/tests/service/step_over_await_test.dart

 // Copyright (c) 2015, 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.
 // VMOptions=--error_on_bad_type --error_on_bad_override  --verbose_debug --trace_service
 
 import 'dart:async';
 import 'dart:developer';
 
 import 'test_helper.dart';
+import 'service_test_common.dart';
 
 import 'package:observatory/service_io.dart';
 import 'package:unittest/unittest.dart';
 
+const int LINE_A = 24;
+const int LINE_B = 26;
+const int LINE_C = 28;
+const int LINE_D = 29;
+
 // This tests the low level synthetic breakpoint added / paused / removed
 // machinery triggered by the step OverAwait command.
 asyncWithoutAwait() async {
   debugger();
-  print('a');
+  print('a');  // LINE_A
   await new Future.delayed(new Duration(seconds: 2));
-  print('b');
-  debugger();
-  debugger();
+  print('b');  // LINE_B
+  debugger();  // LINE_C
+  debugger();  // LINE_D
 }
 
 testMain() {
   asyncWithoutAwait();
 }
 
 Breakpoint syntheticBreakpoint;
 
 Future<Isolate> testLowLevelAwaitOver(
     Isolate isolate) {
@@ skipping 85 matching lines @@
           handleResume(event);
           expect(state, 2);
         } else {
           handleResume(event);
           expect(state, 4);
         }
       } else if (event.kind == ServiceEvent.kPauseBreakpoint) {
         handlePauseBreakpoint(event);
         expect(state, 3);
         // Check that we are paused after the await statement.
-        await (stoppedAtLine(20)(isolate));
+        await (stoppedAtLine(LINE_B)(isolate));
         // Resume the isolate so that we trigger the breakpoint removal.
         print('!!!! Triggering synthetic breakpoint removal.');
         isolate.resume();
       } else if (event.kind == ServiceEvent.kBreakpointRemoved) {
         handleBreakpointRemoved(event);
         expect(state, 5);
         subscription.cancel();
         if (completer != null) {
           // Reload to update isolate.pauseEvent.
           completer.complete(isolate.reload());
           completer = null;
         }
       }
     });
   });
 
   isolate.stepOverAsyncSuspension();
 
   return completer.future;  // Will complete when breakpoint added.
 }
 
 
 var tests = [
   hasStoppedAtBreakpoint,
-  stoppedAtLine(18),
+  stoppedAtLine(LINE_A),
   stepOver,
   stepOver,
   stepOver,
   (Isolate isolate) async {
     expect(isolate.pauseEvent.atAsyncSuspension, isTrue);
     expect(syntheticBreakpoint, isNull);
   },
   testLowLevelAwaitOver,
   hasStoppedAtBreakpoint,
-  stoppedAtLine(22),
+  stoppedAtLine(LINE_C),
   resumeIsolate,
   hasStoppedAtBreakpoint,
-  stoppedAtLine(23),
+  stoppedAtLine(LINE_D),
   resumeIsolate,
 ];
 
 main(args) => runIsolateTests(args, tests, testeeConcurrent: testMain);