| OLD | NEW |
|---|
| 1 Test collecting code coverage data with Profiler.collectCoverage. | 1 Test collecting code coverage data with Profiler.collectCoverage. |
| 2 | 2 |
| 3 Running test: testPreciseCountBaseline | 3 Running test: testPreciseCountBaseline |
| 4 { | 4 { |
| 5 id : <messageId> | 5 id : <messageId> |
| 6 result : { | 6 result : { |
| 7 result : [ | 7 result : [ |
| 8 [0] : { | 8 [0] : { |
| 9 functions : [ | 9 functions : [ |
| 10 [0] : { | 10 [0] : { |
| 11 functionName : fib | 11 functionName : fib |
| 12 ranges : [ | 12 ranges : [ |
| 13 [0] : { | 13 [0] : { |
| 14 count : 15 | 14 count : 15 |
| 15 endOffset : 73 | 15 endOffset : 73 |
| 16 startOffset : 1 | 16 startOffset : 1 |
| 17 } | 17 } |
| 18 ] | 18 ] |
| 19 } | 19 } |
| 20 [1] : { |
| 21 functionName : is_optimized |
| 22 ranges : [ |
| 23 [0] : { |
| 24 count : 0 |
| 25 endOffset : 175 |
| 26 startOffset : 74 |
| 27 } |
| 28 ] |
| 29 } |
| 20 ] | 30 ] |
| 21 scriptId : <scriptId> | 31 scriptId : <scriptId> |
| 22 url : testPreciseCountBaseline | 32 url : testPreciseCountBaseline |
| 23 } | 33 } |
| 24 ] | 34 ] |
| 25 } | 35 } |
| 26 } | 36 } |
| 27 { | 37 { |
| 28 id : <messageId> | 38 id : <messageId> |
| 29 result : { | 39 result : { |
| 30 result : [ | 40 result : [ |
| 41 [0] : { |
| 42 functions : [ |
| 43 [0] : { |
| 44 functionName : fib |
| 45 ranges : [ |
| 46 [0] : { |
| 47 count : 0 |
| 48 endOffset : 73 |
| 49 startOffset : 1 |
| 50 } |
| 51 ] |
| 52 } |
| 53 [1] : { |
| 54 functionName : is_optimized |
| 55 ranges : [ |
| 56 [0] : { |
| 57 count : 0 |
| 58 endOffset : 175 |
| 59 startOffset : 74 |
| 60 } |
| 61 ] |
| 62 } |
| 63 ] |
| 64 scriptId : <scriptId> |
| 65 url : testPreciseCountBaseline |
| 66 } |
| 31 ] | 67 ] |
| 32 } | 68 } |
| 33 } | 69 } |
| 34 | 70 |
| 35 Running test: testPreciseCountCoverage | 71 Running test: testPreciseCountCoverage |
| 36 { | 72 { |
| 37 id : <messageId> | 73 id : <messageId> |
| 38 result : { | 74 result : { |
| 75 } |
| 76 } |
| 77 { |
| 78 id : <messageId> |
| 79 result : { |
| 80 result : [ |
| 81 [0] : { |
| 82 functions : [ |
| 83 [0] : { |
| 84 functionName : |
| 85 ranges : [ |
| 86 [0] : { |
| 87 count : 1 |
| 88 endOffset : 221 |
| 89 startOffset : 0 |
| 90 } |
| 91 ] |
| 92 } |
| 93 [1] : { |
| 94 functionName : fib |
| 95 ranges : [ |
| 96 [0] : { |
| 97 count : 15 |
| 98 endOffset : 73 |
| 99 startOffset : 1 |
| 100 } |
| 101 ] |
| 102 } |
| 103 [2] : { |
| 104 functionName : is_optimized |
| 105 ranges : [ |
| 106 [0] : { |
| 107 count : 0 |
| 108 endOffset : 175 |
| 109 startOffset : 74 |
| 110 } |
| 111 ] |
| 112 } |
| 113 [3] : { |
| 114 functionName : iife |
| 115 ranges : [ |
| 116 [0] : { |
| 117 count : 1 |
| 118 endOffset : 208 |
| 119 startOffset : 177 |
| 120 } |
| 121 ] |
| 122 } |
| 123 ] |
| 124 scriptId : <scriptId> |
| 125 url : testPreciseCountCoverage |
| 126 } |
| 127 [1] : { |
| 128 functions : [ |
| 129 [0] : { |
| 130 functionName : |
| 131 ranges : [ |
| 132 [0] : { |
| 133 count : 1 |
| 134 endOffset : 38 |
| 135 startOffset : 0 |
| 136 } |
| 137 ] |
| 138 } |
| 139 ] |
| 140 scriptId : <scriptId> |
| 141 url : |
| 142 } |
| 143 ] |
| 144 } |
| 145 } |
| 146 { |
| 147 id : <messageId> |
| 148 result : { |
| 149 result : [ |
| 150 [0] : { |
| 151 functions : [ |
| 152 [0] : { |
| 153 functionName : |
| 154 ranges : [ |
| 155 [0] : { |
| 156 count : 0 |
| 157 endOffset : 221 |
| 158 startOffset : 0 |
| 159 } |
| 160 ] |
| 161 } |
| 162 [1] : { |
| 163 functionName : fib |
| 164 ranges : [ |
| 165 [0] : { |
| 166 count : 0 |
| 167 endOffset : 73 |
| 168 startOffset : 1 |
| 169 } |
| 170 ] |
| 171 } |
| 172 [2] : { |
| 173 functionName : is_optimized |
| 174 ranges : [ |
| 175 [0] : { |
| 176 count : 0 |
| 177 endOffset : 175 |
| 178 startOffset : 74 |
| 179 } |
| 180 ] |
| 181 } |
| 182 [3] : { |
| 183 functionName : iife |
| 184 ranges : [ |
| 185 [0] : { |
| 186 count : 0 |
| 187 endOffset : 208 |
| 188 startOffset : 177 |
| 189 } |
| 190 ] |
| 191 } |
| 192 ] |
| 193 scriptId : <scriptId> |
| 194 url : testPreciseCountCoverage |
| 195 } |
| 196 [1] : { |
| 197 functions : [ |
| 198 [0] : { |
| 199 functionName : |
| 200 ranges : [ |
| 201 [0] : { |
| 202 count : 0 |
| 203 endOffset : 38 |
| 204 startOffset : 0 |
| 205 } |
| 206 ] |
| 207 } |
| 208 ] |
| 209 scriptId : <scriptId> |
| 210 url : |
| 211 } |
| 212 ] |
| 213 } |
| 214 } |
| 215 |
| 216 Running test: testPreciseCoverageFail |
| 217 { |
| 218 id : <messageId> |
| 219 result : { |
| 39 result : { | 220 result : { |
| 40 description : 8 | 221 description : 8 |
| 41 type : number | 222 type : number |
| 42 value : 8 | 223 value : 8 |
| 43 } | 224 } |
| 44 } | 225 } |
| 45 } | 226 } |
| 46 { | 227 { |
| 228 error : { |
| 229 code : -32000 |
| 230 message : Precise coverage has not been started. |
| 231 } |
| 47 id : <messageId> | 232 id : <messageId> |
| 48 result : { | |
| 49 result : [ | |
| 50 [0] : { | |
| 51 functions : [ | |
| 52 [0] : { | |
| 53 functionName : | |
| 54 ranges : [ | |
| 55 [0] : { | |
| 56 count : 1 | |
| 57 endOffset : 221 | |
| 58 startOffset : 0 | |
| 59 } | |
| 60 ] | |
| 61 } | |
| 62 [1] : { | |
| 63 functionName : fib | |
| 64 ranges : [ | |
| 65 [0] : { | |
| 66 count : 15 | |
| 67 endOffset : 73 | |
| 68 startOffset : 1 | |
| 69 } | |
| 70 ] | |
| 71 } | |
| 72 [2] : { | |
| 73 functionName : is_optimized | |
| 74 ranges : [ | |
| 75 [0] : { | |
| 76 count : 0 | |
| 77 endOffset : 175 | |
| 78 startOffset : 74 | |
| 79 } | |
| 80 ] | |
| 81 } | |
| 82 [3] : { | |
| 83 functionName : iife | |
| 84 ranges : [ | |
| 85 [0] : { | |
| 86 count : 1 | |
| 87 endOffset : 208 | |
| 88 startOffset : 177 | |
| 89 } | |
| 90 ] | |
| 91 } | |
| 92 ] | |
| 93 scriptId : <scriptId> | |
| 94 url : testPreciseCountCoverage | |
| 95 } | |
| 96 [1] : { | |
| 97 functions : [ | |
| 98 [0] : { | |
| 99 functionName : | |
| 100 ranges : [ | |
| 101 [0] : { | |
| 102 count : 1 | |
| 103 endOffset : 38 | |
| 104 startOffset : 0 | |
| 105 } | |
| 106 ] | |
| 107 } | |
| 108 ] | |
| 109 scriptId : <scriptId> | |
| 110 url : | |
| 111 } | |
| 112 ] | |
| 113 } | |
| 114 } | 233 } |
| 234 |
| 235 Running test: testBestEffortCoverage |
| 115 { | 236 { |
| 116 id : <messageId> | 237 id : <messageId> |
| 117 result : { | 238 result : { |
| 118 result : [ | |
| 119 ] | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 Running test: testPreciseCoverageFail | |
| 124 { | |
| 125 id : <messageId> | |
| 126 result : { | |
| 127 result : { | 239 result : { |
| 128 description : 8 | 240 description : 8 |
| 129 type : number | 241 type : number |
| 130 value : 8 | 242 value : 8 |
| 131 } | 243 } |
| 132 } | 244 } |
| 133 } | 245 } |
| 134 { | 246 { |
| 135 error : { | 247 id : <messageId> |
| 136 code : -32000 | 248 result : { |
| 137 message : Precise coverage has not been started. | 249 result : [ |
| 250 ] |
| 138 } | 251 } |
| 139 id : <messageId> | |
| 140 } | 252 } |
| 141 | |
| 142 Running test: testBestEffortCoverage | |
| 143 { | 253 { |
| 144 id : <messageId> | 254 id : <messageId> |
| 145 result : { | 255 result : { |
| 256 result : [ |
| 257 ] |
| 258 } |
| 259 } |
| 260 |
| 261 Running test: testBestEffortCoverageWithPreciseBinaryEnabled |
| 262 { |
| 263 id : <messageId> |
| 264 result : { |
| 146 result : { | 265 result : { |
| 147 description : 8 | 266 description : 8 |
| 148 type : number | 267 type : number |
| 149 value : 8 | 268 value : 8 |
| 150 } | 269 } |
| 151 } | 270 } |
| 152 } | 271 } |
| 153 { | 272 { |
| 154 id : <messageId> | 273 id : <messageId> |
| 155 result : { | 274 result : { |
| 156 result : [ | 275 result : [ |
| 276 [0] : { |
| 277 functions : [ |
| 278 [0] : { |
| 279 functionName : |
| 280 ranges : [ |
| 281 [0] : { |
| 282 count : 1 |
| 283 endOffset : 221 |
| 284 startOffset : 0 |
| 285 } |
| 286 ] |
| 287 } |
| 288 [1] : { |
| 289 functionName : fib |
| 290 ranges : [ |
| 291 [0] : { |
| 292 count : 1 |
| 293 endOffset : 73 |
| 294 startOffset : 1 |
| 295 } |
| 296 ] |
| 297 } |
| 298 [2] : { |
| 299 functionName : is_optimized |
| 300 ranges : [ |
| 301 [0] : { |
| 302 count : 0 |
| 303 endOffset : 175 |
| 304 startOffset : 74 |
| 305 } |
| 306 ] |
| 307 } |
| 308 [3] : { |
| 309 functionName : iife |
| 310 ranges : [ |
| 311 [0] : { |
| 312 count : 1 |
| 313 endOffset : 208 |
| 314 startOffset : 177 |
| 315 } |
| 316 ] |
| 317 } |
| 318 ] |
| 319 scriptId : <scriptId> |
| 320 url : testBestEffortCoverageWithPreciseBinaryEnabled |
| 321 } |
| 322 [1] : { |
| 323 functions : [ |
| 324 [0] : { |
| 325 functionName : |
| 326 ranges : [ |
| 327 [0] : { |
| 328 count : 1 |
| 329 endOffset : 38 |
| 330 startOffset : 0 |
| 331 } |
| 332 ] |
| 333 } |
| 334 ] |
| 335 scriptId : <scriptId> |
| 336 url : |
| 337 } |
| 157 ] | 338 ] |
| 158 } | 339 } |
| 159 } | 340 } |
| 160 { | 341 { |
| 161 id : <messageId> | 342 id : <messageId> |
| 162 result : { | 343 result : { |
| 163 result : [ | 344 result : [ |
| 345 [0] : { |
| 346 functions : [ |
| 347 [0] : { |
| 348 functionName : |
| 349 ranges : [ |
| 350 [0] : { |
| 351 count : 1 |
| 352 endOffset : 221 |
| 353 startOffset : 0 |
| 354 } |
| 355 ] |
| 356 } |
| 357 [1] : { |
| 358 functionName : fib |
| 359 ranges : [ |
| 360 [0] : { |
| 361 count : 1 |
| 362 endOffset : 73 |
| 363 startOffset : 1 |
| 364 } |
| 365 ] |
| 366 } |
| 367 [2] : { |
| 368 functionName : is_optimized |
| 369 ranges : [ |
| 370 [0] : { |
| 371 count : 0 |
| 372 endOffset : 175 |
| 373 startOffset : 74 |
| 374 } |
| 375 ] |
| 376 } |
| 377 [3] : { |
| 378 functionName : iife |
| 379 ranges : [ |
| 380 [0] : { |
| 381 count : 1 |
| 382 endOffset : 208 |
| 383 startOffset : 177 |
| 384 } |
| 385 ] |
| 386 } |
| 387 ] |
| 388 scriptId : <scriptId> |
| 389 url : testBestEffortCoverageWithPreciseBinaryEnabled |
| 390 } |
| 391 [1] : { |
| 392 functions : [ |
| 393 [0] : { |
| 394 functionName : |
| 395 ranges : [ |
| 396 [0] : { |
| 397 count : 1 |
| 398 endOffset : 38 |
| 399 startOffset : 0 |
| 400 } |
| 401 ] |
| 402 } |
| 403 ] |
| 404 scriptId : <scriptId> |
| 405 url : |
| 406 } |
| 164 ] | 407 ] |
| 165 } | 408 } |
| 166 } | 409 } |
| 167 | 410 |
| 168 Running test: testBestEffortCoverageWithPreciseBinaryEnabled | 411 Running test: testBestEffortCoverageWithPreciseCountEnabled |
| 169 { | 412 { |
| 170 id : <messageId> | 413 id : <messageId> |
| 171 result : { | 414 result : { |
| 172 result : { | 415 result : { |
| 173 description : 8 | 416 description : 8 |
| 174 type : number | 417 type : number |
| 175 value : 8 | 418 value : 8 |
| 176 } | 419 } |
| 177 } | 420 } |
| 178 } | 421 } |
| (...skipping 38 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 217 ranges : [ | 460 ranges : [ |
| 218 [0] : { | 461 [0] : { |
| 219 count : 1 | 462 count : 1 |
| 220 endOffset : 208 | 463 endOffset : 208 |
| 221 startOffset : 177 | 464 startOffset : 177 |
| 222 } | 465 } |
| 223 ] | 466 ] |
| 224 } | 467 } |
| 225 ] | 468 ] |
| 226 scriptId : <scriptId> | 469 scriptId : <scriptId> |
| 227 url : testBestEffortCoverageWithPreciseBinaryEnabled | 470 url : testBestEffortCoverageWithPreciseCountEnabled |
| 228 } | 471 } |
| 229 [1] : { | 472 [1] : { |
| 230 functions : [ | 473 functions : [ |
| 231 [0] : { | 474 [0] : { |
| 232 functionName : | 475 functionName : |
| 233 ranges : [ | 476 ranges : [ |
| 234 [0] : { | 477 [0] : { |
| 235 count : 1 | 478 count : 1 |
| 236 endOffset : 38 | 479 endOffset : 38 |
| 237 startOffset : 0 | 480 startOffset : 0 |
| (...skipping 48 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 286 ranges : [ | 529 ranges : [ |
| 287 [0] : { | 530 [0] : { |
| 288 count : 1 | 531 count : 1 |
| 289 endOffset : 208 | 532 endOffset : 208 |
| 290 startOffset : 177 | 533 startOffset : 177 |
| 291 } | 534 } |
| 292 ] | 535 ] |
| 293 } | 536 } |
| 294 ] | 537 ] |
| 295 scriptId : <scriptId> | 538 scriptId : <scriptId> |
| 296 url : testBestEffortCoverageWithPreciseBinaryEnabled | 539 url : testBestEffortCoverageWithPreciseCountEnabled |
| 297 } | 540 } |
| 298 [1] : { | 541 [1] : { |
| 299 functions : [ | 542 functions : [ |
| 300 [0] : { | 543 [0] : { |
| 301 functionName : | 544 functionName : |
| 302 ranges : [ | 545 ranges : [ |
| 303 [0] : { | 546 [0] : { |
| 304 count : 1 | 547 count : 1 |
| 305 endOffset : 38 | 548 endOffset : 38 |
| 306 startOffset : 0 | 549 startOffset : 0 |
| 307 } | 550 } |
| 308 ] | 551 ] |
| 309 } | 552 } |
| 310 ] | 553 ] |
| 311 scriptId : <scriptId> | 554 scriptId : <scriptId> |
| 312 url : | 555 url : |
| 313 } | 556 } |
| 314 ] | 557 ] |
| 315 } | 558 } |
| 316 } | 559 } |
| 317 | 560 |
| 318 Running test: testBestEffortCoverageWithPreciseCountEnabled | 561 Running test: testEnablePreciseCountCoverageAtPause |
| 319 { | 562 { |
| 320 id : <messageId> | 563 id : <messageId> |
| 321 result : { | 564 result : { |
| 565 result : { |
| 566 type : undefined |
| 567 } |
| 568 } |
| 569 } |
| 570 { |
| 571 id : <messageId> |
| 572 result : { |
| 573 result : [ |
| 574 [0] : { |
| 575 functions : [ |
| 576 [0] : { |
| 577 functionName : |
| 578 ranges : [ |
| 579 [0] : { |
| 580 count : 1 |
| 581 endOffset : 114 |
| 582 startOffset : 0 |
| 583 } |
| 584 ] |
| 585 } |
| 586 [1] : { |
| 587 functionName : g |
| 588 ranges : [ |
| 589 [0] : { |
| 590 count : 1 |
| 591 endOffset : 29 |
| 592 startOffset : 1 |
| 593 } |
| 594 ] |
| 595 } |
| 596 [2] : { |
| 597 functionName : f |
| 598 ranges : [ |
| 599 [0] : { |
| 600 count : 4 |
| 601 endOffset : 83 |
| 602 startOffset : 30 |
| 603 } |
| 604 ] |
| 605 } |
| 606 [3] : { |
| 607 functionName : h |
| 608 ranges : [ |
| 609 [0] : { |
| 610 count : 0 |
| 611 endOffset : 107 |
| 612 startOffset : 84 |
| 613 } |
| 614 ] |
| 615 } |
| 616 ] |
| 617 scriptId : <scriptId> |
| 618 url : testEnablePreciseCountCoverageAtPause |
| 619 } |
| 620 [1] : { |
| 621 functions : [ |
| 622 [0] : { |
| 623 functionName : |
| 624 ranges : [ |
| 625 [0] : { |
| 626 count : 1 |
| 627 endOffset : 38 |
| 628 startOffset : 0 |
| 629 } |
| 630 ] |
| 631 } |
| 632 ] |
| 633 scriptId : <scriptId> |
| 634 url : |
| 635 } |
| 636 ] |
| 637 } |
| 638 } |
| 639 |
| 640 Running test: testPreciseBinaryCoverage |
| 641 { |
| 642 id : <messageId> |
| 643 result : { |
| 322 result : { | 644 result : { |
| 323 description : 8 | 645 description : 8 |
| 324 type : number | 646 type : number |
| 325 value : 8 | 647 value : 8 |
| 326 } | 648 } |
| 327 } | 649 } |
| 328 } | 650 } |
| 329 { | 651 { |
| 330 id : <messageId> | 652 id : <messageId> |
| 331 result : { | 653 result : { |
| (...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
| 367 ranges : [ | 689 ranges : [ |
| 368 [0] : { | 690 [0] : { |
| 369 count : 1 | 691 count : 1 |
| 370 endOffset : 208 | 692 endOffset : 208 |
| 371 startOffset : 177 | 693 startOffset : 177 |
| 372 } | 694 } |
| 373 ] | 695 ] |
| 374 } | 696 } |
| 375 ] | 697 ] |
| 376 scriptId : <scriptId> | 698 scriptId : <scriptId> |
| 377 url : testBestEffortCoverageWithPreciseCountEnabled | |
| 378 } | |
| 379 [1] : { | |
| 380 functions : [ | |
| 381 [0] : { | |
| 382 functionName : | |
| 383 ranges : [ | |
| 384 [0] : { | |
| 385 count : 1 | |
| 386 endOffset : 38 | |
| 387 startOffset : 0 | |
| 388 } | |
| 389 ] | |
| 390 } | |
| 391 ] | |
| 392 scriptId : <scriptId> | |
| 393 url : | |
| 394 } | |
| 395 ] | |
| 396 } | |
| 397 } | |
| 398 { | |
| 399 id : <messageId> | |
| 400 result : { | |
| 401 result : [ | |
| 402 [0] : { | |
| 403 functions : [ | |
| 404 [0] : { | |
| 405 functionName : | |
| 406 ranges : [ | |
| 407 [0] : { | |
| 408 count : 1 | |
| 409 endOffset : 221 | |
| 410 startOffset : 0 | |
| 411 } | |
| 412 ] | |
| 413 } | |
| 414 [1] : { | |
| 415 functionName : fib | |
| 416 ranges : [ | |
| 417 [0] : { | |
| 418 count : 1 | |
| 419 endOffset : 73 | |
| 420 startOffset : 1 | |
| 421 } | |
| 422 ] | |
| 423 } | |
| 424 [2] : { | |
| 425 functionName : is_optimized | |
| 426 ranges : [ | |
| 427 [0] : { | |
| 428 count : 0 | |
| 429 endOffset : 175 | |
| 430 startOffset : 74 | |
| 431 } | |
| 432 ] | |
| 433 } | |
| 434 [3] : { | |
| 435 functionName : iife | |
| 436 ranges : [ | |
| 437 [0] : { | |
| 438 count : 1 | |
| 439 endOffset : 208 | |
| 440 startOffset : 177 | |
| 441 } | |
| 442 ] | |
| 443 } | |
| 444 ] | |
| 445 scriptId : <scriptId> | |
| 446 url : testBestEffortCoverageWithPreciseCountEnabled | |
| 447 } | |
| 448 [1] : { | |
| 449 functions : [ | |
| 450 [0] : { | |
| 451 functionName : | |
| 452 ranges : [ | |
| 453 [0] : { | |
| 454 count : 1 | |
| 455 endOffset : 38 | |
| 456 startOffset : 0 | |
| 457 } | |
| 458 ] | |
| 459 } | |
| 460 ] | |
| 461 scriptId : <scriptId> | |
| 462 url : | |
| 463 } | |
| 464 ] | |
| 465 } | |
| 466 } | |
| 467 | |
| 468 Running test: testEnablePreciseCountCoverageAtPause | |
| 469 { | |
| 470 id : <messageId> | |
| 471 result : { | |
| 472 result : { | |
| 473 type : undefined | |
| 474 } | |
| 475 } | |
| 476 } | |
| 477 { | |
| 478 id : <messageId> | |
| 479 result : { | |
| 480 result : [ | |
| 481 [0] : { | |
| 482 functions : [ | |
| 483 [0] : { | |
| 484 functionName : | |
| 485 ranges : [ | |
| 486 [0] : { | |
| 487 count : 1 | |
| 488 endOffset : 114 | |
| 489 startOffset : 0 | |
| 490 } | |
| 491 ] | |
| 492 } | |
| 493 [1] : { | |
| 494 functionName : g | |
| 495 ranges : [ | |
| 496 [0] : { | |
| 497 count : 1 | |
| 498 endOffset : 29 | |
| 499 startOffset : 1 | |
| 500 } | |
| 501 ] | |
| 502 } | |
| 503 [2] : { | |
| 504 functionName : f | |
| 505 ranges : [ | |
| 506 [0] : { | |
| 507 count : 4 | |
| 508 endOffset : 83 | |
| 509 startOffset : 30 | |
| 510 } | |
| 511 ] | |
| 512 } | |
| 513 [3] : { | |
| 514 functionName : h | |
| 515 ranges : [ | |
| 516 [0] : { | |
| 517 count : 0 | |
| 518 endOffset : 107 | |
| 519 startOffset : 84 | |
| 520 } | |
| 521 ] | |
| 522 } | |
| 523 ] | |
| 524 scriptId : <scriptId> | |
| 525 url : testEnablePreciseCountCoverageAtPause | |
| 526 } | |
| 527 [1] : { | |
| 528 functions : [ | |
| 529 [0] : { | |
| 530 functionName : | |
| 531 ranges : [ | |
| 532 [0] : { | |
| 533 count : 1 | |
| 534 endOffset : 38 | |
| 535 startOffset : 0 | |
| 536 } | |
| 537 ] | |
| 538 } | |
| 539 ] | |
| 540 scriptId : <scriptId> | |
| 541 url : | |
| 542 } | |
| 543 ] | |
| 544 } | |
| 545 } | |
| 546 | |
| 547 Running test: testPreciseBinaryCoverage | |
| 548 { | |
| 549 id : <messageId> | |
| 550 result : { | |
| 551 result : { | |
| 552 description : 8 | |
| 553 type : number | |
| 554 value : 8 | |
| 555 } | |
| 556 } | |
| 557 } | |
| 558 { | |
| 559 id : <messageId> | |
| 560 result : { | |
| 561 result : [ | |
| 562 [0] : { | |
| 563 functions : [ | |
| 564 [0] : { | |
| 565 functionName : | |
| 566 ranges : [ | |
| 567 [0] : { | |
| 568 count : 1 | |
| 569 endOffset : 221 | |
| 570 startOffset : 0 | |
| 571 } | |
| 572 ] | |
| 573 } | |
| 574 [1] : { | |
| 575 functionName : fib | |
| 576 ranges : [ | |
| 577 [0] : { | |
| 578 count : 1 | |
| 579 endOffset : 73 | |
| 580 startOffset : 1 | |
| 581 } | |
| 582 ] | |
| 583 } | |
| 584 [2] : { | |
| 585 functionName : is_optimized | |
| 586 ranges : [ | |
| 587 [0] : { | |
| 588 count : 0 | |
| 589 endOffset : 175 | |
| 590 startOffset : 74 | |
| 591 } | |
| 592 ] | |
| 593 } | |
| 594 [3] : { | |
| 595 functionName : iife | |
| 596 ranges : [ | |
| 597 [0] : { | |
| 598 count : 1 | |
| 599 endOffset : 208 | |
| 600 startOffset : 177 | |
| 601 } | |
| 602 ] | |
| 603 } | |
| 604 ] | |
| 605 scriptId : <scriptId> | |
| 606 url : testPreciseBinaryCoverage | 699 url : testPreciseBinaryCoverage |
| 607 } | 700 } |
| 608 ] | 701 ] |
| 609 } | 702 } |
| 610 } | 703 } |
| 611 { | 704 { |
| 612 id : <messageId> | 705 id : <messageId> |
| 613 result : { | 706 result : { |
| 614 result : { | 707 result : { |
| 615 type : string | 708 type : string |
| (...skipping 20 matching lines...) Expand all Loading... |
| 636 } | 729 } |
| 637 } | 730 } |
| 638 } | 731 } |
| 639 { | 732 { |
| 640 id : <messageId> | 733 id : <messageId> |
| 641 result : { | 734 result : { |
| 642 result : [ | 735 result : [ |
| 643 [0] : { | 736 [0] : { |
| 644 functions : [ | 737 functions : [ |
| 645 [0] : { | 738 [0] : { |
| 739 functionName : |
| 740 ranges : [ |
| 741 [0] : { |
| 742 count : 0 |
| 743 endOffset : 221 |
| 744 startOffset : 0 |
| 745 } |
| 746 ] |
| 747 } |
| 748 [1] : { |
| 749 functionName : fib |
| 750 ranges : [ |
| 751 [0] : { |
| 752 count : 0 |
| 753 endOffset : 73 |
| 754 startOffset : 1 |
| 755 } |
| 756 ] |
| 757 } |
| 758 [2] : { |
| 646 functionName : is_optimized | 759 functionName : is_optimized |
| 647 ranges : [ | 760 ranges : [ |
| 648 [0] : { | 761 [0] : { |
| 649 count : 1 | 762 count : 1 |
| 650 endOffset : 175 | 763 endOffset : 175 |
| 651 startOffset : 74 | 764 startOffset : 74 |
| 652 } | 765 } |
| 653 ] | 766 ] |
| 654 } | 767 } |
| 768 [3] : { |
| 769 functionName : iife |
| 770 ranges : [ |
| 771 [0] : { |
| 772 count : 0 |
| 773 endOffset : 208 |
| 774 startOffset : 177 |
| 775 } |
| 776 ] |
| 777 } |
| 655 ] | 778 ] |
| 656 scriptId : <scriptId> | 779 scriptId : <scriptId> |
| 657 url : testPreciseBinaryCoverage | 780 url : testPreciseBinaryCoverage |
| 658 } | 781 } |
| 659 [1] : { | 782 [1] : { |
| 660 functions : [ | 783 functions : [ |
| 661 [0] : { | 784 [0] : { |
| 662 functionName : | 785 functionName : |
| 663 ranges : [ | 786 ranges : [ |
| 664 [0] : { | 787 [0] : { |
| (...skipping 19 matching lines...) Expand all Loading... |
| 684 } | 807 } |
| 685 ] | 808 ] |
| 686 } | 809 } |
| 687 ] | 810 ] |
| 688 scriptId : <scriptId> | 811 scriptId : <scriptId> |
| 689 url : | 812 url : |
| 690 } | 813 } |
| 691 ] | 814 ] |
| 692 } | 815 } |
| 693 } | 816 } |
| 694 | |
| 695 Running test: testPreciseEmptyScriptCoverageEntries | |
| 696 { | |
| 697 id : <messageId> | |
| 698 result : { | |
| 699 result : [ | |
| 700 ] | |
| 701 } | |
| 702 } | |
| 703 | |
| 704 Running test: testPreciseCountCoveragePartial | |
| 705 { | |
| 706 id : <messageId> | |
| 707 result : { | |
| 708 result : { | |
| 709 type : undefined | |
| 710 } | |
| 711 } | |
| 712 } | |
| 713 { | |
| 714 id : <messageId> | |
| 715 result : { | |
| 716 result : [ | |
| 717 [0] : { | |
| 718 functions : [ | |
| 719 [0] : { | |
| 720 functionName : | |
| 721 ranges : [ | |
| 722 [0] : { | |
| 723 count : 1 | |
| 724 endOffset : 238 | |
| 725 startOffset : 0 | |
| 726 } | |
| 727 ] | |
| 728 } | |
| 729 [1] : { | |
| 730 functionName : outer | |
| 731 ranges : [ | |
| 732 [0] : { | |
| 733 count : 1 | |
| 734 endOffset : 224 | |
| 735 startOffset : 10 | |
| 736 } | |
| 737 ] | |
| 738 } | |
| 739 [2] : { | |
| 740 functionName : nested_0 | |
| 741 ranges : [ | |
| 742 [0] : { | |
| 743 count : 1 | |
| 744 endOffset : 176 | |
| 745 startOffset : 31 | |
| 746 } | |
| 747 ] | |
| 748 } | |
| 749 [3] : { | |
| 750 functionName : nested_1 | |
| 751 ranges : [ | |
| 752 [0] : { | |
| 753 count : 1 | |
| 754 endOffset : 172 | |
| 755 startOffset : 64 | |
| 756 } | |
| 757 ] | |
| 758 } | |
| 759 [4] : { | |
| 760 functionName : nested_2 | |
| 761 ranges : [ | |
| 762 [0] : { | |
| 763 count : 1 | |
| 764 endOffset : 166 | |
| 765 startOffset : 99 | |
| 766 } | |
| 767 ] | |
| 768 } | |
| 769 [5] : { | |
| 770 functionName : nested_3 | |
| 771 ranges : [ | |
| 772 [0] : { | |
| 773 count : 1 | |
| 774 endOffset : 158 | |
| 775 startOffset : 136 | |
| 776 } | |
| 777 ] | |
| 778 } | |
| 779 [6] : { | |
| 780 functionName : nested_4 | |
| 781 ranges : [ | |
| 782 [0] : { | |
| 783 count : 0 | |
| 784 endOffset : 201 | |
| 785 startOffset : 179 | |
| 786 } | |
| 787 ] | |
| 788 } | |
| 789 ] | |
| 790 scriptId : <scriptId> | |
| 791 url : testPreciseCountCoveragePartial | |
| 792 } | |
| 793 ] | |
| 794 } | |
| 795 } | |
| 796 { | |
| 797 id : <messageId> | |
| 798 result : { | |
| 799 result : [ | |
| 800 [0] : { | |
| 801 functions : [ | |
| 802 [0] : { | |
| 803 functionName : nested_1 | |
| 804 ranges : [ | |
| 805 [0] : { | |
| 806 count : 1 | |
| 807 endOffset : 172 | |
| 808 startOffset : 64 | |
| 809 } | |
| 810 ] | |
| 811 } | |
| 812 [1] : { | |
| 813 functionName : nested_2 | |
| 814 ranges : [ | |
| 815 [0] : { | |
| 816 count : 0 | |
| 817 endOffset : 166 | |
| 818 startOffset : 99 | |
| 819 } | |
| 820 ] | |
| 821 } | |
| 822 ] | |
| 823 scriptId : <scriptId> | |
| 824 url : testPreciseCountCoveragePartial | |
| 825 } | |
| 826 [1] : { | |
| 827 functions : [ | |
| 828 [0] : { | |
| 829 functionName : | |
| 830 ranges : [ | |
| 831 [0] : { | |
| 832 count : 1 | |
| 833 endOffset : 3 | |
| 834 startOffset : 0 | |
| 835 } | |
| 836 ] | |
| 837 } | |
| 838 ] | |
| 839 scriptId : <scriptId> | |
| 840 url : | |
| 841 } | |
| 842 ] | |
| 843 } | |
| 844 } | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2769063004:
Revert of [debug] do not report unnecessary coverage data. (Closed)
