fix(test/*): make sure tests produce no output (#3947)

Modify tests so that they produce no output. This also means removing all uses of `sorry`/`admit`.
Replace `#eval` by `run_cmd` consistently.
Tests that produced output before are modified so that it is checked that they roughly produce the right output
Add a trace option to the `#simp` command that turns the message of only if the expression is simplified to `true`. All tests are modified so that they simplify to `true`.
The randomized tests can produce output when they find a false positive, but that should basically never happen.
Add some docstings to `src/tactic/interactive`.

Author: fpvandoorn

src/tactic/interactive.lean

@@ -391,7 +391,6 @@ We use this tactic for writing tests.
 meta def guard_target_strict (p : parse texpr) : tactic unit :=
 do t ← target, guard_expr_strict t p
 
-
 /--
 `guard_hyp_strict h : t` fails if the hypothesis `h` does not have type syntactically equal
 to `t`.
@@ -400,19 +399,33 @@ We use this tactic for writing tests.
 meta def guard_hyp_strict (n : parse ident) (p : parse $ tk ":" *> texpr) : tactic unit :=
 do h ← get_local n >>= infer_type >>= instantiate_mvars, guard_expr_strict h p
 
+/-- Tests that there are `n` hypotheses in the current context. -/
 meta def guard_hyp_nums (n : ℕ) : tactic unit :=
 do k ← local_context,
    guard (n = k.length) <|> fail format!"{k.length} hypotheses found"
 
+/-- Test that `t` is the tag of the main goal. -/
 meta def guard_tags (tags : parse ident*) : tactic unit :=
 do (t : list name) ← get_main_tag,
    guard (t = tags)
 
+/-- `guard_proof_term { t } e` applies tactic `t` and tests whether the resulting proof term
+  unifies with `p`. -/
+meta def guard_proof_term (t : itactic) (p : parse texpr) : itactic :=
+do
+  g :: _ ← get_goals,
+  e ← to_expr p,
+  t,
+  g ← instantiate_mvars g,
+  unify e g
+
+
 /-- `success_if_fail_with_msg { tac } msg` succeeds if the interactive tactic `tac` fails with
 error message `msg` (for test writing purposes). -/
 meta def success_if_fail_with_msg (tac : tactic.interactive.itactic) :=
 tactic.success_if_fail_with_msg tac
 
+/-- Get the field of the current goal. -/
 meta def get_current_field : tactic name :=
 do [_,field,str] ← get_main_tag,
    expr.const_name <$> resolve_name (field.update_prefix str)
@@ -649,12 +662,16 @@ add_tactic_doc
   decl_names := [`tactic.interactive.field_simp],
   tags       := ["simplification", "arithmetic"] }
 
+/-- Tests whether `t` is definitionally equal to `p`. The difference with `guard_expr_eq` is that
+  this uses definitional equality instead of alpha-equivalence. -/
 meta def guard_expr_eq' (t : expr) (p : parse $ tk ":=" *> texpr) : tactic unit :=
 do e ← to_expr p, is_def_eq t e
 
 /--
-`guard_target t` fails if the target of the main goal is not `t`.
+`guard_target' t` fails if the target of the main goal is not definitionally equal to `t`.
 We use this tactic for writing tests.
+The difference with `guard_target` is that this uses definitional equality instead of
+alpha-equivalence.
 -/
 meta def guard_target' (p : parse texpr) : tactic unit :=
 do t ← target, guard_expr_eq' t p

src/tactic/simp_command.lean

@@ -46,6 +46,9 @@ meta def simp_arg_type.replace_subexprs : simp_arg_type → list (expr × expr)
 
 setup_tactic_parser
 
+/- Turn off the messages if the result is exactly `true` with this option. -/
+declare_trace silence_simp_if_true
+
 /--
 The basic usage is `#simp e`, where `e` is an expression,
 which will print the simplified form of `e`.
@@ -100,7 +103,8 @@ do
   } ts,
 
   /- Trace the result. -/
-  trace simp_result
+  when (¬ is_trace_enabled_for `silence_simp_if_true ∨ simp_result ≠ expr.const `true [])
+    (trace simp_result)
 
 add_tactic_doc
 { name                     := "#simp",

src/tactic/squeeze.lean

@@ -185,6 +185,15 @@ namespace interactive
 
 attribute [derive decidable_eq] simp_arg_type
 
+/-- Turn a `simp_arg_type` into a string. -/
+meta instance simp_arg_type.has_to_string : has_to_string simp_arg_type :=
+⟨λ a, match a with
+| simp_arg_type.all_hyps := "*"
+| (simp_arg_type.except n) := "-" ++ to_string n
+| (simp_arg_type.expr e) := to_string e
+| (simp_arg_type.symm_expr e) := "←" ++ to_string e
+end⟩
+
 /-- combinator meant to aggregate the suggestions issued by multiple calls
 of `squeeze_simp` (due, for instance, to `;`).
 

test/README.md

@@ -0,0 +1,15 @@
+# The Mathlib Test Directory
+
+In this directory we collect various tests for the commands, tactics and metaprograms written in
+mathlib (see [the tactic folder](../src/tactic)).
+
+Tests for all tactics are highly encouraged, especially if they are used sparingly in mathlib.
+Here are some guidelines for writing a test:
+
+* Make sure that the test fails if something unexpected happens. Use `guard`, `guard_target`, `guard_hyp`, `get_decl` or similar tactics that fail if the tactic state is incorrect.
+* Make sure that the test is silent, i.e. produces no output when it succeeds. This makes it easy to spot the tests that actually failed. Furthermore, it is unlikely that anyone will notice the output changing if the test keeps succeeding.
+
+Some tips to make a test silent:
+* Instead of `trace e`, write `guard (e = expected_expression)`.
+* If you write a tactic/command that normally produces output, consider adding an option that silences it. See for example the uses of `set_option trace.silence_library_search true` in the [library_search](library_search) folder.
+* Do not prove a lemma using `admit` or `sorry`. Instead make sure that the lemma is provable, and prove it by `assumption` or `trivial` or similar.

test/continuity.lean

@@ -6,28 +6,27 @@ import analysis.special_functions.trigonometric
 example {X Y : Type*} [topological_space X] [topological_space Y]
   (f₁ f₂ : X → Y) (hf₁ : continuous f₁) (hf₂ : continuous f₂)
   (g : Y → ℝ) (hg : continuous g) : continuous (λ x, (max (g (f₁ x)) (g (f₂ x))) + 1) :=
-by show_term { continuity }
--- prints `refine ((continuous.comp hg hf₁).max (continuous.comp hg hf₂)).add continuous_const`
+by guard_proof_term { continuity } ((hg.comp hf₁).max (hg.comp hf₂)).add continuous_const
 
 example {κ ι : Type}
   (K : κ → Type) [∀ k, topological_space (K k)] (I : ι → Type) [∀ i, topological_space (I i)]
   (e : κ ≃ ι) (F : Π k, homeomorph (K k) (I (e k))) :
   continuous (λ (f : Π k, K k) (i : ι), F (e.symm i) (f (e.symm i))) :=
-by show_term { continuity }
--- prints, modulo a little bit of cleaning up the pretty printer:
---   `exact continuous_pi (λ i, ((F (e.symm i)).continuous).comp (continuous_apply (e.symm i)))`
+by guard_proof_term { continuity }
+  @continuous_pi _ _ _ _ _ (λ (f : Π k, K k) i, (F (e.symm i)) (f (e.symm i)))
+    (λ (i : ι), ((F (e.symm i)).continuous).comp (continuous_apply (e.symm i)))
 
 open real
 
 local attribute [continuity] continuous_exp continuous_sin continuous_cos
 
 example : continuous (λ x : ℝ, exp ((max x (-x)) + sin x)^2) :=
-by show_term { continuity }
--- prints
---   `exact (continuous_exp.comp ((continuous_id.max continuous_id.neg).add continuous_sin)).pow 2`
+by guard_proof_term { continuity }
+  (continuous_exp.comp ((continuous_id.max continuous_id.neg).add continuous_sin)).pow 2
 
 example : continuous (λ x : ℝ, exp ((max x (-x)) + sin (cos x))^2) :=
-by show_term { continuity }
+by guard_proof_term { continuity }
+ (continuous_exp.comp ((continuous_id'.max continuous_id'.neg).add (continuous_sin.comp continuous_cos))).pow 2
 
 -- Without `md := semireducible` in the call to `apply_rules` in `continuity`,
 -- this last example would have run off the rails:

test/doc_commands.lean

@@ -9,7 +9,7 @@ def foo := 5
 /-- ok -/
 add_decl_doc foo
 
-#eval do
+run_cmd do
 ds ← doc_string ``foo,
 guard $ ds = "ok"
 

test/general_recursion.lean

@@ -195,8 +195,7 @@ by rw roption.dom_iff_mem; apply exists_imp_exists _ (f91_spec n); simp
 
 def f91' (n : ℕ) : ℕ := (f91 n).get (f91_dom n)
 
-#eval f91' 109
--- 99
+run_cmd guard (f91' 109 = 99)
 
 lemma f91_spec' (n : ℕ) : f91' n = if n > 100 then n - 10 else 91 :=
 begin

test/library_search/exp_le_exp.lean

@@ -3,4 +3,7 @@ import analysis.special_functions.exp_log
 
 open real
 
+/- Turn off trace messages so they don't pollute the test build: -/
+set_option trace.silence_library_search true
+
 example {a b : ℝ} (h: a ≤ b) : exp a ≤ exp b := by library_search

test/library_search/filter.lean

@@ -2,6 +2,9 @@ import order.filter.basic
 
 open filter
 
+/- Turn off trace messages so they don't pollute the test build: -/
+set_option trace.silence_library_search true
+
 example {α β γ : Type*} {A : filter α} {B : filter β} {C : filter γ} {f : α → β} {g : β → γ}
   (hf : tendsto f A B) (hg : tendsto g B C) : tendsto (g ∘ f) A C :=
 calc

test/library_search/nat.lean

@@ -8,7 +8,6 @@ import data.nat.basic
 
 namespace test.library_search
 
-
 /- Turn off trace messages so they don't pollute the test build: -/
 set_option trace.silence_library_search true
 /- For debugging purposes, we can display the list of lemmas: -/