[debug-wrapper] migrate some scope related tests

test/debugger/debug/es6/generators-debug-scopes.js

 // Copyright 2014 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: --expose-debug-as debug --noanalyze-environment-liveness
+// Flags: --noanalyze-environment-liveness
 
 var Debug = debug.Debug;
+var global_marker = 7;
 
 function RunTest(name, formals_and_body, args, handler, continuation) {
   var handler_called = false;
   var exception = null;
 
   function listener(event, exec_state, event_data, data) {
     try {
       if (event == Debug.DebugEvent.Break) {
         handler_called = true;
         handler(exec_state);
@@ skipping 34 matching lines @@
   assertEquals(scope1.scopeIndex(), scope2.scopeIndex());
   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, exec_state.frame().scopeCount());
   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);
 }
 
 
 // Simple empty local scope.
 RunTest("Local 1",
         ['debugger;'],
         [],
         function (exec_state) {
           CheckScopeChain([debug.ScopeType.Local,
                            debug.ScopeType.Script,
@@ skipping 66 matching lines @@
         [1, 2],
         function (exec_state) {
           CheckScopeChain([debug.ScopeType.Local,
                            debug.ScopeType.Script,
                            debug.ScopeType.Global], exec_state);
           CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6}, 0, exec_state);
         });
 
 // Nested empty with blocks.
 RunTest("With",
-        ["with ({}) { with ({}) { debugger; } }"],
+        ["with ({a:1}) { with ({b:2}) { debugger; } }"],
         [],
         function (exec_state) {
           CheckScopeChain([debug.ScopeType.With,
                            debug.ScopeType.With,
                            debug.ScopeType.Local,
                            debug.ScopeType.Script,
                            debug.ScopeType.Global], exec_state);
-          CheckScopeContent({}, 0, exec_state);
-          CheckScopeContent({}, 1, exec_state);
+          CheckScopeContent({b:2}, 0, exec_state);
+          CheckScopeContent({a:1}, 1, exec_state);
         });
 
 // Simple closure formed by returning an inner function referering the outer
 // functions arguments.
 RunTest("Closure 1",
         ['a', 'return function() { debugger; return a; }'],
         [1],
         function (exec_state) {
           CheckScopeChain([debug.ScopeType.Local,
                            debug.ScopeType.Closure,
@@ skipping 36 matching lines @@
                            debug.ScopeType.With,
                            debug.ScopeType.Closure,
                            debug.ScopeType.Closure,
                            debug.ScopeType.Script,
                            debug.ScopeType.Global], exec_state);
           CheckScopeContent({b:16}, 0, exec_state);
           CheckScopeContent({a:15}, 1, exec_state);
           CheckScopeContent({x:14}, 2, exec_state);
           CheckScopeContent({j:13}, 3, exec_state);
           CheckScopeContent({a:1,b:2,x:9,y:10,i:11,j:12}, 4, exec_state);
-          CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6,f:function(){}}, 5,
+          CheckScopeContent({a:1,b:2,x:3,y:4,i:5,j:6,f:undefined}, 5,
                             exec_state);
         },
         function (result) { result() });
 
 RunTest("Catch block 1",
         ["try { throw 'Exception'; } catch (e) { debugger; }"],
         [],
         function (exec_state) {
           CheckScopeChain([debug.ScopeType.Catch,
                            debug.ScopeType.Local,
                            debug.ScopeType.Script,
                            debug.ScopeType.Global], exec_state);
           CheckScopeContent({e:'Exception'}, 0, exec_state);
         });