deps/v8/test/mjsunit/harmony/computed-property-names-classes.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 'use strict';
   6
   7 // Flags: --harmony-computed-property-names --harmony-classes
   8
   9
  10 function ID(x) {
  11   return x;
  12 }
  13
  14
  15 (function TestClassMethodString() {
  16   class C {
  17     a() { return 'A'}
  18     ['b']() { return 'B'; }
  19     c() { return 'C'; }
  20     [ID('d')]() { return 'D'; }
  21   }
  22   assertEquals('A', new C().a());
  23   assertEquals('B', new C().b());
  24   assertEquals('C', new C().c());
  25   assertEquals('D', new C().d());
  26   assertArrayEquals([], Object.keys(C.prototype));
  27   assertArrayEquals(['constructor', 'a', 'b', 'c', 'd'],
  28                     Object.getOwnPropertyNames(C.prototype));
  29 })();
  30
  31
  32 (function TestClassMethodNumber() {
  33   class C {
  34     a() { return 'A'; }
  35     [1]() { return 'B'; }
  36     c() { return 'C'; }
  37     [ID(2)]() { return 'D'; }
  38   }
  39   assertEquals('A', new C().a());
  40   assertEquals('B', new C()[1]());
  41   assertEquals('C', new C().c());
  42   assertEquals('D', new C()[2]());
  43   // Array indexes first.
  44   assertArrayEquals([], Object.keys(C.prototype));
  45   assertArrayEquals(['1', '2', 'constructor', 'a', 'c'],
  46                     Object.getOwnPropertyNames(C.prototype));
  47 })();
  48
  49
  50 (function TestClassMethodSymbol() {
  51   var sym1 = Symbol();
  52   var sym2 = Symbol();
  53   class C {
  54     a() { return 'A'; }
  55     [sym1]() { return 'B'; }
  56     c() { return 'C'; }
  57     [ID(sym2)]() { return 'D'; }
  58   }
  59   assertEquals('A', new C().a());
  60   assertEquals('B', new C()[sym1]());
  61   assertEquals('C', new C().c());
  62   assertEquals('D', new C()[sym2]());
  63   assertArrayEquals([], Object.keys(C.prototype));
  64   assertArrayEquals(['constructor', 'a', 'c'],
  65                     Object.getOwnPropertyNames(C.prototype));
  66   assertArrayEquals([sym1, sym2], Object.getOwnPropertySymbols(C.prototype));
  67 })();
  68
  69
  70
  71 (function TestStaticClassMethodString() {
  72   class C {
  73     static a() { return 'A'}
  74     static ['b']() { return 'B'; }
  75     static c() { return 'C'; }
  76     static ['d']() { return 'D'; }
  77   }
  78   assertEquals('A', C.a());
  79   assertEquals('B', C.b());
  80   assertEquals('C', C.c());
  81   assertEquals('D', C.d());
  82   assertArrayEquals([], Object.keys(C));
  83   // TODO(arv): It is not clear that we are adding the "standard" properties
  84   // in the right order. As far as I can tell the spec adds them in alphabetical
  85   // order.
  86   assertArrayEquals(['length', 'name', 'arguments', 'caller', 'prototype',
  87       'a', 'b', 'c', 'd'],
  88       Object.getOwnPropertyNames(C));
  89 })();
  90
  91
  92 (function TestStaticClassMethodNumber() {
  93   class C {
  94     static a() { return 'A'; }
  95     static [1]() { return 'B'; }
  96     static c() { return 'C'; }
  97     static [2]() { return 'D'; }
  98   }
  99   assertEquals('A', C.a());
 100   assertEquals('B', C[1]());
 101   assertEquals('C', C.c());
 102   assertEquals('D', C[2]());
 103   // Array indexes first.
 104   assertArrayEquals([], Object.keys(C));
 105   assertArrayEquals(['1', '2', 'length', 'name', 'arguments', 'caller',
 106       'prototype', 'a', 'c'], Object.getOwnPropertyNames(C));
 107 })();
 108
 109
 110 (function TestStaticClassMethodSymbol() {
 111   var sym1 = Symbol();
 112   var sym2 = Symbol();
 113   class C {
 114     static a() { return 'A'; }
 115     static [sym1]() { return 'B'; }
 116     static c() { return 'C'; }
 117     static [sym2]() { return 'D'; }
 118   }
 119   assertEquals('A', C.a());
 120   assertEquals('B', C[sym1]());
 121   assertEquals('C', C.c());
 122   assertEquals('D', C[sym2]());
 123   assertArrayEquals([], Object.keys(C));
 124   assertArrayEquals(['length', 'name', 'arguments', 'caller', 'prototype',
 125       'a', 'c'],
 126       Object.getOwnPropertyNames(C));
 127   assertArrayEquals([sym1, sym2], Object.getOwnPropertySymbols(C));
 128 })();
 129
 130
 131
 132 function assertIteratorResult(value, done, result) {
 133   assertEquals({ value: value, done: done}, result);
 134 }
 135
 136
 137 (function TestGeneratorComputedName() {
 138   class C {
 139     *['a']() {
 140       yield 1;
 141       yield 2;
 142     }
 143   }
 144   var iter = new C().a();
 145   assertIteratorResult(1, false, iter.next());
 146   assertIteratorResult(2, false, iter.next());
 147   assertIteratorResult(undefined, true, iter.next());
 148   assertArrayEquals([], Object.keys(C.prototype));
 149   assertArrayEquals(['constructor', 'a'],
 150                     Object.getOwnPropertyNames(C.prototype));
 151 })();
 152
 153
 154 (function TestToNameSideEffects() {
 155   var counter = 0;
 156   var key1 = {
 157     toString: function() {
 158       assertEquals(0, counter++);
 159       return 'b';
 160     }
 161   };
 162   var key2 = {
 163     toString: function() {
 164       assertEquals(1, counter++);
 165       return 'd';
 166     }
 167   };
 168   class C {
 169     a() { return 'A'; }
 170     [key1]() { return 'B'; }
 171     c() { return 'C'; }
 172     [key2]() { return 'D'; }
 173   }
 174   assertEquals(2, counter);
 175   assertEquals('A', new C().a());
 176   assertEquals('B', new C().b());
 177   assertEquals('C', new C().c());
 178   assertEquals('D', new C().d());
 179   assertArrayEquals([], Object.keys(C.prototype));
 180   assertArrayEquals(['constructor', 'a', 'b', 'c', 'd'],
 181                     Object.getOwnPropertyNames(C.prototype));
 182 })();
 183
 184
 185 (function TestToNameSideEffectsNumbers() {
 186   var counter = 0;
 187   var key1 = {
 188     valueOf: function() {
 189       assertEquals(0, counter++);
 190       return 1;
 191     },
 192     toString: null
 193   };
 194   var key2 = {
 195     valueOf: function() {
 196       assertEquals(1, counter++);
 197       return 2;
 198     },
 199     toString: null
 200   };
 201
 202   class C {
 203     a() { return 'A'; }
 204     [key1]() { return 'B'; }
 205     c() { return 'C'; }
 206     [key2]() { return 'D'; }
 207   }
 208   assertEquals(2, counter);
 209   assertEquals('A', new C().a());
 210   assertEquals('B', new C()[1]());
 211   assertEquals('C', new C().c());
 212   assertEquals('D', new C()[2]());
 213   // Array indexes first.
 214   assertArrayEquals([], Object.keys(C.prototype));
 215   assertArrayEquals(['1', '2', 'constructor', 'a', 'c'],
 216                     Object.getOwnPropertyNames(C.prototype));
 217 })();
 218
 219
 220 (function TestGetter() {
 221   class C {
 222     get ['a']() {
 223       return 'A';
 224     }
 225   }
 226   assertEquals('A', new C().a);
 227
 228   class C2 {
 229     get b() {
 230       assertUnreachable();
 231     }
 232     get ['b']() {
 233       return 'B';
 234     }
 235   }
 236   assertEquals('B', new C2().b);
 237
 238   class C3 {
 239     get c() {
 240       assertUnreachable();
 241     }
 242     get ['c']() {
 243       assertUnreachable();
 244     }
 245     get ['c']() {
 246       return 'C';
 247     }
 248   }
 249   assertEquals('C', new C3().c);
 250
 251   class C4 {
 252     get ['d']() {
 253       assertUnreachable();
 254     }
 255     get d() {
 256       return 'D';
 257     }
 258   }
 259   assertEquals('D', new C4().d);
 260 })();
 261
 262
 263 (function TestSetter() {
 264   var calls = 0;
 265   class C {
 266     set ['a'](_) {
 267       calls++;
 268     }
 269   }
 270   new C().a = 'A';
 271   assertEquals(1, calls);
 272
 273   calls = 0;
 274   class C2 {
 275     set b(_) {
 276       assertUnreachable();
 277     }
 278     set ['b'](_) {
 279       calls++;
 280     }
 281   }
 282   new C2().b = 'B';
 283   assertEquals(1, calls);
 284
 285   calls = 0;
 286   class C3 {
 287     set c(_) {
 288       assertUnreachable()
 289     }
 290     set ['c'](_) {
 291       assertUnreachable()
 292     }
 293     set ['c'](_) {
 294       calls++
 295     }
 296   }
 297   new C3().c = 'C';
 298   assertEquals(1, calls);
 299
 300   calls = 0;
 301   class C4 {
 302     set ['d'](_) {
 303       assertUnreachable()
 304     }
 305     set d(_) {
 306       calls++
 307     }
 308   }
 309   new C4().d = 'D';
 310   assertEquals(1, calls);
 311 })();
 312
 313
 314 (function TestPrototype() {
 315   assertThrows(function() {
 316     class C {
 317       static ['prototype']() {
 318         return 1;
 319       }
 320     }
 321   }, TypeError);
 322
 323   assertThrows(function() {
 324     class C2 {
 325       static get ['prototype']() {
 326         return 2;
 327       }
 328     }
 329   }, TypeError);
 330
 331   assertThrows(function() {
 332     class C3 {
 333       static set ['prototype'](x) {
 334         assertEquals(3, x);
 335       }
 336     }
 337   }, TypeError);
 338
 339   assertThrows(function() {
 340     class C4 {
 341       static *['prototype']() {
 342         yield 1;
 343         yield 2;
 344       }
 345     }
 346   }, TypeError);
 347 })();
 348
 349
 350 (function TestPrototypeConcat() {
 351   assertThrows(function() {
 352     class C {
 353       static ['pro' + 'tot' + 'ype']() {
 354         return 1;
 355       }
 356     }
 357   }, TypeError);
 358
 359   assertThrows(function() {
 360     class C2 {
 361       static get ['pro' + 'tot' + 'ype']() {
 362         return 2;
 363       }
 364     }
 365   }, TypeError);
 366
 367   assertThrows(function() {
 368     class C3 {
 369       static set ['pro' + 'tot' + 'ype'](x) {
 370         assertEquals(3, x);
 371       }
 372     }
 373   }, TypeError);
 374
 375   assertThrows(function() {
 376     class C4 {
 377       static *['pro' + 'tot' + 'ype']() {
 378         yield 1;
 379         yield 2;
 380       }
 381     }
 382   }, TypeError);
 383 })();
 384
 385
 386 (function TestConstructor() {
 387   // Normally a constructor property is not allowed.
 388   class C {
 389     ['constructor']() {
 390       return 1;
 391     }
 392   }
 393   assertTrue(C !== C.prototype.constructor);
 394   assertEquals(1, new C().constructor());
 395
 396   class C2 {
 397     get ['constructor']() {
 398       return 2;
 399     }
 400   }
 401   assertEquals(2, new C2().constructor);
 402
 403   var calls = 0;
 404   class C3 {
 405     set ['constructor'](x) {
 406       assertEquals(3, x);
 407       calls++;
 408     }
 409   }
 410   new C3().constructor = 3;
 411   assertEquals(1, calls);
 412
 413   class C4 {
 414     *['constructor']() {
 415       yield 1;
 416       yield 2;
 417     }
 418   }
 419   var iter = new C4().constructor();
 420   assertIteratorResult(1, false, iter.next());
 421   assertIteratorResult(2, false, iter.next());
 422   assertIteratorResult(undefined, true, iter.next());
 423 })();
 424
 425
 426 (function TestExceptionInName() {
 427   function MyError() {};
 428   function throwMyError() {
 429     throw new MyError();
 430   }
 431   assertThrows(function() {
 432     class C {
 433       [throwMyError()]() {}
 434     }
 435   }, MyError);
 436   assertThrows(function() {
 437     class C {
 438       get [throwMyError()]() { return 42; }
 439     }
 440   }, MyError);
 441   assertThrows(function() {
 442     class C {
 443       set [throwMyError()](_) { }
 444     }
 445   }, MyError);
 446 })();
 447
 448
 449 (function TestTdzName() {
 450   assertThrows(function() {
 451     class C {
 452       [C]() {}
 453     }
 454   }, ReferenceError);
 455   assertThrows(function() {
 456     class C {
 457       get [C]() { return 42; }
 458     }
 459   }, ReferenceError);
 460   assertThrows(function() {
 461     class C {
 462       set [C](_) { }
 463     }
 464   }, ReferenceError);
 465 })();