[proxies] [tests] Un-skip proxies-with-unscopables, delete proxies-symbols

test/mjsunit/harmony/proxies-with-unscopables.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: --harmony-proxies
 
 
-// TODO(arv): Once proxies can intercept symbols, add more tests.
+function str(x) {
+  if (typeof x === "symbol") return "<Symbol>";
+  return "" + x;
+}
 

[neis, 2015/12/14 15:53:55]

Why not use String(x)?  Then you can test for "Symbol(Symbol.unscopables)".

[Jakob Kummerow, 2015/12/14 15:59:12]

Done.

 
 function TestBasics() {
   var log = [];
 
   var proxy = new Proxy({}, {
-    getPropertyDescriptor: function(key) {
-      log.push(key);
-      if (key === 'x') {
-        return {
-          value: 1,
-          configurable: true
-        };
-      }
-      return undefined;
+    get: function(target, key) {
+      log.push("get " + str(key));
+      if (key === 'x') return 1;
+    },
+    has: function(target, key) {
+      log.push("has " + str(key));
+      if (key === 'x') return true;
+      return false;
     }
   });
 
   var x = 'local';
 
   with (proxy) {
     assertEquals(1, x);
   }
 
-  // One 'x' for HasBinding and one for GetBindingValue
-  assertEquals(['assertEquals', 'x', 'x'], log);
+  assertEquals(['has assertEquals', 'has x', 'get <Symbol>', 'get x'], log);
 }
 TestBasics();
 
 
 function TestInconsistent() {
   var log = [];
-  var calls = 0;
 
   var proxy = new Proxy({}, {
-    getPropertyDescriptor: function(key) {
-      log.push(key);
-      if (key === 'x' && calls < 1) {
-        calls++;
-        return {
-          value: 1,
-          configurable: true
-        };
-      }
+    get: function(target, key) {
+      log.push("get " + str(key));
       return undefined;
+    },
+    has: function(target, key) {
+      log.push("has " + str(key));
+      if (key === 'x') return true;
+      return false;
     }
   });
 
   var x = 'local';
 
   with (proxy) {
     assertEquals(void 0, x);
   }
 
-  // One 'x' for HasBinding and one for GetBindingValue
-  assertEquals(['assertEquals', 'x', 'x'], log);
+  assertEquals(['has assertEquals', 'has x', 'get <Symbol>', 'get x'], log);
 }
 TestInconsistent();
 
 
 function TestUseProxyAsUnscopables() {
   var x = 1;
   var object = {
     x: 2
   };
   var calls = 0;
   var proxy = new Proxy({}, {
-    has: function(key) {
+    has: function() {
       assertUnreachable();
     },
-    getPropertyDescriptor: function(key) {
+    get: function(target, key) {
+      assertEquals('x', key);
       calls++;
-      assertEquals('x', key);
-      return {
-        value: calls === 2 ? true : undefined,
-        configurable: true,
-        enumerable: true,
-        writable: true,
-      };
+      return calls === 2 ? true : undefined;
     }
   });
 
   object[Symbol.unscopables] = proxy;
 
   with (object) {
     assertEquals(2, x);
     assertEquals(1, x);
   }
 
   // HasBinding, HasBinding
   assertEquals(2, calls);
 }
 TestUseProxyAsUnscopables();
 
 
 function TestThrowInHasUnscopables() {
   var x = 1;
   var object = {
     x: 2
   };
 
   function CustomError() {}
 
   var calls = 0;
   var proxy = new Proxy({}, {
-    has: function(key) {
+    has: function() {
       assertUnreachable();
     },
-    getPropertyDescriptor: function(key) {
+    get: function(target, key) {
       if (calls++ === 0) {
         throw new CustomError();
       }
       assertUnreachable();
     }
   });
 
   object[Symbol.unscopables] = proxy;
 
   assertThrows(function() {
     with (object) {
       x;
     }
   }, CustomError);
 }
 TestThrowInHasUnscopables();
 
 
 var global = this;
 function TestGlobalShouldIgnoreUnscopables() {
   global.x = 1;
   var proxy = new Proxy({}, {
-    getPropertyDescriptor: function() {
+    get: function() {
+      assertUnreachable();
+    },
+    has: function() {
       assertUnreachable();
     }
   });
   global[Symbol.unscopables] = proxy;
 
   assertEquals(1, global.x);
   assertEquals(1, x);
 
   global.x = 2;
   assertEquals(2, global.x);
   assertEquals(2, x);
 
   x = 3;
   assertEquals(3, global.x);
   assertEquals(3, x);
 }
 TestGlobalShouldIgnoreUnscopables();