| OLD | NEW |
| (Empty) |
| 1 // Copyright 2013 the V8 project authors. All rights reserved. | |
| 2 // Copyright (C) 2005, 2006, 2007, 2008, 2009 Apple Inc. All rights reserved. | |
| 3 // | |
| 4 // Redistribution and use in source and binary forms, with or without | |
| 5 // modification, are permitted provided that the following conditions | |
| 6 // are met: | |
| 7 // 1. Redistributions of source code must retain the above copyright | |
| 8 // notice, this list of conditions and the following disclaimer. | |
| 9 // 2. Redistributions in binary form must reproduce the above copyright | |
| 10 // notice, this list of conditions and the following disclaimer in the | |
| 11 // documentation and/or other materials provided with the distribution. | |
| 12 // | |
| 13 // THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS'' AND AN
Y | |
| 14 // EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED | |
| 15 // WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE | |
| 16 // DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS BE LIABLE FOR AN
Y | |
| 17 // DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES | |
| 18 // (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; | |
| 19 // LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND O
N | |
| 20 // ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT | |
| 21 // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS | |
| 22 // SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. | |
| 23 | |
| 24 description("KDE JS Test"); | |
| 25 var global = this; | |
| 26 function myfunc() { | |
| 27 } | |
| 28 function throwex() { | |
| 29 throw new Error("test exception"); | |
| 30 } | |
| 31 | |
| 32 //--------------------------- | |
| 33 var func_ret_with_ex_func = 4; | |
| 34 try { | |
| 35 func_ret_with_ex_func = throwex()(); | |
| 36 } | |
| 37 catch (e) { | |
| 38 } | |
| 39 shouldBe("func_ret_with_ex_func", "4"); | |
| 40 | |
| 41 // --------------------------------- | |
| 42 | |
| 43 var func_ret_from_ex_throw_args = 4; | |
| 44 try { | |
| 45 func_ret_from_ex_throw_args = Math.abs(throwex()); | |
| 46 } | |
| 47 catch (e) { | |
| 48 } | |
| 49 shouldBe("func_ret_from_ex_throw_args", "4"); | |
| 50 | |
| 51 // --------------------------------- | |
| 52 | |
| 53 var set_from_throw_func_args = 4; | |
| 54 try { | |
| 55 throwex()(set_from_throw_func_args = 1); | |
| 56 } | |
| 57 catch (e) { | |
| 58 } | |
| 59 shouldBe("set_from_throw_func_args","4"); | |
| 60 | |
| 61 // --------------------------------- | |
| 62 | |
| 63 var set_from_func_throw_args = 4; | |
| 64 try { | |
| 65 myfunc(throwex(), set_from_func_throw_args = 1); | |
| 66 } | |
| 67 catch (e) { | |
| 68 } | |
| 69 shouldBe("set_from_func_throw_args","4"); | |
| 70 | |
| 71 // --------------------------------- | |
| 72 | |
| 73 var set_from_before_func_throw_args = 4; | |
| 74 try { | |
| 75 myfunc(set_from_before_func_throw_args = 1, throwex()); | |
| 76 } | |
| 77 catch (e) { | |
| 78 } | |
| 79 shouldBe("set_from_before_func_throw_args","1"); | |
| 80 | |
| 81 // --------------------------------- | |
| 82 | |
| 83 // ### move to function.js | |
| 84 var function_param_order = ""; | |
| 85 function aparam() { | |
| 86 function_param_order += "a"; | |
| 87 } | |
| 88 function bparam() { | |
| 89 function_param_order += "b"; | |
| 90 } | |
| 91 function cparam() { | |
| 92 function_param_order += "c"; | |
| 93 } | |
| 94 myfunc(aparam(),bparam(),cparam()); | |
| 95 shouldBe("function_param_order","'abc'"); | |
| 96 | |
| 97 // --------------------------------- | |
| 98 // ### move to function.js | |
| 99 var new_param_order = ""; | |
| 100 function anewparam() { | |
| 101 new_param_order += "a"; | |
| 102 } | |
| 103 function bnewparam() { | |
| 104 new_param_order += "b"; | |
| 105 } | |
| 106 function cnewparam() { | |
| 107 new_param_order += "c"; | |
| 108 } | |
| 109 new myfunc(anewparam(),bnewparam(),cnewparam()); | |
| 110 shouldBe("new_param_order","'abc'"); | |
| 111 | |
| 112 // --------------------------------- | |
| 113 // ### move to function.js | |
| 114 var elision_param_order = ""; | |
| 115 function aelision() { | |
| 116 elision_param_order += "a"; | |
| 117 } | |
| 118 function belision() { | |
| 119 elision_param_order += "b"; | |
| 120 } | |
| 121 function celision() { | |
| 122 elision_param_order += "c"; | |
| 123 } | |
| 124 [aelision(),belision(),celision()]; | |
| 125 shouldBe("elision_param_order","'abc'"); | |
| 126 | |
| 127 // --------------------------------- | |
| 128 // ### move to function.js | |
| 129 var comma_order = ""; | |
| 130 function acomma() { | |
| 131 comma_order += "a"; | |
| 132 } | |
| 133 function bcomma() { | |
| 134 comma_order += "b"; | |
| 135 } | |
| 136 function ccomma() { | |
| 137 comma_order += "c"; | |
| 138 } | |
| 139 acomma(),bcomma(),ccomma(); | |
| 140 shouldBe("comma_order","'abc'"); | |
| 141 | |
| 142 // --------------------------------- | |
| 143 | |
| 144 function checkOperator(op,name) { | |
| 145 var code =( | |
| 146 "global."+name+"_part1 = 4;\n"+ | |
| 147 "try {\n"+ | |
| 148 " ("+name+"_part1 = 1) "+op+" throwex();\n"+ | |
| 149 "}\n"+ | |
| 150 "catch (e) {\n"+ | |
| 151 "}\n"+ | |
| 152 "shouldBe('"+name+"_part1', '1');\n"+ | |
| 153 "global."+name+"_part2 = 4;\n"+ | |
| 154 "try {\n"+ | |
| 155 " throwex() "+op+" ("+name+"_part2 = 1);\n"+ | |
| 156 "}\n"+ | |
| 157 "catch (e) {\n"+ | |
| 158 "}\n"+ | |
| 159 "shouldBe('"+name+"_part2', '4');\n"); | |
| 160 // print("\n\n\n"); | |
| 161 // print(code); | |
| 162 eval(code); | |
| 163 } | |
| 164 | |
| 165 checkOperator("==","OpEqEq"); | |
| 166 checkOperator("!=","OpNotEq"); | |
| 167 checkOperator("===","OpStrEq"); | |
| 168 checkOperator("!==","OpStrNEq"); | |
| 169 // ### these generate a syntax error in mozilla - kjs should do the same (?) | |
| 170 //checkOperator("+=","OpPlusEq"); | |
| 171 //checkOperator("-=","OpMinusEq"); | |
| 172 //checkOperator("*=","OpMultEq"); | |
| 173 //checkOperator("/=","OpDivEq"); | |
| 174 // OpPlusPlus, | |
| 175 // OpMinusMinus, | |
| 176 checkOperator("<","OpLess"); | |
| 177 checkOperator("<=","OpLessEq"); | |
| 178 checkOperator(">","OpGreater"); | |
| 179 checkOperator(">=","OpGreaterEq"); | |
| 180 //checkOperator("&=","OpAndEq"); | |
| 181 //checkOperator("^=","OpXOrEq"); | |
| 182 //checkOperator("|=","OpOrEq"); | |
| 183 //checkOperator("%=","OpModEq"); | |
| 184 checkOperator("&&","OpAnd"); | |
| 185 checkOperator("||","OpOr"); | |
| 186 checkOperator("&","OpBitAnd"); | |
| 187 checkOperator("^","OpBitXOr"); | |
| 188 checkOperator("|","OpBitOr"); | |
| 189 checkOperator("<<","OpLShift"); | |
| 190 checkOperator(">>","OpRShift"); | |
| 191 checkOperator(">>>","OpURShift"); | |
| 192 // OpIn, | |
| 193 checkOperator("instanceof","OpInstanceOf"); | |
| 194 | |
| 195 // --------------------------------- | |
| 196 var set_from_if_stmt = 4; | |
| 197 try { | |
| 198 if (throwex()) { | |
| 199 set_from_if_stmt = 1; | |
| 200 } | |
| 201 } | |
| 202 catch (e) { | |
| 203 } | |
| 204 shouldBe("set_from_if_stmt","4"); | |
| 205 | |
| 206 // --------------------------------- | |
| 207 var set_from_if_else_stmt = 4; | |
| 208 try { | |
| 209 if (throwex()) { | |
| 210 set_from_if_else_stmt = 1; | |
| 211 } | |
| 212 else { | |
| 213 undefined; | |
| 214 } | |
| 215 } | |
| 216 catch (e) { | |
| 217 } | |
| 218 shouldBe("set_from_if_else_stmt","4"); | |
| 219 | |
| 220 // --------------------------------- | |
| 221 | |
| 222 var set_from_else_in_if_else_stmt = 4; | |
| 223 try { | |
| 224 if (throwex()) { | |
| 225 undefined; | |
| 226 } | |
| 227 else { | |
| 228 set_from_else_in_if_else_stmt = 1; | |
| 229 } | |
| 230 } | |
| 231 catch (e) { | |
| 232 } | |
| 233 shouldBe("set_from_else_in_if_else_stmt","4"); | |
| 234 | |
| 235 // --------------------------------- | |
| 236 | |
| 237 var comma_left = 4; | |
| 238 try { | |
| 239 comma_left = 1, throwex(); | |
| 240 } | |
| 241 catch (e) { | |
| 242 } | |
| 243 shouldBe("comma_left","1"); | |
| 244 | |
| 245 // --------------------------------- | |
| 246 | |
| 247 var comma_left = 4; | |
| 248 try { | |
| 249 throwex(), comma_left = 1; | |
| 250 } | |
| 251 catch (e) { | |
| 252 } | |
| 253 shouldBe("comma_left","4"); | |
| 254 | |
| 255 var vardecl_assign_throws = 4; | |
| 256 try { | |
| 257 var vardecl_assign_throws = throwex(); | |
| 258 } | |
| 259 catch (e) { | |
| 260 } | |
| 261 shouldBe("vardecl_assign_throws","4"); | |
| 262 | |
| 263 // --------------------------------- | |
| 264 | |
| 265 var var_assign_before_throw_run = false; | |
| 266 function var_assign_before_throw() { | |
| 267 var_assign_before_throw_run = true; | |
| 268 return 1; | |
| 269 } | |
| 270 | |
| 271 var var_assign_after_throw_run = false; | |
| 272 function var_assign_after_throw() { | |
| 273 var_assign_after_throw_run = true; | |
| 274 return 1; | |
| 275 } | |
| 276 | |
| 277 try { | |
| 278 var var_assign1 = var_assign_before_throw(), | |
| 279 var_assign2 = throwex(), | |
| 280 var_assign1 = var_assign_before_throw(); | |
| 281 } | |
| 282 catch (e) { | |
| 283 } | |
| 284 shouldBe("var_assign_before_throw_run","true"); | |
| 285 shouldBe("var_assign_after_throw_run","false"); | |
| 286 | |
| 287 // --------------------------------- | |
| 288 | |
| 289 var do_val = 4; | |
| 290 try { | |
| 291 do { | |
| 292 do_val++; | |
| 293 } | |
| 294 while (throwex()); | |
| 295 } | |
| 296 catch (e) { | |
| 297 } | |
| 298 shouldBe("do_val","5"); | |
| 299 | |
| 300 // --------------------------------- | |
| 301 var while_val = 4; | |
| 302 try { | |
| 303 while (throwex()) { | |
| 304 while_val++; | |
| 305 } | |
| 306 } | |
| 307 catch (e) { | |
| 308 } | |
| 309 shouldBe("while_val","4"); | |
| 310 | |
| 311 // --------------------------------- | |
| 312 var for_val_part1_throw2 = 4; | |
| 313 try { | |
| 314 for (for_val_part1_throw2 = 1; throwex(); ) { | |
| 315 } | |
| 316 } | |
| 317 catch (e) { | |
| 318 } | |
| 319 shouldBe("for_val_part1_throw2","1"); | |
| 320 | |
| 321 // --------------------------------- | |
| 322 var for_val_part1_throw3 = 4; | |
| 323 try { | |
| 324 for (for_val_part1_throw3 = 1; ; throwex()) { | |
| 325 } | |
| 326 } | |
| 327 catch (e) { | |
| 328 } | |
| 329 shouldBe("for_val_part1_throw3","1"); | |
| 330 | |
| 331 // --------------------------------- | |
| 332 var for_val_part2_throw1 = 4; | |
| 333 try { | |
| 334 for (throwex(); for_val_part2_throw1 = 1; ) { | |
| 335 } | |
| 336 } | |
| 337 catch (e) { | |
| 338 } | |
| 339 shouldBe("for_val_part2_throw1","4"); | |
| 340 | |
| 341 // --------------------------------- | |
| 342 var for_val_part2_throw3 = 4; | |
| 343 try { | |
| 344 for (; for_val_part2_throw3 = 1; throwex()) { | |
| 345 } | |
| 346 } | |
| 347 catch (e) { | |
| 348 } | |
| 349 shouldBe("for_val_part2_throw3","1"); | |
| 350 | |
| 351 // --------------------------------- | |
| 352 var for_val_part3_throw1 = 4; | |
| 353 try { | |
| 354 for (throwex(); ; for_val_part3_throw1 = 1) { | |
| 355 } | |
| 356 } | |
| 357 catch (e) { | |
| 358 } | |
| 359 shouldBe("for_val_part3_throw1","4"); | |
| 360 | |
| 361 // --------------------------------- | |
| 362 var for_val_part3_throw2 = 4; | |
| 363 try { | |
| 364 for (; throwex(); for_val_part3_throw2 = 1) { | |
| 365 } | |
| 366 } | |
| 367 catch (e) { | |
| 368 } | |
| 369 shouldBe("for_val_part3_throw2","4"); | |
| 370 | |
| 371 // --------------------------------- | |
| 372 var for_val_part1_throwbody = 4; | |
| 373 try { | |
| 374 for (for_val_part1_throwbody = 1; ;) { | |
| 375 throwex(); | |
| 376 } | |
| 377 } | |
| 378 catch (e) { | |
| 379 } | |
| 380 shouldBe("for_val_part1_throwbody","1"); | |
| 381 | |
| 382 // --------------------------------- | |
| 383 var for_val_part2_throwbody = 4; | |
| 384 try { | |
| 385 for (; for_val_part2_throwbody = 1; ) { | |
| 386 throwex(); | |
| 387 } | |
| 388 } | |
| 389 catch (e) { | |
| 390 } | |
| 391 shouldBe("for_val_part2_throwbody","1"); | |
| 392 | |
| 393 // --------------------------------- | |
| 394 var for_val_part3_throwbody = 4; | |
| 395 try { | |
| 396 for (; ; for_val_part3_throwbody = 1) { | |
| 397 throwex(); | |
| 398 } | |
| 399 } | |
| 400 catch (e) { | |
| 401 } | |
| 402 shouldBe("for_val_part3_throwbody","4"); | |
| 403 | |
| 404 // --------------------------------- | |
| 405 var forin_test_obj = new Object(); | |
| 406 forin_test_obj.a = 1; | |
| 407 forin_test_obj.b = 2; | |
| 408 forin_test_obj.c = 3; | |
| 409 var forin_count = 4; | |
| 410 function forin_lexpr() { | |
| 411 // if (forincount == 1); | |
| 412 // throwex(); | |
| 413 return new Object(); | |
| 414 } | |
| 415 try { | |
| 416 for (throwex() in forin_test_obj) { | |
| 417 forin_count++; | |
| 418 } | |
| 419 } | |
| 420 catch (e) { | |
| 421 } | |
| 422 shouldBe("forin_count","4"); | |
| 423 | |
| 424 // --------------------------------- | |
| 425 var set_inside_with_throw = 4; | |
| 426 try { | |
| 427 with (throwex()) { | |
| 428 set_inside_with_throw = 1; | |
| 429 } | |
| 430 } | |
| 431 catch (e) { | |
| 432 } | |
| 433 shouldBe("set_inside_with_throw","4"); | |
| 434 | |
| 435 // --------------------------------- | |
| 436 var set_inside_with_cantconverttoobject = 4; | |
| 437 try { | |
| 438 with (undefined) { | |
| 439 print("FAIL. This message should not be displayed"); | |
| 440 set_inside_with_cantconverttoobject = 1; | |
| 441 } | |
| 442 } | |
| 443 catch (e) { | |
| 444 } | |
| 445 shouldBe("set_inside_with_cantconverttoobject","4"); | |
| 446 // ### test case, sw | |
| OLD | NEW |