| OLD | NEW |
| (Empty) |
| 1 // Copyright 2015 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: --strong-mode --allow-natives-syntax | |
| 6 | |
| 7 // TODO(conradw): Track implementation of strong bit for other objects, add | |
| 8 // tests. | |
| 9 | |
| 10 function getSloppyObjects() { | |
| 11 return [(function(){}), ({})]; | |
| 12 } | |
| 13 | |
| 14 function getStrictObjects() { | |
| 15 "use strict"; | |
| 16 return [(function(){}), ({})]; | |
| 17 } | |
| 18 | |
| 19 function getWeakObjects() { | |
| 20 return getSloppyObjects().concat(getStrictObjects()); | |
| 21 } | |
| 22 | |
| 23 function getStrongObjects() { | |
| 24 "use strong"; | |
| 25 // Strong functions can't have properties added to them, and will be tested as a | |
| 26 // special case. | |
| 27 return [({})]; | |
| 28 } | |
| 29 | |
| 30 function strongFunction() { | |
| 31 "use strong"; | |
| 32 } | |
| 33 | |
| 34 function deleteFromObjectSloppy(o) { | |
| 35 return delete o.foo; | |
| 36 } | |
| 37 | |
| 38 function deleteFromObjectKeyedSloppy(o) { | |
| 39 return delete o["foo"]; | |
| 40 } | |
| 41 | |
| 42 function deleteFromObjectKeyedVarSloppy(o) { | |
| 43 var a = "foo"; | |
| 44 return delete o[a]; | |
| 45 } | |
| 46 | |
| 47 function deleteFromObjectKeyedComputedSloppy(o) { | |
| 48 var a = "o"; | |
| 49 return delete o["fo" + a]; | |
| 50 } | |
| 51 | |
| 52 function deleteFromObjectWith(o) { | |
| 53 with (o) { | |
| 54 return delete foo; | |
| 55 } | |
| 56 } | |
| 57 | |
| 58 function deleteFromObjectElementSloppy(o) { | |
| 59 return delete o[0]; | |
| 60 } | |
| 61 | |
| 62 function deleteFromObjectElementVarSloppy(o) { | |
| 63 var a = 0; | |
| 64 return delete o[a]; | |
| 65 } | |
| 66 | |
| 67 function deleteFromObjectElementSparseSloppy(o) { | |
| 68 return delete o[100000]; | |
| 69 } | |
| 70 | |
| 71 function deleteFromObjectElementVarSloppy(o) { | |
| 72 var a = 0; | |
| 73 return delete o[a]; | |
| 74 } | |
| 75 | |
| 76 function deleteFromObjectElementSparseVarSloppy(o) { | |
| 77 var a = 100000; | |
| 78 return delete o[a]; | |
| 79 } | |
| 80 | |
| 81 function deleteFromObjectStrict(o) { | |
| 82 "use strict"; | |
| 83 return delete o.foo; | |
| 84 } | |
| 85 | |
| 86 function deleteFromObjectKeyedStrict(o) { | |
| 87 "use strict"; | |
| 88 return delete o["foo"]; | |
| 89 } | |
| 90 | |
| 91 function deleteFromObjectKeyedVarStrict(o) { | |
| 92 "use strict"; | |
| 93 var a = "foo"; | |
| 94 return delete o[a]; | |
| 95 } | |
| 96 | |
| 97 function deleteFromObjectKeyedComputedStrict(o) { | |
| 98 "use strict"; | |
| 99 var a = "o"; | |
| 100 return delete o["fo" + a]; | |
| 101 } | |
| 102 | |
| 103 function deleteFromObjectElementStrict(o) { | |
| 104 "use strict"; | |
| 105 return delete o[0]; | |
| 106 } | |
| 107 | |
| 108 function deleteFromObjectElementSparseStrict(o) { | |
| 109 "use strict"; | |
| 110 return delete o[100000]; | |
| 111 } | |
| 112 | |
| 113 function deleteFromObjectElementVarStrict(o) { | |
| 114 "use strict"; | |
| 115 var a = 0; | |
| 116 return delete o[a]; | |
| 117 } | |
| 118 | |
| 119 function deleteFromObjectElementSparseVarStrict(o) { | |
| 120 "use strict"; | |
| 121 var a = 100000; | |
| 122 return delete o[a]; | |
| 123 } | |
| 124 | |
| 125 function testStrongObjectDelete() { | |
| 126 "use strict"; | |
| 127 | |
| 128 let deletePropertyFuncsSloppy = [ | |
| 129 deleteFromObjectSloppy, | |
| 130 deleteFromObjectKeyedSloppy, | |
| 131 deleteFromObjectKeyedVarSloppy, | |
| 132 deleteFromObjectKeyedComputedSloppy, | |
| 133 deleteFromObjectWith | |
| 134 ]; | |
| 135 let deletePropertyFuncsStrict = [ | |
| 136 deleteFromObjectStrict, | |
| 137 deleteFromObjectKeyedStrict, | |
| 138 deleteFromObjectKeyedVarStrict, | |
| 139 deleteFromObjectKeyedComputedStrict | |
| 140 ]; | |
| 141 let deleteElementFuncsSloppy = [ | |
| 142 deleteFromObjectElementSloppy, | |
| 143 deleteFromObjectElementVarSloppy | |
| 144 ]; | |
| 145 let deleteElementSparseFuncsSloppy = [ | |
| 146 deleteFromObjectElementSparseSloppy, | |
| 147 deleteFromObjectElementSparseVarSloppy | |
| 148 ]; | |
| 149 let deleteElementFuncsStrict = [ | |
| 150 deleteFromObjectElementStrict, | |
| 151 deleteFromObjectElementVarStrict | |
| 152 ]; | |
| 153 let deleteElementSparseFuncsStrict = [ | |
| 154 deleteFromObjectElementSparseStrict, | |
| 155 deleteFromObjectElementSparseVarStrict | |
| 156 ]; | |
| 157 let deleteFuncs = deletePropertyFuncsSloppy.concat( | |
| 158 deletePropertyFuncsStrict, deleteElementFuncsSloppy, | |
| 159 deleteElementSparseFuncsSloppy, deleteElementFuncsStrict, | |
| 160 deleteElementSparseFuncsStrict); | |
| 161 | |
| 162 for (let deleteFunc of deleteFuncs) { | |
| 163 assertTrue(deleteFunc(strongFunction)); | |
| 164 } | |
| 165 | |
| 166 let testCasesSloppy = [ | |
| 167 [deletePropertyFuncsSloppy, "foo"], | |
| 168 [deleteElementFuncsSloppy, "0"], | |
| 169 [deleteElementSparseFuncsSloppy, "100000"] | |
| 170 ]; | |
| 171 | |
| 172 let testCasesStrict = [ | |
| 173 [deletePropertyFuncsStrict, "foo"], | |
| 174 [deleteElementFuncsStrict, "0"], | |
| 175 [deleteElementSparseFuncsStrict, "100000"] | |
| 176 ]; | |
| 177 | |
| 178 let propDescs = [ | |
| 179 {configurable: true, value: "bar"}, | |
| 180 {configurable: true, value: 1}, | |
| 181 {configurable: true, enumerable: true, writable: true, value: "bar"}, | |
| 182 {configurable: true, enumerable: true, writable: true, value: 1}, | |
| 183 {configurable: true, get: (function(){return 0}), set: (function(x){})} | |
| 184 ]; | |
| 185 | |
| 186 for (let propDesc of propDescs) { | |
| 187 for (let testCase of testCasesSloppy) { | |
| 188 let name = testCase[1]; | |
| 189 for (let deleteFunc of testCase[0]) { | |
| 190 for (let o of getWeakObjects()) { | |
| 191 Object.defineProperty(o, name, propDesc); | |
| 192 assertTrue(delete o["bar"]); | |
| 193 assertTrue(delete o[5000]); | |
| 194 assertTrue(deleteFunc(o)); | |
| 195 assertFalse(o.hasOwnProperty(name)); | |
| 196 %OptimizeFunctionOnNextCall(deleteFunc); | |
| 197 Object.defineProperty(o, name, propDesc); | |
| 198 assertTrue(deleteFunc(o)); | |
| 199 assertFalse(o.hasOwnProperty(name)); | |
| 200 %DeoptimizeFunction(deleteFunc); | |
| 201 Object.defineProperty(o, name, propDesc); | |
| 202 assertTrue(deleteFunc(o)); | |
| 203 assertFalse(o.hasOwnProperty(name)); | |
| 204 } | |
| 205 for (let o of getStrongObjects()) { | |
| 206 Object.defineProperty(o, name, propDesc); | |
| 207 assertTrue(delete o["bar"]); | |
| 208 assertTrue(delete o[5000]); | |
| 209 assertFalse(deleteFunc(o)); | |
| 210 assertTrue(o.hasOwnProperty(name)); | |
| 211 %OptimizeFunctionOnNextCall(deleteFunc); | |
| 212 assertFalse(deleteFunc(o)); | |
| 213 assertTrue(o.hasOwnProperty(name)); | |
| 214 %DeoptimizeFunction(deleteFunc); | |
| 215 assertFalse(deleteFunc(o)); | |
| 216 assertTrue(o.hasOwnProperty(name)); | |
| 217 } | |
| 218 } | |
| 219 } | |
| 220 for (let testCase of testCasesStrict) { | |
| 221 let name = testCase[1]; | |
| 222 for (let deleteFunc of testCase[0]) { | |
| 223 for (let o of getWeakObjects()) { | |
| 224 Object.defineProperty(o, name, propDesc); | |
| 225 assertTrue(delete o["bar"]); | |
| 226 assertTrue(delete o[5000]); | |
| 227 assertTrue(deleteFunc(o)); | |
| 228 assertFalse(o.hasOwnProperty(name)); | |
| 229 %OptimizeFunctionOnNextCall(deleteFunc); | |
| 230 Object.defineProperty(o, name, propDesc); | |
| 231 assertTrue(deleteFunc(o)); | |
| 232 assertFalse(o.hasOwnProperty(name)); | |
| 233 %DeoptimizeFunction(deleteFunc); | |
| 234 Object.defineProperty(o, name, propDesc); | |
| 235 assertTrue(deleteFunc(o)); | |
| 236 assertFalse(o.hasOwnProperty(name)); | |
| 237 } | |
| 238 for (let o of getStrongObjects()) { | |
| 239 Object.defineProperty(o, name, propDesc); | |
| 240 assertTrue(delete o["bar"]); | |
| 241 assertTrue(delete o[5000]); | |
| 242 assertThrows(function(){deleteFunc(o)}, TypeError); | |
| 243 assertTrue(o.hasOwnProperty(name)); | |
| 244 %OptimizeFunctionOnNextCall(deleteFunc); | |
| 245 assertThrows(function(){deleteFunc(o)}, TypeError); | |
| 246 assertTrue(o.hasOwnProperty(name)); | |
| 247 %DeoptimizeFunction(deleteFunc); | |
| 248 assertThrows(function(){deleteFunc(o)}, TypeError); | |
| 249 assertTrue(o.hasOwnProperty(name)); | |
| 250 } | |
| 251 } | |
| 252 } | |
| 253 } | |
| 254 } | |
| 255 testStrongObjectDelete(); | |
| OLD | NEW |