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   // Normally a static prototype property is not allowed.
 316   class C {
 317     static ['prototype']() {
 318       return 1;
 319     }
 320   }
 321   assertEquals(1, C.prototype());
 322
 323   class C2 {
 324     static get ['prototype']() {
 325       return 2;
 326     }
 327   }
 328   assertEquals(2, C2.prototype);
 329
 330   var calls = 0;
 331   class C3 {
 332     static set ['prototype'](x) {
 333       assertEquals(3, x);
 334       calls++;
 335     }
 336   }
 337   C3.prototype = 3;
 338   assertEquals(1, calls);
 339
 340   class C4 {
 341     static *['prototype']() {
 342       yield 1;
 343       yield 2;
 344     }
 345   }
 346   var iter = C4.prototype();
 347   assertIteratorResult(1, false, iter.next());
 348   assertIteratorResult(2, false, iter.next());
 349   assertIteratorResult(undefined, true, iter.next());
 350 })();
 351
 352
 353 (function TestConstructor() {
 354   // Normally a constructor property is not allowed.
 355   class C {
 356     ['constructor']() {
 357       return 1;
 358     }
 359   }
 360   assertTrue(C !== C.prototype.constructor);
 361   assertEquals(1, new C().constructor());
 362
 363   class C2 {
 364     get ['constructor']() {
 365       return 2;
 366     }
 367   }
 368   assertEquals(2, new C2().constructor);
 369
 370   var calls = 0;
 371   class C3 {
 372     set ['constructor'](x) {
 373       assertEquals(3, x);
 374       calls++;
 375     }
 376   }
 377   new C3().constructor = 3;
 378   assertEquals(1, calls);
 379
 380   class C4 {
 381     *['constructor']() {
 382       yield 1;
 383       yield 2;
 384     }
 385   }
 386   var iter = new C4().constructor();
 387   assertIteratorResult(1, false, iter.next());
 388   assertIteratorResult(2, false, iter.next());
 389   assertIteratorResult(undefined, true, iter.next());
 390 })();