Converted Observatory vm-view && isolate-view elements

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/models.dart' as M;
 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;
+const int LINE_A = 25;
+const int LINE_B = 27;
+const int LINE_C = 29;
+const int LINE_D = 30;
 
 // This tests the low level synthetic breakpoint added / paused / removed
 // machinery triggered by the step OverAwait command.
 asyncWithoutAwait() async {
   debugger();
   print('a');  // LINE_A
   await new Future.delayed(new Duration(seconds: 2));
   print('b');  // LINE_B
   debugger();  // LINE_C
   debugger();  // LINE_D
 }
 
 testMain() {
   asyncWithoutAwait();
 }
 
 Breakpoint syntheticBreakpoint;
 
 Future<Isolate> testLowLevelAwaitOver(
     Isolate isolate) {
-  assert(isolate.pauseEvent.atAsyncSuspension);
+  assert(M.isAtAsyncSuspension(isolate.pauseEvent));
 
   int state = 0;
   bool firstResume = true;
   handleBreakpointAdded(ServiceEvent event) {
     expect(syntheticBreakpoint, isNull);
     expect(state, 0);
     if (!event.breakpoint.isSyntheticAsyncContinuation) {
       // Not a synthetic async breakpoint.
       return;
     }
@@ skipping 104 matching lines @@
 }
 
 
 var tests = [
   hasStoppedAtBreakpoint,
   stoppedAtLine(LINE_A),
   stepOver,
   stepOver,
   stepOver,
   (Isolate isolate) async {
-    expect(isolate.pauseEvent.atAsyncSuspension, isTrue);
+    expect(M.isAtAsyncSuspension(isolate.pauseEvent), isTrue);
     expect(syntheticBreakpoint, isNull);
   },
   testLowLevelAwaitOver,
   hasStoppedAtBreakpoint,
   stoppedAtLine(LINE_C),
   resumeIsolate,
   hasStoppedAtBreakpoint,
   stoppedAtLine(LINE_D),
   resumeIsolate,
 ];
 
 main(args) => runIsolateTests(args, tests, testeeConcurrent: testMain);