Converted Observatory vm-view && isolate-view elements

runtime/observatory/tests/service/service_test_common.dart

 // Copyright (c) 2016, 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 service_test_common;
 
 import 'dart:async';
+import 'package:observatory/models.dart' as M;
 import 'package:observatory/service_common.dart';
 import 'package:unittest/unittest.dart';
 
 typedef Future IsolateTest(Isolate isolate);
 typedef Future VMTest(VM vm);
 
 Map<String, StreamSubscription> streamSubscriptions = {};
 
 Future subscribeToStream(VM vm, String streamName, onEvent) async {
   assert(streamSubscriptions[streamName] == null);
@@ skipping 71 matching lines @@
   } catch (e) {
     // This can fail when another client issued the same resume command
     // or another client has moved the isolate forward.
     cancelSubscription();
     completeError(e);
   }
 
   return pausedAtSyntheticBreakpoint.future;
 }
 
+bool isEventOfKind(M.Event event, String kind) {
+  switch (kind) {
+    case ServiceEvent.kPauseBreakpoint:
+      return event is M.PauseBreakpointEvent;
+    case ServiceEvent.kPauseException:
+      return event is M.PauseExceptionEvent;
+    case ServiceEvent.kPauseExit:
+      return event is M.PauseExitEvent;
+    case ServiceEvent.kPauseStart:
+      return event is M.PauseStartEvent;
+    default:
+      return false;
+  }
+}
 
 Future<Isolate> hasPausedFor(Isolate isolate, String kind) {
   // Set up a listener to wait for breakpoint events.
   Completer completer = new Completer();
   isolate.vm.getEventStream(VM.kDebugStream).then((stream) {
     var subscription;
     subscription = stream.listen((ServiceEvent event) {
         if (event.kind == kind) {
           if (completer != null) {
             // Reload to update isolate.pauseEvent.
             print('Paused with $kind');
             subscription.cancel();
             completer.complete(isolate.reload());
             completer = null;
           }
         }
     });
 
     // Pause may have happened before we subscribed.
     isolate.reload().then((_) {
       if ((isolate.pauseEvent != null) &&
-         (isolate.pauseEvent.kind == kind)) {
+         isEventOfKind(isolate.pauseEvent, kind)) {
         // Already waiting at a breakpoint.
         if (completer != null) {
           print('Paused with $kind');
           subscription.cancel();
           completer.complete(isolate);
           completer = null;
         }
       }
     });
   });
@@ skipping 121 matching lines @@
 
 Future<Instance> rootLibraryFieldValue(Isolate isolate,
                                        String fieldName) async {
   Library rootLib = await isolate.rootLibrary.load();
   Field field = rootLib.variables.singleWhere((v) => v.name == fieldName);
   await field.load();
   Instance value = field.staticValue;
   await value.load();
   return value;
 }