[debug-wrapper] migrate some scope related tests

test/debugger/debug/harmony/async-function-debug-scopes.js

 // Copyright 2016 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-// Flags: --harmony-async-await --expose-debug-as debug
+// Flags: --harmony-async-await
 
 var Debug = debug.Debug;
+var global_marker = 7;
 
 async function thrower() { throw 'Exception'; }
 
 async function test(name, func, args, handler, continuation) {
   var handler_called = false;
   var exception = null;
 
   function listener(event, exec_state, event_data, data) {
     try {
       if (event == Debug.DebugEvent.Break) {
@@ skipping 466 matching lines @@
   assertPropertiesEqual(
       scope1.scopeObject().value(), scope2.scopeObject().value());
 }
 
 function CheckFastAllScopes(scopes, exec_state) {
   var fast_all_scopes = exec_state.frame().allScopes(true);
   var length = fast_all_scopes.length;
   assertTrue(scopes.length >= length);
   for (var i = 0; i < scopes.length && i < length; i++) {
     var scope = fast_all_scopes[length - i - 1];
-    assertTrue(scope.isScope());
     assertEquals(scopes[scopes.length - i - 1], scope.scopeType());
   }
 }
 
 // Check that the scope chain contains the expected types of scopes.
 function CheckScopeChain(scopes, exec_state) {
   var all_scopes = exec_state.frame().allScopes();
   assertEquals(
       scopes.length, all_scopes.length, "FrameMirror.allScopes length");
   for (var i = 0; i < scopes.length; i++) {
     var scope = exec_state.frame().scope(i);
-    assertTrue(scope.isScope());
     assertEquals(scopes[i], scope.scopeType());
     assertScopeMirrorEquals(all_scopes[i], scope);
 
     // Check the global object when hitting the global scope.
     if (scopes[i] == debug.ScopeType.Global) {
-      // Objects don't have same class (one is "global", other is "Object",
-      // so just check the properties directly.
-      assertPropertiesEqual(this, scope.scopeObject().value());
+      assertEquals(global_marker, scope.scopeObject().value().global_marker);
     }
   }
   CheckFastAllScopes(scopes, exec_state);
 }
 
 // Check that the content of the scope is as expected. For functions just check
 // that there is a function.
 function CheckScopeContent(content, number, exec_state) {
   var scope = exec_state.frame().scope(number);
   var count = 0;
   for (var p in content) {
     var property_mirror = scope.scopeObject().property(p);
     assertFalse(property_mirror.isUndefined(),
                 `property ${p} not found in scope`);
-    if (typeof(content[p]) === 'function') {
-      assertTrue(property_mirror.value().isFunction());
-    } else {
-      assertEquals(content[p], property_mirror.value().value(),
-                   `property ${p} has unexpected value`);
-    }
+    assertEquals(content[p], property_mirror.value().value(),
+                 `property ${p} has unexpected value`);
     count++;
   }
 
   // 'arguments' and might be exposed in the local and closure scope. Just
   // ignore this.
   var scope_size = scope.scopeObject().properties().length;
   if (!scope.scopeObject().property('arguments').isUndefined()) {
     scope_size--;
   }
   // Skip property with empty name.
   if (!scope.scopeObject().property('').isUndefined()) {
     scope_size--;
   }
 
-  if (count != scope_size) {
+  if (scope_size < count) {
     print('Names found in scope:');
     var names = scope.scopeObject().propertyNames();
     for (var i = 0; i < names.length; i++) {
       print(names[i]);
     }
   }
-  assertEquals(count, scope_size);
+  assertTrue(scope_size >= count);
 }