Google Git
Sign in
rust/rust-lang/rust/refs/heads/perf-tmp/./tests/coverage
tree: 38bd24cc38653d68b12291003f2f40d466268eb4
  1. attr/
  2. auxiliary/
  3. branch/
  4. condition/
  5. macros/
  6. abort.cov-map
  7. abort.coverage
  8. abort.rs
  9. assert-ne.cov-map
  10. assert-ne.coverage
  11. assert-ne.rs
  12. assert.cov-map
  13. assert.coverage
  14. assert.rs
  15. assert_not.cov-map
  16. assert_not.coverage
  17. assert_not.rs
  18. async.cov-map
  19. async.coverage
  20. async.rs
  21. async2.cov-map
  22. async2.coverage
  23. async2.rs
  24. async_block.cov-map
  25. async_block.coverage
  26. async_block.rs
  27. async_closure.cov-map
  28. async_closure.coverage
  29. async_closure.rs
  30. async_closure2.cov-map
  31. async_closure2.coverage
  32. async_closure2.rs
  33. auto-derived.auto.cov-map
  34. auto-derived.auto.coverage
  35. auto-derived.base.cov-map
  36. auto-derived.base.coverage
  37. auto-derived.on.cov-map
  38. auto-derived.on.coverage
  39. auto-derived.rs
  40. await_ready.cov-map
  41. await_ready.coverage
  42. await_ready.rs
  43. bad_counter_ids.cov-map
  44. bad_counter_ids.coverage
  45. bad_counter_ids.rs
  46. bench.cov-map
  47. bench.coverage
  48. bench.rs
  49. closure.cov-map
  50. closure.coverage
  51. closure.rs
  52. closure_bug.cov-map
  53. closure_bug.coverage
  54. closure_bug.rs
  55. closure_macro.cov-map
  56. closure_macro.coverage
  57. closure_macro.rs
  58. closure_macro_async.cov-map
  59. closure_macro_async.coverage
  60. closure_macro_async.rs
  61. closure_unit_return.cov-map
  62. closure_unit_return.coverage
  63. closure_unit_return.rs
  64. color.coverage
  65. color.rs
  66. conditions.cov-map
  67. conditions.coverage
  68. conditions.rs
  69. continue.cov-map
  70. continue.coverage
  71. continue.rs
  72. coroutine.cov-map
  73. coroutine.coverage
  74. coroutine.rs
  75. coverage_attr_closure.cov-map
  76. coverage_attr_closure.coverage
  77. coverage_attr_closure.rs
  78. dead_code.cov-map
  79. dead_code.coverage
  80. dead_code.rs
  81. discard-all-issue-133606.coverage
  82. discard-all-issue-133606.rs
  83. drop_trait.cov-map
  84. drop_trait.coverage
  85. drop_trait.rs
  86. fn_sig_into_try.cov-map
  87. fn_sig_into_try.coverage
  88. fn_sig_into_try.rs
  89. generic-unused-impl.cov-map
  90. generic-unused-impl.coverage
  91. generic-unused-impl.rs
  92. generics.cov-map
  93. generics.coverage
  94. generics.rs
  95. holes.cov-map
  96. holes.coverage
  97. holes.rs
  98. if.cov-map
  99. if.coverage
  100. if.rs
  101. if_else.cov-map
  102. if_else.coverage
  103. if_else.rs
  104. if_not.cov-map
  105. if_not.coverage
  106. if_not.rs
  107. ignore_map.coverage
  108. ignore_map.rs
  109. ignore_run.cov-map
  110. ignore_run.rs
  111. inline-dead.cov-map
  112. inline-dead.coverage
  113. inline-dead.rs
  114. inline.cov-map
  115. inline.coverage
  116. inline.rs
  117. inline_mixed.rs
  118. inner_items.cov-map
  119. inner_items.coverage
  120. inner_items.rs
  121. issue-83601.cov-map
  122. issue-83601.coverage
  123. issue-83601.rs
  124. issue-84561.cov-map
  125. issue-84561.coverage
  126. issue-84561.rs
  127. issue-85461.cov-map
  128. issue-85461.coverage
  129. issue-85461.rs
  130. issue-93054.cov-map
  131. issue-93054.coverage
  132. issue-93054.rs
  133. lazy_boolean.cov-map
  134. lazy_boolean.coverage
  135. lazy_boolean.rs
  136. let_else_loop.cov-map
  137. let_else_loop.coverage
  138. let_else_loop.rs
  139. long_and_wide.cov-map
  140. long_and_wide.coverage
  141. long_and_wide.rs
  142. loop-break.cov-map
  143. loop-break.coverage
  144. loop-break.rs
  145. loop_break_value.cov-map
  146. loop_break_value.coverage
  147. loop_break_value.rs
  148. loops_branches.cov-map
  149. loops_branches.coverage
  150. loops_branches.rs
  151. macro_in_closure.cov-map
  152. macro_in_closure.coverage
  153. macro_in_closure.rs
  154. macro_name_span.cov-map
  155. macro_name_span.coverage
  156. macro_name_span.rs
  157. match_or_pattern.cov-map
  158. match_or_pattern.coverage
  159. match_or_pattern.rs
  160. nested_loops.cov-map
  161. nested_loops.coverage
  162. nested_loops.rs
  163. no-core.cov-map
  164. no-core.coverage
  165. no-core.rs
  166. no_cov_crate.cov-map
  167. no_cov_crate.coverage
  168. no_cov_crate.rs
  169. no_spans.cov-map
  170. no_spans.coverage
  171. no_spans.rs
  172. no_spans_if_not.cov-map
  173. no_spans_if_not.coverage
  174. no_spans_if_not.rs
  175. overflow.cov-map
  176. overflow.coverage
  177. overflow.rs
  178. panic_unwind.cov-map
  179. panic_unwind.coverage
  180. panic_unwind.rs
  181. partial_eq.cov-map
  182. partial_eq.coverage
  183. partial_eq.rs
  184. README.md
  185. remap-path-prefix.rs
  186. remap-path-prefix.with_coverage_scope.cov-map
  187. remap-path-prefix.with_macro_scope.cov-map
  188. remap-path-prefix.with_macro_scope.coverage
  189. remap-path-prefix.with_object_scope.cov-map
  190. remap-path-prefix.with_remap.cov-map
  191. rustfmt-skip.cov-map
  192. rustfmt-skip.coverage
  193. rustfmt-skip.rs
  194. simple_loop.cov-map
  195. simple_loop.coverage
  196. simple_loop.rs
  197. simple_match.cov-map
  198. simple_match.coverage
  199. simple_match.rs
  200. sort_groups.cov-map
  201. sort_groups.coverage
  202. sort_groups.rs
  203. test_harness.cov-map
  204. test_harness.coverage
  205. test_harness.rs
  206. tight_inf_loop.cov-map
  207. tight_inf_loop.coverage
  208. tight_inf_loop.rs
  209. trivial.cov-map
  210. trivial.coverage
  211. trivial.rs
  212. try-in-macro.attr.cov-map
  213. try-in-macro.attr.coverage
  214. try-in-macro.bang.cov-map
  215. try-in-macro.bang.coverage
  216. try-in-macro.derive.cov-map
  217. try-in-macro.derive.coverage
  218. try-in-macro.rs
  219. try_error_result.cov-map
  220. try_error_result.coverage
  221. try_error_result.rs
  222. unicode.cov-map
  223. unicode.coverage
  224. unicode.rs
  225. unreachable.cov-map
  226. unreachable.coverage
  227. unreachable.rs
  228. unused.cov-map
  229. unused.coverage
  230. unused.rs
  231. unused_mod.cov-map
  232. unused_mod.coverage
  233. unused_mod.rs
  234. uses_crate.cov-map
  235. uses_crate.coverage
  236. uses_crate.rs
  237. uses_inline_crate.cov-map
  238. uses_inline_crate.coverage
  239. uses_inline_crate.rs
  240. while.cov-map
  241. while.coverage
  242. while.rs
  243. while_early_ret.cov-map
  244. while_early_ret.coverage
  245. while_early_ret.rs
  246. yield.cov-map
  247. yield.coverage
  248. yield.rs
tests/coverage/README.md

The tests in this directory are shared by two different test modes, and can be run in multiple different ways:

  • ./x.py test coverage-map (compiles to LLVM IR and checks coverage mappings)
  • ./x.py test coverage-run (runs a test binary and checks its coverage report)
  • ./x.py test coverage (runs both coverage-map and coverage-run)

Maintenance note

These tests can be sensitive to small changes in MIR spans or MIR control flow, especially in HIR-to-MIR lowering or MIR optimizations.

If you haven't touched the coverage code directly, and the tests still pass in coverage-run mode, then it should usually be OK to just re-bless the mappings as necessary with ./x.py test coverage-map --bless, without worrying too much about the exact changes.