deps/v8/test/mjsunit/harmony/private.js

   1 // Copyright 2013 the V8 project authors. All rights reserved.
   2 // Redistribution and use in source and binary forms, with or without
   3 // modification, are permitted provided that the following conditions are
   4 // met:
   5 //
   6 //     * Redistributions of source code must retain the above copyright
   7 //       notice, this list of conditions and the following disclaimer.
   8 //     * Redistributions in binary form must reproduce the above
   9 //       copyright notice, this list of conditions and the following
  10 //       disclaimer in the documentation and/or other materials provided
  11 //       with the distribution.
  12 //     * Neither the name of Google Inc. nor the names of its
  13 //       contributors may be used to endorse or promote products derived
  14 //       from this software without specific prior written permission.
  15 //
  16 // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
  17 // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
  18 // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
  19 // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  20 // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  21 // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  22 // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  23 // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  24 // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  25 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  26 // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  27
  28 // Flags: --expose-gc --allow-natives-syntax
  29
  30 var symbols = []
  31
  32
  33 // Returns true if the string is a valid
  34 // serialization of Symbols added to the 'symbols'
  35 // array. Adjust if you extend 'symbols' with other
  36 // values.
  37 function isValidSymbolString(s) {
  38   return ["Symbol(66)"].indexOf(s) >= 0;
  39 }
  40
  41
  42 // Test different forms of constructor calls, all equivalent.
  43 function TestNew() {
  44   for (var i = 0; i < 2; ++i) {
  45     for (var j = 0; j < 5; ++j) {
  46       symbols.push(%CreatePrivateSymbol("66"))
  47       symbols.push(Object(%CreatePrivateSymbol("66")).valueOf())
  48     }
  49     gc()  // Promote existing symbols and then allocate some more.
  50   }
  51 }
  52 TestNew()
  53
  54
  55 function TestType() {
  56   for (var i in symbols) {
  57     assertEquals("symbol", typeof symbols[i])
  58     assertTrue(typeof symbols[i] === "symbol")
  59     assertTrue(%SymbolIsPrivate(symbols[i]))
  60     assertEquals(null, %_ClassOf(symbols[i]))
  61     assertEquals("Symbol", %_ClassOf(Object(symbols[i])))
  62   }
  63 }
  64 TestType()
  65
  66
  67 function TestPrototype() {
  68   for (var i in symbols) {
  69     assertSame(Symbol.prototype, symbols[i].__proto__)
  70   }
  71 }
  72 TestPrototype()
  73
  74
  75 function TestConstructor() {
  76   for (var i in symbols) {
  77     assertSame(Symbol, symbols[i].__proto__.constructor)
  78     assertSame(Symbol, Object(symbols[i]).__proto__.constructor)
  79   }
  80 }
  81 TestConstructor()
  82
  83
  84 function TestToString() {
  85   for (var i in symbols) {
  86     assertThrows(function() {new String(symbols[i]) }, TypeError)
  87     assertEquals(symbols[i].toString(), String(symbols[i]))
  88     assertThrows(function() { symbols[i] + "" }, TypeError)
  89     assertTrue(isValidSymbolString(symbols[i].toString()))
  90     assertTrue(isValidSymbolString(Object(symbols[i]).toString()))
  91     assertTrue(isValidSymbolString(Symbol.prototype.toString.call(symbols[i])))
  92     assertEquals(
  93         "[object Symbol]", Object.prototype.toString.call(symbols[i]))
  94   }
  95 }
  96 TestToString()
  97
  98
  99 function TestToBoolean() {
 100   for (var i in symbols) {
 101     assertTrue(Boolean(symbols[i]).valueOf())
 102     assertFalse(!symbols[i])
 103     assertTrue(!!symbols[i])
 104     assertTrue(symbols[i] && true)
 105     assertFalse(!symbols[i] && false)
 106     assertTrue(!symbols[i] || true)
 107     assertEquals(1, symbols[i] ? 1 : 2)
 108     assertEquals(2, !symbols[i] ? 1 : 2)
 109     if (!symbols[i]) assertUnreachable();
 110     if (symbols[i]) {} else assertUnreachable();
 111   }
 112 }
 113 TestToBoolean()
 114
 115
 116 function TestToNumber() {
 117   for (var i in symbols) {
 118     assertThrows(function() { Number(symbols[i]); }, TypeError);
 119     assertThrows(function() { symbols[i] + 0; }, TypeError);
 120   }
 121 }
 122 TestToNumber()
 123
 124
 125 function TestEquality() {
 126   // Every symbol should equal itself, and non-strictly equal its wrapper.
 127   for (var i in symbols) {
 128     assertSame(symbols[i], symbols[i])
 129     assertEquals(symbols[i], symbols[i])
 130     assertTrue(Object.is(symbols[i], symbols[i]))
 131     assertTrue(symbols[i] === symbols[i])
 132     assertTrue(symbols[i] == symbols[i])
 133     assertFalse(symbols[i] === Object(symbols[i]))
 134     assertFalse(Object(symbols[i]) === symbols[i])
 135     assertFalse(symbols[i] == Object(symbols[i]))
 136     assertFalse(Object(symbols[i]) == symbols[i])
 137     assertTrue(symbols[i] === symbols[i].valueOf())
 138     assertTrue(symbols[i].valueOf() === symbols[i])
 139     assertTrue(symbols[i] == symbols[i].valueOf())
 140     assertTrue(symbols[i].valueOf() == symbols[i])
 141   }
 142
 143   // All symbols should be distinct.
 144   for (var i = 0; i < symbols.length; ++i) {
 145     for (var j = i + 1; j < symbols.length; ++j) {
 146       assertFalse(Object.is(symbols[i], symbols[j]))
 147       assertFalse(symbols[i] === symbols[j])
 148       assertFalse(symbols[i] == symbols[j])
 149     }
 150   }
 151
 152   // Symbols should not be equal to any other value (and the test terminates).
 153   var values = [347, 1.275, NaN, "string", null, undefined, {}, function() {}]
 154   for (var i in symbols) {
 155     for (var j in values) {
 156       assertFalse(symbols[i] === values[j])
 157       assertFalse(values[j] === symbols[i])
 158       assertFalse(symbols[i] == values[j])
 159       assertFalse(values[j] == symbols[i])
 160     }
 161   }
 162 }
 163 TestEquality()
 164
 165
 166 function TestGet() {
 167   for (var i in symbols) {
 168     assertTrue(isValidSymbolString(symbols[i].toString()))
 169     assertEquals(symbols[i], symbols[i].valueOf())
 170     assertEquals(undefined, symbols[i].a)
 171     assertEquals(undefined, symbols[i]["a" + "b"])
 172     assertEquals(undefined, symbols[i]["" + "1"])
 173     assertEquals(undefined, symbols[i][62])
 174   }
 175 }
 176 TestGet()
 177
 178
 179 function TestSet() {
 180   for (var i in symbols) {
 181     symbols[i].toString = 0
 182     assertTrue(isValidSymbolString(symbols[i].toString()))
 183     symbols[i].valueOf = 0
 184     assertEquals(symbols[i], symbols[i].valueOf())
 185     symbols[i].a = 0
 186     assertEquals(undefined, symbols[i].a)
 187     symbols[i]["a" + "b"] = 0
 188     assertEquals(undefined, symbols[i]["a" + "b"])
 189     symbols[i][62] = 0
 190     assertEquals(undefined, symbols[i][62])
 191   }
 192 }
 193 TestSet()
 194
 195
 196 function TestCollections() {
 197   var set = new Set
 198   var map = new Map
 199   for (var i in symbols) {
 200     set.add(symbols[i])
 201     map.set(symbols[i], i)
 202   }
 203   assertEquals(symbols.length, set.size)
 204   assertEquals(symbols.length, map.size)
 205   for (var i in symbols) {
 206     assertTrue(set.has(symbols[i]))
 207     assertTrue(map.has(symbols[i]))
 208     assertEquals(i, map.get(symbols[i]))
 209   }
 210   for (var i in symbols) {
 211     assertTrue(set.delete(symbols[i]))
 212     assertTrue(map.delete(symbols[i]))
 213   }
 214   assertEquals(0, set.size)
 215   assertEquals(0, map.size)
 216 }
 217 TestCollections()
 218
 219
 220
 221 function TestKeySet(obj) {
 222   assertTrue(%HasFastProperties(obj))
 223   // Set the even symbols via assignment.
 224   for (var i = 0; i < symbols.length; i += 2) {
 225     obj[symbols[i]] = i
 226     // Object should remain in fast mode until too many properties were added.
 227     assertTrue(%HasFastProperties(obj) || i >= 30)
 228   }
 229 }
 230
 231
 232 function TestKeyDefine(obj) {
 233   // Set the odd symbols via defineProperty (as non-enumerable).
 234   for (var i = 1; i < symbols.length; i += 2) {
 235     Object.defineProperty(obj, symbols[i], {value: i, configurable: true})
 236   }
 237 }
 238
 239
 240 function TestKeyGet(obj) {
 241   var obj2 = Object.create(obj)
 242   for (var i in symbols) {
 243     assertEquals(i|0, obj[symbols[i]])
 244     assertEquals(i|0, obj2[symbols[i]])
 245   }
 246 }
 247
 248
 249 function TestKeyHas() {
 250   for (var i in symbols) {
 251     assertTrue(symbols[i] in obj)
 252     assertTrue(Object.hasOwnProperty.call(obj, symbols[i]))
 253   }
 254 }
 255
 256
 257 function TestKeyEnum(obj) {
 258   for (var name in obj) {
 259     assertEquals("string", typeof name)
 260   }
 261 }
 262
 263
 264 function TestKeyNames(obj) {
 265   assertEquals(0, Object.keys(obj).length)
 266
 267   var names = Object.getOwnPropertyNames(obj)
 268   for (var i in names) {
 269     assertEquals("string", typeof names[i])
 270   }
 271 }
 272
 273
 274 function TestKeyDescriptor(obj) {
 275   for (var i in symbols) {
 276     var desc = Object.getOwnPropertyDescriptor(obj, symbols[i]);
 277     assertEquals(i|0, desc.value)
 278     assertTrue(desc.configurable)
 279     assertEquals(i % 2 == 0, desc.writable)
 280     assertEquals(i % 2 == 0, desc.enumerable)
 281     assertEquals(i % 2 == 0,
 282         Object.prototype.propertyIsEnumerable.call(obj, symbols[i]))
 283   }
 284 }
 285
 286
 287 function TestKeyDelete(obj) {
 288   for (var i in symbols) {
 289     delete obj[symbols[i]]
 290   }
 291   for (var i in symbols) {
 292     assertEquals(undefined, Object.getOwnPropertyDescriptor(obj, symbols[i]))
 293   }
 294 }
 295
 296
 297 var objs = [{}, [], Object.create(null), Object(1), new Map, function(){}]
 298
 299 for (var i in objs) {
 300   var obj = objs[i]
 301   TestKeySet(obj)
 302   TestKeyDefine(obj)
 303   TestKeyGet(obj)
 304   TestKeyHas(obj)
 305   TestKeyEnum(obj)
 306   TestKeyNames(obj)
 307   TestKeyDescriptor(obj)
 308   TestKeyDelete(obj)
 309 }
 310
 311
 312 function TestCachedKeyAfterScavenge() {
 313   gc();
 314   // Keyed property lookup are cached.  Hereby we assume that the keys are
 315   // tenured, so that we only have to clear the cache between mark compacts,
 316   // but not between scavenges.  This must also apply for symbol keys.
 317   var key = Symbol("key");
 318   var a = {};
 319   a[key] = "abc";
 320
 321   for (var i = 0; i < 100000; i++) {
 322     a[key] += "a";  // Allocations cause a scavenge.
 323   }
 324 }
 325 TestCachedKeyAfterScavenge();
 326
 327
 328 function TestGetOwnPropertySymbols() {
 329   var privateSymbol = %CreatePrivateSymbol("private")
 330   var publicSymbol = Symbol()
 331   var publicSymbol2 = Symbol()
 332   var obj = {}
 333   obj[publicSymbol] = 1
 334   obj[privateSymbol] = 2
 335   obj[publicSymbol2] = 3
 336   var syms = Object.getOwnPropertySymbols(obj)
 337   assertEquals(syms, [publicSymbol, publicSymbol2])
 338 }
 339 TestGetOwnPropertySymbols()
 340
 341
 342 function TestSealAndFreeze(freeze) {
 343   var sym = %CreatePrivateSymbol("private")
 344   var obj = {}
 345   obj[sym] = 1
 346   freeze(obj)
 347   obj[sym] = 2
 348   assertEquals(2, obj[sym])
 349   assertTrue(delete obj[sym])
 350   assertEquals(undefined, obj[sym])
 351 }
 352 TestSealAndFreeze(Object.seal)
 353 TestSealAndFreeze(Object.freeze)
 354 TestSealAndFreeze(Object.preventExtensions)