[es6] Implement parts of the Reflect object.

test/mjsunit/harmony/reflect.js

+// Copyright 2015 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-reflect --harmony
+
+// TODO(neis): Test with proxies.
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// (Auxiliaries)
+
+
+var global = this;
+
+var sym = Symbol("gaga");
+
+var objects = [
+  {},
+  [],
+  function() {},
+  function() {
+    return arguments;
+  }(),
+  function() {
+    'use strict';
+    return arguments;
+  }(),
+  Object(1),
+  Object(true),
+  Object('bla'),
+  new Date,
+  new RegExp,
+  new Set,
+  new Map,
+  new WeakMap,
+  new WeakSet,
+  new ArrayBuffer(10),
+  new Int32Array(5),
+  Object,
+  Function,
+  Date,
+  RegExp,
+  global
+];
+
+function prepare(tgt) {
+  tgt["bla"] = true;
+  tgt[4] = 42;
+  tgt[sym] = "foo";
+  tgt["noconf"] = 43;
+  Object.defineProperty(tgt, "noconf", {configurable: false});
+  return tgt;
+}
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Reflect.get
+
+
+(function testReflectGetArity() {
+  assertEquals(3, Reflect.get.length);
+})();
+
+
+(function testReflectGetOnNonObject() {
+  assertThrows(function() { Reflect.get(); }, TypeError);
+  assertThrows(function() { Reflect.get(42, "bla"); }, TypeError);
+  assertThrows(function() { Reflect.get(null, "bla"); }, TypeError);
+})();
+
+
+(function testReflectGetKeyConversion() {
+  var tgt = {bla: 42};
+  var a = { [Symbol.toPrimitive]: function() { return "bla" } };
+  var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
+  assertEquals(42, Reflect.get(tgt, a));
+  assertThrows(function() { Reflect.get(tgt, b); }, "gaga");
+})();
+
+
+(function testReflectGetOnObject() {
+  for (let obj of objects) {
+    var tgt = prepare(obj);

[rossberg, 2015/10/07 11:15:02]

Nit: no need for this extra binding, or 'prepare' returning its argument. ;)

+    assertEquals(true, Reflect.get(tgt, "bla"));
+    assertEquals(42, Reflect.get(tgt, 4));
+    assertEquals(42, Reflect.get(tgt, "4"));
+    assertEquals("foo", Reflect.get(tgt, sym));
+    assertEquals(undefined, Reflect.get(tgt, "doesnotexist"));
+    assertEquals(undefined, Reflect.get(tgt, 666));
+  }
+})();
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Reflect.has
+
+
+(function testReflectHasArity() {
+  assertEquals(2, Reflect.has.length);
+})();
+
+
+(function testReflectHasOnNonObject() {
+  assertThrows(function() { Reflect.has(); }, TypeError);
+  assertThrows(function() { Reflect.has(42, "bla"); }, TypeError);
+  assertThrows(function() { Reflect.has(null, "bla"); }, TypeError);
+})();
+
+
+(function testReflectHasKeyConversion() {
+  var tgt = {bla: 42};
+  var a = { [Symbol.toPrimitive]: function() { return "bla" } };
+  var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
+  assertTrue(Reflect.has(tgt, a));
+  assertThrows(function() { Reflect.has(tgt, b); }, "gaga");
+})();
+
+
+(function testReflectHasOnObject() {
+  for (let obj of objects) {
+    var tgt = prepare(obj);
+    assertTrue(Reflect.has(tgt, "bla"));
+    assertTrue(Reflect.has(tgt, 4));
+    assertTrue(Reflect.has(tgt, "4"));
+    assertTrue(Reflect.has(tgt, sym));
+    assertFalse(Reflect.has(tgt, "doesnotexist"));
+    assertFalse(Reflect.has(tgt, 666));
+  }
+})();
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Reflect.deleteProperty
+
+
+(function testReflectDeletePropertyArity() {
+  assertEquals(2, Reflect.deleteProperty.length);
+})();
+
+
+(function testReflectDeletePropertyOnNonObject() {
+  assertThrows(function() { Reflect.deleteProperty(); }, TypeError);
+  assertThrows(function() { Reflect.deleteProperty(42, "bla"); }, TypeError);
+  assertThrows(function() { Reflect.deleteProperty(null, "bla"); }, TypeError);
+})();
+
+
+(function testReflectDeletePropertyKeyConversion() {
+  var tgt = {bla: 42};
+  var a = { [Symbol.toPrimitive]: function() { return "bla" } };
+  var b = { [Symbol.toPrimitive]: function() { throw "gaga" } };
+  assertTrue(Reflect.deleteProperty(tgt, a));
+  assertThrows(function() { Reflect.deleteProperty(tgt, b); }, "gaga");
+})();
+
+
+(function testReflectDeletePropertyOnObject() {
+  for (let obj of objects) {
+    var tgt = prepare(obj);
+    assertTrue(Reflect.deleteProperty(tgt, "bla"));
+    assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, "bla"));
+    if (tgt instanceof Int32Array) {
+      assertFalse(Reflect.deleteProperty(tgt, 4));
+    } else {
+      assertTrue(Reflect.deleteProperty(tgt, 4));
+      assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, 4));
+    }
+    assertTrue(Reflect.deleteProperty(tgt, sym));
+    assertEquals(undefined, Object.getOwnPropertyDescriptor(tgt, sym));
+    assertTrue(Reflect.deleteProperty(tgt, "doesnotexist"));
+    assertTrue(Reflect.deleteProperty(tgt, 666));
+    assertFalse(Reflect.deleteProperty(tgt, "noconf"));
+    assertEquals(43, tgt.noconf);
+  }
+})();
+
+
+
+////////////////////////////////////////////////////////////////////////////////
+// Reflect.isExtensible
+
+
+(function testReflectIsExtensibleArity() {
+  assertEquals(1, Reflect.isExtensible.length);
+})();
+
+
+(function testReflectIsExtensibleOnNonObject() {
+  assertThrows(function() { Reflect.isExtensible(); }, TypeError);
+  assertThrows(function() { Reflect.isExtensible(42); }, TypeError);
+  assertThrows(function() { Reflect.isExtensible(null); }, TypeError);
+})();
+
+
+(function testReflectIsExtensibleOnObject() {
+  // This should be the last test as it modifies the objects irreversibly.
+  for (let obj of objects) {
+    var tgt = prepare(obj);
+    if (tgt instanceof Int32Array) continue;  // issue v8:4460
+    assertTrue(Reflect.isExtensible(tgt));
+    Object.preventExtensions(tgt);
+    assertFalse(Reflect.isExtensible(tgt));
+  }
+})();