| OLD | NEW |
| (Empty) |
| 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-object-literals --allow-natives-syntax | |
| 6 | |
| 7 | |
| 8 (function TestBasics() { | |
| 9 var object = { | |
| 10 method() { | |
| 11 return 42; | |
| 12 } | |
| 13 }; | |
| 14 assertEquals(42, object.method()); | |
| 15 })(); | |
| 16 | |
| 17 | |
| 18 (function TestThis() { | |
| 19 var object = { | |
| 20 method() { | |
| 21 assertEquals(object, this); | |
| 22 } | |
| 23 }; | |
| 24 object.method(); | |
| 25 })(); | |
| 26 | |
| 27 | |
| 28 (function TestDescriptor() { | |
| 29 var object = { | |
| 30 method() { | |
| 31 return 42; | |
| 32 } | |
| 33 }; | |
| 34 | |
| 35 var desc = Object.getOwnPropertyDescriptor(object, 'method'); | |
| 36 assertTrue(desc.enumerable); | |
| 37 assertTrue(desc.configurable); | |
| 38 assertTrue(desc.writable); | |
| 39 assertEquals('function', typeof desc.value); | |
| 40 | |
| 41 assertEquals(42, desc.value()); | |
| 42 })(); | |
| 43 | |
| 44 | |
| 45 (function TestProto() { | |
| 46 var object = { | |
| 47 method() {} | |
| 48 }; | |
| 49 | |
| 50 assertEquals(Function.prototype, Object.getPrototypeOf(object.method)); | |
| 51 })(); | |
| 52 | |
| 53 | |
| 54 (function TestNotConstructable() { | |
| 55 var object = { | |
| 56 method() {} | |
| 57 }; | |
| 58 | |
| 59 assertThrows(function() { | |
| 60 new object.method; | |
| 61 }); | |
| 62 })(); | |
| 63 | |
| 64 | |
| 65 (function TestFunctionName() { | |
| 66 var object = { | |
| 67 method() {}, | |
| 68 1() {}, | |
| 69 2.0() {} | |
| 70 }; | |
| 71 var f = object.method; | |
| 72 assertEquals('method', f.name); | |
| 73 var g = object[1]; | |
| 74 assertEquals('1', g.name); | |
| 75 var h = object[2]; | |
| 76 assertEquals('2', h.name); | |
| 77 })(); | |
| 78 | |
| 79 | |
| 80 (function TestNoBinding() { | |
| 81 var method = 'local'; | |
| 82 var calls = 0; | |
| 83 var object = { | |
| 84 method() { | |
| 85 calls++; | |
| 86 assertEquals('local', method); | |
| 87 } | |
| 88 }; | |
| 89 object.method(); | |
| 90 assertEquals(1, calls); | |
| 91 })(); | |
| 92 | |
| 93 | |
| 94 (function TestNoPrototype() { | |
| 95 var object = { | |
| 96 method() {} | |
| 97 }; | |
| 98 var f = object.method; | |
| 99 assertFalse(f.hasOwnProperty('prototype')); | |
| 100 assertEquals(undefined, f.prototype); | |
| 101 | |
| 102 f.prototype = 42; | |
| 103 assertEquals(42, f.prototype); | |
| 104 })(); | |
| 105 | |
| 106 | |
| 107 (function TestNoRestrictedPropertiesStrict() { | |
| 108 var obj = { | |
| 109 method() { "use strict"; } | |
| 110 }; | |
| 111 assertFalse(obj.method.hasOwnProperty("arguments")); | |
| 112 assertThrows(function() { return obj.method.arguments; }, TypeError); | |
| 113 assertThrows(function() { obj.method.arguments = {}; }, TypeError); | |
| 114 | |
| 115 assertFalse(obj.method.hasOwnProperty("caller")); | |
| 116 assertThrows(function() { return obj.method.caller; }, TypeError); | |
| 117 assertThrows(function() { obj.method.caller = {}; }, TypeError); | |
| 118 })(); | |
| 119 | |
| 120 | |
| 121 (function TestNoRestrictedPropertiesSloppy() { | |
| 122 var obj = { | |
| 123 method() {} | |
| 124 }; | |
| 125 assertFalse(obj.method.hasOwnProperty("arguments")); | |
| 126 assertThrows(function() { return obj.method.arguments; }, TypeError); | |
| 127 assertThrows(function() { obj.method.arguments = {}; }, TypeError); | |
| 128 | |
| 129 assertFalse(obj.method.hasOwnProperty("caller")); | |
| 130 assertThrows(function() { return obj.method.caller; }, TypeError); | |
| 131 assertThrows(function() { obj.method.caller = {}; }, TypeError); | |
| 132 })(); | |
| 133 | |
| 134 | |
| 135 (function TestToString() { | |
| 136 var object = { | |
| 137 method() { 42; } | |
| 138 }; | |
| 139 assertEquals('method() { 42; }', object.method.toString()); | |
| 140 })(); | |
| 141 | |
| 142 | |
| 143 (function TestOptimized() { | |
| 144 var object = { | |
| 145 method() { return 42; } | |
| 146 }; | |
| 147 assertEquals(42, object.method()); | |
| 148 assertEquals(42, object.method()); | |
| 149 %OptimizeFunctionOnNextCall(object.method); | |
| 150 assertEquals(42, object.method()); | |
| 151 assertFalse(object.method.hasOwnProperty('prototype')); | |
| 152 })(); | |
| 153 | |
| 154 | |
| 155 /////////////////////////////////////////////////////////////////////////////// | |
| 156 | |
| 157 | |
| 158 var GeneratorFunction = function*() {}.__proto__.constructor; | |
| 159 var GeneratorPrototype = Object.getPrototypeOf(function*() {}).prototype; | |
| 160 | |
| 161 | |
| 162 function assertIteratorResult(value, done, result) { | |
| 163 assertEquals({value: value, done: done}, result); | |
| 164 } | |
| 165 | |
| 166 | |
| 167 (function TestGeneratorBasics() { | |
| 168 var object = { | |
| 169 *method() { | |
| 170 yield 1; | |
| 171 } | |
| 172 }; | |
| 173 var g = object.method(); | |
| 174 assertIteratorResult(1, false, g.next()); | |
| 175 assertIteratorResult(undefined, true, g.next()); | |
| 176 })(); | |
| 177 | |
| 178 | |
| 179 (function TestGeneratorThis() { | |
| 180 var object = { | |
| 181 *method() { | |
| 182 yield this; | |
| 183 } | |
| 184 }; | |
| 185 var g = object.method(); | |
| 186 assertIteratorResult(object, false, g.next()); | |
| 187 assertIteratorResult(undefined, true, g.next()); | |
| 188 })(); | |
| 189 | |
| 190 | |
| 191 (function TestGeneratorSymbolIterator() { | |
| 192 var object = { | |
| 193 *method() {} | |
| 194 }; | |
| 195 var g = object.method(); | |
| 196 assertEquals(g, g[Symbol.iterator]()); | |
| 197 })(); | |
| 198 | |
| 199 | |
| 200 (function TestGeneratorDescriptor() { | |
| 201 var object = { | |
| 202 *method() { | |
| 203 yield 1; | |
| 204 } | |
| 205 }; | |
| 206 | |
| 207 var desc = Object.getOwnPropertyDescriptor(object, 'method'); | |
| 208 assertTrue(desc.enumerable); | |
| 209 assertTrue(desc.configurable); | |
| 210 assertTrue(desc.writable); | |
| 211 assertEquals('function', typeof desc.value); | |
| 212 | |
| 213 var g = desc.value(); | |
| 214 assertIteratorResult(1, false, g.next()); | |
| 215 assertIteratorResult(undefined, true, g.next()); | |
| 216 })(); | |
| 217 | |
| 218 | |
| 219 (function TestGeneratorPrototypeDescriptor() { | |
| 220 var object = { | |
| 221 *method() {} | |
| 222 }; | |
| 223 | |
| 224 var desc = Object.getOwnPropertyDescriptor(object.method, 'prototype'); | |
| 225 assertFalse(desc.enumerable); | |
| 226 assertFalse(desc.configurable); | |
| 227 assertTrue(desc.writable); | |
| 228 assertEquals(GeneratorPrototype, Object.getPrototypeOf(desc.value)); | |
| 229 })(); | |
| 230 | |
| 231 | |
| 232 (function TestGeneratorProto() { | |
| 233 var object = { | |
| 234 *method() {} | |
| 235 }; | |
| 236 | |
| 237 assertEquals(GeneratorFunction.prototype, | |
| 238 Object.getPrototypeOf(object.method)); | |
| 239 })(); | |
| 240 | |
| 241 | |
| 242 (function TestGeneratorConstructable() { | |
| 243 var object = { | |
| 244 *method() { | |
| 245 yield 1; | |
| 246 } | |
| 247 }; | |
| 248 | |
| 249 var g = new object.method(); | |
| 250 assertIteratorResult(1, false, g.next()); | |
| 251 assertIteratorResult(undefined, true, g.next()); | |
| 252 })(); | |
| 253 | |
| 254 | |
| 255 (function TestGeneratorName() { | |
| 256 var object = { | |
| 257 *method() {}, | |
| 258 *1() {}, | |
| 259 *2.0() {} | |
| 260 }; | |
| 261 var f = object.method; | |
| 262 assertEquals('method', f.name); | |
| 263 var g = object[1]; | |
| 264 assertEquals('1', g.name); | |
| 265 var h = object[2]; | |
| 266 assertEquals('2', h.name); | |
| 267 })(); | |
| 268 | |
| 269 | |
| 270 (function TestGeneratorNoBinding() { | |
| 271 var method = 'local'; | |
| 272 var calls = 0; | |
| 273 var object = { | |
| 274 *method() { | |
| 275 calls++; | |
| 276 assertEquals('local', method); | |
| 277 } | |
| 278 }; | |
| 279 var g = object.method(); | |
| 280 assertIteratorResult(undefined, true, g.next()); | |
| 281 assertEquals(1, calls); | |
| 282 })(); | |
| 283 | |
| 284 | |
| 285 (function TestGeneratorToString() { | |
| 286 var object = { | |
| 287 *method() { yield 1; } | |
| 288 }; | |
| 289 assertEquals('*method() { yield 1; }', object.method.toString()); | |
| 290 })(); | |
| 291 | |
| 292 | |
| 293 (function TestProtoName() { | |
| 294 var object = { | |
| 295 __proto__() { | |
| 296 return 1; | |
| 297 } | |
| 298 }; | |
| 299 assertEquals(Object.prototype, Object.getPrototypeOf(object)); | |
| 300 assertEquals(1, object.__proto__()); | |
| 301 })(); | |
| 302 | |
| 303 | |
| 304 (function TestProtoName2() { | |
| 305 var p = {}; | |
| 306 var object = { | |
| 307 __proto__() { | |
| 308 return 1; | |
| 309 }, | |
| 310 __proto__: p | |
| 311 }; | |
| 312 assertEquals(p, Object.getPrototypeOf(object)); | |
| 313 assertEquals(1, object.__proto__()); | |
| 314 })(); | |
| OLD | NEW |