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