deps/v8/test/mjsunit/harmony/computed-property-names.js

   1 // Copyright 2014 the V8 project authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // Flags: --harmony-computed-property-names
   6
   7
   8 function ID(x) {
   9   return x;
  10 }
  11
  12
  13
  14 (function TestBasicsString() {
  15   var object = {
  16     a: 'A',
  17     ['b']: 'B',
  18     c: 'C',
  19     [ID('d')]: 'D',
  20   };
  21   assertEquals('A', object.a);
  22   assertEquals('B', object.b);
  23   assertEquals('C', object.c);
  24   assertEquals('D', object.d);
  25   assertArrayEquals(['a', 'b', 'c', 'd'], Object.keys(object));
  26 })();
  27
  28
  29 (function TestBasicsNumber() {
  30   var object = {
  31     a: 'A',
  32     [1]: 'B',
  33     c: 'C',
  34     [ID(2)]: 'D',
  35   };
  36   assertEquals('A', object.a);
  37   assertEquals('B', object[1]);
  38   assertEquals('C', object.c);
  39   assertEquals('D', object[2]);
  40   // Array indexes first.
  41   assertArrayEquals(['1', '2', 'a', 'c'], Object.keys(object));
  42 })();
  43
  44
  45 (function TestBasicsSymbol() {
  46   var sym1 = Symbol();
  47   var sym2 = Symbol();
  48   var object = {
  49     a: 'A',
  50     [sym1]: 'B',
  51     c: 'C',
  52     [ID(sym2)]: 'D',
  53   };
  54   assertEquals('A', object.a);
  55   assertEquals('B', object[sym1]);
  56   assertEquals('C', object.c);
  57   assertEquals('D', object[sym2]);
  58   assertArrayEquals(['a', 'c'], Object.keys(object));
  59   assertArrayEquals([sym1, sym2], Object.getOwnPropertySymbols(object));
  60 })();
  61
  62
  63 (function TestToNameSideEffects() {
  64   var counter = 0;
  65   var key1 = {
  66     toString: function() {
  67       assertEquals(0, counter++);
  68       return 'b';
  69     }
  70   };
  71   var key2 = {
  72     toString: function() {
  73       assertEquals(1, counter++);
  74       return 'd';
  75     }
  76   };
  77   var object = {
  78     a: 'A',
  79     [key1]: 'B',
  80     c: 'C',
  81     [key2]: 'D',
  82   };
  83   assertEquals(2, counter);
  84   assertEquals('A', object.a);
  85   assertEquals('B', object.b);
  86   assertEquals('C', object.c);
  87   assertEquals('D', object.d);
  88   assertArrayEquals(['a', 'b', 'c', 'd'], Object.keys(object));
  89 })();
  90
  91
  92 (function TestToNameSideEffectsNumbers() {
  93   var counter = 0;
  94   var key1 = {
  95     valueOf: function() {
  96       assertEquals(0, counter++);
  97       return 1;
  98     },
  99     toString: null
 100   };
 101   var key2 = {
 102     valueOf: function() {
 103       assertEquals(1, counter++);
 104       return 2;
 105     },
 106     toString: null
 107   };
 108
 109   var object = {
 110     a: 'A',
 111     [key1]: 'B',
 112     c: 'C',
 113     [key2]: 'D',
 114   };
 115   assertEquals(2, counter);
 116   assertEquals('A', object.a);
 117   assertEquals('B', object[1]);
 118   assertEquals('C', object.c);
 119   assertEquals('D', object[2]);
 120   // Array indexes first.
 121   assertArrayEquals(['1', '2', 'a', 'c'], Object.keys(object));
 122 })();
 123
 124
 125 (function TestDoubleName() {
 126   var object = {
 127     [1.2]: 'A',
 128     [1e55]: 'B',
 129     [0.000001]: 'C',
 130     [-0]: 'D',
 131     // TODO(arv): https://code.google.com/p/v8/issues/detail?id=3815
 132     // [Infinity]: 'E',
 133     // [-Infinity]: 'F',
 134     [NaN]: 'G',
 135   };
 136   assertEquals('A', object['1.2']);
 137   assertEquals('B', object['1e+55']);
 138   assertEquals('C', object['0.000001']);
 139   assertEquals('D', object[0]);
 140   // TODO(arv): https://code.google.com/p/v8/issues/detail?id=3815
 141   // assertEquals('E', object[Infinity]);
 142   // assertEquals('F', object[-Infinity]);
 143   assertEquals('G', object[NaN]);
 144 })();
 145
 146
 147 (function TestGetter() {
 148   var object = {
 149     get ['a']() {
 150       return 'A';
 151     }
 152   };
 153   assertEquals('A', object.a);
 154
 155   object = {
 156     get b() {
 157       assertUnreachable();
 158     },
 159     get ['b']() {
 160       return 'B';
 161     }
 162   };
 163   assertEquals('B', object.b);
 164
 165   object = {
 166     get c() {
 167       assertUnreachable();
 168     },
 169     get ['c']() {
 170       assertUnreachable();
 171     },
 172     get ['c']() {
 173       return 'C';
 174     }
 175   };
 176   assertEquals('C', object.c);
 177
 178   object = {
 179     get ['d']() {
 180       assertUnreachable();
 181     },
 182     get d() {
 183       return 'D';
 184     }
 185   };
 186   assertEquals('D', object.d);
 187 })();
 188
 189
 190 (function TestSetter() {
 191   var calls = 0;
 192   var object = {
 193     set ['a'](_) {
 194       calls++;
 195     }
 196   };
 197   object.a = 'A';
 198   assertEquals(1, calls);
 199
 200   calls = 0;
 201   object = {
 202     set b(_) {
 203       assertUnreachable();
 204     },
 205     set ['b'](_) {
 206       calls++;
 207     }
 208   };
 209   object.b = 'B';
 210   assertEquals(1, calls);
 211
 212   calls = 0;
 213   object = {
 214     set c(_) {
 215       assertUnreachable()
 216     },
 217     set ['c'](_) {
 218       assertUnreachable()
 219     },
 220     set ['c'](_) {
 221       calls++
 222     }
 223   };
 224   object.c = 'C';
 225   assertEquals(1, calls);
 226
 227   calls = 0;
 228   object = {
 229     set ['d'](_) {
 230       assertUnreachable()
 231     },
 232     set d(_) {
 233       calls++
 234     }
 235   };
 236   object.d = 'D';
 237   assertEquals(1, calls);
 238 })();
 239
 240
 241 (function TestDuplicateKeys() {
 242   'use strict';
 243   // ES5 does not allow duplicate keys.
 244   // ES6 does but we haven't changed our code yet.
 245
 246   var object = {
 247     a: 1,
 248     ['a']: 2,
 249   };
 250   assertEquals(2, object.a);
 251 })();
 252
 253
 254 (function TestProto() {
 255   var proto = {};
 256   var object = {
 257     __proto__: proto
 258   };
 259   assertEquals(proto, Object.getPrototypeOf(object));
 260
 261   object = {
 262     '__proto__': proto
 263   };
 264   assertEquals(proto, Object.getPrototypeOf(object));
 265
 266   object = {
 267     ['__proto__']: proto
 268   };
 269   assertEquals(Object.prototype, Object.getPrototypeOf(object));
 270   assertEquals(proto, object.__proto__);
 271   assertTrue(object.hasOwnProperty('__proto__'));
 272
 273   object = {
 274     [ID('x')]: 'X',
 275     __proto__: proto
 276   };
 277   assertEquals('X', object.x);
 278   assertEquals(proto, Object.getPrototypeOf(object));
 279 })();