Migrate tests under testsuite/tests/basic to ocamltest

33 files changed, 156 insertions, 182 deletions

diff --git a/.gitignore b/.gitignore
index 6e61de5192..ac93a38692 100644
--- a/.gitignore
+++ b/.gitignore
@@ -252,7 +252,6 @@ _ocamltest
 /testsuite/tests/asmgen/*.s
 /testsuite/tests/asmgen/*.out.manifest
 
-/testsuite/tests/basic/*.safe-string
 
 /testsuite/tests/embedded/caml
 
diff --git a/testsuite/tests/basic/Makefile b/testsuite/tests/basic/Makefile
deleted file mode 100644
index 26cdeadf21..0000000000
--- a/testsuite/tests/basic/Makefile
+++ /dev/null
@@ -1,10 +0,0 @@
-BASEDIR=../..
-include $(BASEDIR)/makefiles/Makefile.several
-include $(BASEDIR)/makefiles/Makefile.common
-
-# The trigraph.ml test always fails under OpenBSD 6 / i386
-# because of an unrelated warning emitted by the linker called by ocamlopt
-# (see commit log for details).
-# As a temporary workaround, we skip this test.
-SKIP=test $$file = trigraph.ml \
-     && test `uname -m` = i386 && test `uname -s` = OpenBSD
diff --git a/testsuite/tests/basic/arrays.ml b/testsuite/tests/basic/arrays.ml
index 1ec4e4ebf5..83cc796cae 100644
--- a/testsuite/tests/basic/arrays.ml
+++ b/testsuite/tests/basic/arrays.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let bigarray n = [|
 n+0; n+1; n+2; n+3; n+4; n+5; n+6; n+7; n+8; n+9; n+10; n+11; n+12;
 n+13; n+14; n+15; n+16; n+17; n+18; n+19; n+20; n+21; n+22; n+23;
diff --git a/testsuite/tests/basic/bigints.ml b/testsuite/tests/basic/bigints.ml
index 23e571c3fc..281c1b092c 100644
--- a/testsuite/tests/basic/bigints.ml
+++ b/testsuite/tests/basic/bigints.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let _ =
   match Sys.word_size with
   | 32 ->
diff --git a/testsuite/tests/basic/boxedints.ml b/testsuite/tests/basic/boxedints.ml
index 016916f4d8..e3ff7000f5 100644
--- a/testsuite/tests/basic/boxedints.ml
+++ b/testsuite/tests/basic/boxedints.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* Test the types nativeint, int32, int64 *)
 
 open Printf
diff --git a/testsuite/tests/basic/constprop.ml b/testsuite/tests/basic/constprop.ml
index 89d988831e..c89b182494 100644
--- a/testsuite/tests/basic/constprop.ml
+++ b/testsuite/tests/basic/constprop.ml
@@ -1,104 +1,124 @@
+(* TEST
+   flags = "-pp '${c_preprocessor}'"
+   * bytecode
+     compare_programs = "false"
+   * native
+*)
+
 (* Test constant propagation through inlining *)
 
 (* constprop.ml is generated from constprop.mlp using
       cpp constprop.mlp > constprop.ml
 *)
+
+#define tbool(x,y) \
+  (x && y, x || y, not x)
+
+#define tint(x,y,s)                                                         \
+  (-x, x + y, x - y, x * y, x / y, x mod y,                                 \
+   x land y, x lor y, x lxor y,                                             \
+   x lsl s, x lsr s, x asr s,                                               \
+   x = y, x <> y, x < y, x <= y, x > y, x >= y,                             \
+   succ x, pred y)
+
+#define tfloat(x,y)                                                         \
+  (int_of_float x,                                                          \
+   x +. y, x -. y, x *. y, x /. y,                                          \
+   x = y, x <> y, x < y, x <= y, x > y, x >= y)
+
+#define tconvint(i)                                                         \
+  (float_of_int i,                                                          \
+   Int32.of_int i,                                                          \
+   Nativeint.of_int i,                                                      \
+   Int64.of_int i)
+
+#define tconvint32(i)                                                       \
+  (Int32.to_int i,                                                          \
+   Nativeint.of_int32 i,                                                    \
+   Int64.of_int32 i)
+
+#define tconvnativeint(i)                                                   \
+  (Nativeint.to_int i,                                                      \
+   Nativeint.to_int32 i,                                                    \
+   Int64.of_nativeint i)
+
+#define tconvint64(i)                                                       \
+  (Int64.to_int i,                                                          \
+   Int64.to_int32 i,                                                        \
+   Int64.to_nativeint i)                                                    \
+
+#define tint32(x,y,s)                                                       \
+  Int32.(neg x, add x y, sub x y, mul x y, div x y, rem x y,                \
+         logand x y, logor x y, logxor x y,                                 \
+         shift_left x s, shift_right x s, shift_right_logical x s,          \
+         x = y, x <> y, x < y, x <= y, x > y, x >= y)
+
+#define tnativeint(x,y,s)                                                   \
+  Nativeint.(neg x, add x y, sub x y, mul x y, div x y, rem x y,            \
+         logand x y, logor x y, logxor x y,                                 \
+         shift_left x s, shift_right x s, shift_right_logical x s,          \
+         x = y, x <> y, x < y, x <= y, x > y, x >= y)
+
+#define tint64(x,y,s)                                                       \
+  Int64.(neg x, add x y, sub x y, mul x y, div x y, rem x y,                \
+         logand x y, logor x y, logxor x y,                                 \
+         shift_left x s, shift_right x s, shift_right_logical x s,          \
+         x = y, x <> y, x < y, x <= y, x > y, x >= y)
+
 let do_test msg res1 res2 =
   Printf.printf "%s: %s\n" msg (if res1 = res2 then "passed" else "FAILED")
+
 (* Hide a constant from the optimizer, preventing constant propagation *)
 let hide x = List.nth [x] 0
+
 let _ =
   begin
     let x = true and y = false in
     let xh = hide x and yh = hide y in
-    do_test "booleans" ((x && y, x || y, not x)) ((xh && yh, xh || yh, not xh))
+    do_test "booleans" (tbool(x, y)) (tbool(xh,yh))
   end;
   begin
     let x = 89809344 and y = 457455773 and s = 7 in
     let xh = hide x and yh = hide y and sh = hide s in
-    do_test "integers"
-      ((-x, x + y, x - y, x * y, x / y, x mod y, x land y,
-        x lor y, x lxor y, x lsl s, x lsr s, x asr s, x = y,
-        x <> y, x < y, x <= y, x > y, x >= y, succ x, pred y))
-      ((-xh, xh + yh, xh - yh, xh * yh, xh / yh, xh mod yh, xh land yh,
-        xh lor yh, xh lxor yh, xh lsl sh, xh lsr sh, xh asr sh, xh = yh,
-        xh <> yh, xh < yh, xh <= yh, xh > yh, xh >= yh, succ xh, pred yh))
+    do_test "integers" (tint(x, y, s)) (tint(xh,yh,sh))
   end;
   begin
     let x = 3.141592654 and y = 0.341638588598232096 in
     let xh = hide x and yh = hide y in
-    do_test "floats"
-      ((int_of_float x, x +. y, x -. y, x *. y, x /. y, x = y,
-        x <> y, x < y, x <= y, x > y, x >= y))
-      ((int_of_float xh, xh +. yh, xh -. yh, xh *. yh, xh /. yh, xh = yh,
-        xh <> yh, xh < yh, xh <= yh, xh > yh, xh >= yh))
+    do_test "floats" (tfloat(x, y)) (tfloat(xh, yh))
   end;
   begin
     let x = 781944104l and y = 308219921l and s = 3 in
     let xh = hide x and yh = hide y and sh = hide s in
-    do_test "32-bit integers"
-      (Int32.(neg x, add x y, sub x y, mul x y, div x y, rem x y,
-              logand x y, logor x y, logxor x y, shift_left x s,
-              shift_right x s, shift_right_logical x s, x = y, x <> y,
-              x < y, x <= y, x > y, x >= y))
-      (Int32.(neg xh, add xh yh, sub xh yh, mul xh yh, div xh yh, rem xh yh,
-              logand xh yh, logor xh yh, logxor xh yh, shift_left xh sh,
-              shift_right xh sh, shift_right_logical xh sh, xh = yh, xh <> yh,
-              xh < yh, xh <= yh, xh > yh, xh >= yh))
+    do_test "32-bit integers" (tint32(x, y, s)) (tint32(xh, yh, sh))
   end;
   begin
     let x = 1828697041n and y = -521695949n and s = 8 in
     let xh = hide x and yh = hide y and sh = hide s in
-    do_test "native integers"
-      (Nativeint.(neg x, add x y, sub x y, mul x y, div x y,
-                  rem x y, logand x y, logor x y, logxor x y,
-                  shift_left x s, shift_right x s,
-                  shift_right_logical x s, x = y, x <> y, x < y,
-                  x <= y, x > y, x >= y))
-      (Nativeint.(neg xh, add xh yh, sub xh yh, mul xh yh, div xh yh,
-                  rem xh yh, logand xh yh, logor xh yh, logxor xh yh,
-                  shift_left xh sh, shift_right xh sh,
-                  shift_right_logical xh sh, xh = yh, xh <> yh, xh < yh,
-                  xh <= yh, xh > yh, xh >= yh))
+    do_test "native integers" (tnativeint(x, y, s)) (tnativeint(xh, yh, sh))
   end;
   begin
     let x = 1511491586921138079L and y = 6677538715441746158L and s = 17 in
     let xh = hide x and yh = hide y and sh = hide s in
-    do_test "64-bit integers"
-      (Int64.(neg x, add x y, sub x y, mul x y, div x y, rem x y,
-              logand x y, logor x y, logxor x y, shift_left x s,
-              shift_right x s, shift_right_logical x s, x = y, x <> y,
-              x < y, x <= y, x > y, x >= y))
-      (Int64.(neg xh, add xh yh, sub xh yh, mul xh yh, div xh yh, rem xh yh,
-              logand xh yh, logor xh yh, logxor xh yh, shift_left xh sh,
-              shift_right xh sh, shift_right_logical xh sh, xh = yh, xh <> yh,
-              xh < yh, xh <= yh, xh > yh, xh >= yh))
+    do_test "64-bit integers" (tint64(x, y, s)) (tint64(xh, yh, sh))
   end;
   begin
     let x = 1000807289 in
     let xh = hide x in
-    do_test "integer conversions"
-      ((float_of_int x, Int32.of_int x, Nativeint.of_int x, Int64.of_int x))
-      ((float_of_int xh, Int32.of_int xh, Nativeint.of_int xh, Int64.of_int xh))
+    do_test "integer conversions" (tconvint(x)) (tconvint(xh))
   end;
   begin
     let x = 10486393l in
     let xh = hide x in
-    do_test "32-bit integer conversions"
-      ((Int32.to_int x, Nativeint.of_int32 x, Int64.of_int32 x))
-      ((Int32.to_int xh, Nativeint.of_int32 xh, Int64.of_int32 xh))
+    do_test "32-bit integer conversions" (tconvint32(x)) (tconvint32(xh))
   end;
   begin
     let x = -131134014n in
     let xh = hide x in
-    do_test "native integer conversions"
-      ((Nativeint.to_int x, Nativeint.to_int32 x, Int64.of_nativeint x))
-      ((Nativeint.to_int xh, Nativeint.to_int32 xh, Int64.of_nativeint xh))
+    do_test "native integer conversions" (tconvnativeint(x))(tconvnativeint(xh))
   end;
   begin
     let x = 531871273453404175L in
     let xh = hide x in
-    do_test "64-bit integer conversions"
-      ((Int64.to_int x, Int64.to_int32 x, Int64.to_nativeint x))
-      ((Int64.to_int xh, Int64.to_int32 xh, Int64.to_nativeint xh))
+    do_test "64-bit integer conversions" (tconvint64(x)) (tconvint64(xh))
   end
diff --git a/testsuite/tests/basic/constprop.mlp b/testsuite/tests/basic/constprop.mlp
deleted file mode 100644
index f08bc50fa6..0000000000
--- a/testsuite/tests/basic/constprop.mlp
+++ /dev/null
@@ -1,117 +0,0 @@
-(* Test constant propagation through inlining *)
-
-(* constprop.ml is generated from constprop.mlp using
-      cpp constprop.mlp > constprop.ml
-*)
-
-#define tbool(x,y) \
-  (x && y, x || y, not x)
-
-#define tint(x,y,s)                                                         \
-  (-x, x + y, x - y, x * y, x / y, x mod y,                                 \
-   x land y, x lor y, x lxor y,                                             \
-   x lsl s, x lsr s, x asr s,                                               \
-   x = y, x <> y, x < y, x <= y, x > y, x >= y,                             \
-   succ x, pred y)
-
-#define tfloat(x,y)                                                         \
-  (int_of_float x,                                                          \
-   x +. y, x -. y, x *. y, x /. y,                                          \
-   x = y, x <> y, x < y, x <= y, x > y, x >= y)
-
-#define tconvint(i)                                                         \
-  (float_of_int i,                                                          \
-   Int32.of_int i,                                                          \
-   Nativeint.of_int i,                                                      \
-   Int64.of_int i)
-
-#define tconvint32(i)                                                       \
-  (Int32.to_int i,                                                          \
-   Nativeint.of_int32 i,                                                    \
-   Int64.of_int32 i)
-
-#define tconvnativeint(i)                                                   \
-  (Nativeint.to_int i,                                                      \
-   Nativeint.to_int32 i,                                                    \
-   Int64.of_nativeint i)
-
-#define tconvint64(i)                                                       \
-  (Int64.to_int i,                                                          \
-   Int64.to_int32 i,                                                        \
-   Int64.to_nativeint i)                                                    \
-
-#define tint32(x,y,s)                                                       \
-  Int32.(neg x, add x y, sub x y, mul x y, div x y, rem x y,                \
-         logand x y, logor x y, logxor x y,                                 \
-         shift_left x s, shift_right x s, shift_right_logical x s,          \
-         x = y, x <> y, x < y, x <= y, x > y, x >= y)
-
-#define tnativeint(x,y,s)                                                   \
-  Nativeint.(neg x, add x y, sub x y, mul x y, div x y, rem x y,            \
-         logand x y, logor x y, logxor x y,                                 \
-         shift_left x s, shift_right x s, shift_right_logical x s,          \
-         x = y, x <> y, x < y, x <= y, x > y, x >= y)
-
-#define tint64(x,y,s)                                                       \
-  Int64.(neg x, add x y, sub x y, mul x y, div x y, rem x y,                \
-         logand x y, logor x y, logxor x y,                                 \
-         shift_left x s, shift_right x s, shift_right_logical x s,          \
-         x = y, x <> y, x < y, x <= y, x > y, x >= y)
-
-let do_test msg res1 res2 =
-  Printf.printf "%s: %s\n" msg (if res1 = res2 then "passed" else "FAILED")
-
-(* Hide a constant from the optimizer, preventing constant propagation *)
-let hide x = List.nth [x] 0
-
-let _ =
-  begin
-    let x = true and y = false in
-    let xh = hide x and yh = hide y in
-    do_test "booleans" (tbool(x, y)) (tbool(xh,yh))
-  end;
-  begin
-    let x = 89809344 and y = 457455773 and s = 7 in
-    let xh = hide x and yh = hide y and sh = hide s in
-    do_test "integers" (tint(x, y, s)) (tint(xh,yh,sh))
-  end;
-  begin
-    let x = 3.141592654 and y = 0.341638588598232096 in
-    let xh = hide x and yh = hide y in
-    do_test "floats" (tfloat(x, y)) (tfloat(xh, yh))
-  end;
-  begin
-    let x = 781944104l and y = 308219921l and s = 3 in
-    let xh = hide x and yh = hide y and sh = hide s in
-    do_test "32-bit integers" (tint32(x, y, s)) (tint32(xh, yh, sh))
-  end;
-  begin
-    let x = 1828697041n and y = -521695949n and s = 8 in
-    let xh = hide x and yh = hide y and sh = hide s in
-    do_test "native integers" (tnativeint(x, y, s)) (tnativeint(xh, yh, sh))
-  end;
-  begin
-    let x = 1511491586921138079L and y = 6677538715441746158L and s = 17 in
-    let xh = hide x and yh = hide y and sh = hide s in
-    do_test "64-bit integers" (tint64(x, y, s)) (tint64(xh, yh, sh))
-  end;
-  begin
-    let x = 1000807289 in
-    let xh = hide x in
-    do_test "integer conversions" (tconvint(x)) (tconvint(xh))
-  end;
-  begin
-    let x = 10486393l in
-    let xh = hide x in
-    do_test "32-bit integer conversions" (tconvint32(x)) (tconvint32(xh))
-  end;
-  begin
-    let x = -131134014n in
-    let xh = hide x in
-    do_test "native integer conversions" (tconvnativeint(x))(tconvnativeint(xh))
-  end;
-  begin
-    let x = 531871273453404175L in
-    let xh = hide x in
-    do_test "64-bit integer conversions" (tconvint64(x)) (tconvint64(xh))
-  end
diff --git a/testsuite/tests/basic/divint.ml b/testsuite/tests/basic/divint.ml
index c007edaeda..e315ad70b1 100644
--- a/testsuite/tests/basic/divint.ml
+++ b/testsuite/tests/basic/divint.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 open Printf
 
 (* Test integer division and modulus, esp. ocamlopt's optimization
diff --git a/testsuite/tests/basic/equality.ml b/testsuite/tests/basic/equality.ml
index ebf5cf438b..19d76e096f 100644
--- a/testsuite/tests/basic/equality.ml
+++ b/testsuite/tests/basic/equality.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let test n check res =
   print_string "Test "; print_int n;
   if check res then print_string " passed.\n" else print_string " FAILED.\n";
diff --git a/testsuite/tests/basic/eval_order_1.ml b/testsuite/tests/basic/eval_order_1.ml
index 7c20be3f22..bad1d05427 100644
--- a/testsuite/tests/basic/eval_order_1.ml
+++ b/testsuite/tests/basic/eval_order_1.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let f x y = Printf.printf "%d %d\n" x y
 
 let i = ref 0
diff --git a/testsuite/tests/basic/eval_order_2.ml b/testsuite/tests/basic/eval_order_2.ml
index 378398b381..e11da19b1e 100644
--- a/testsuite/tests/basic/eval_order_2.ml
+++ b/testsuite/tests/basic/eval_order_2.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* PR#6136 *)
 
 exception Ok
diff --git a/testsuite/tests/basic/eval_order_3.ml b/testsuite/tests/basic/eval_order_3.ml
index 07c5367e8e..90a9eba926 100644
--- a/testsuite/tests/basic/eval_order_3.ml
+++ b/testsuite/tests/basic/eval_order_3.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let i = ref 0
 
 let f x y =
diff --git a/testsuite/tests/basic/eval_order_4.ml b/testsuite/tests/basic/eval_order_4.ml
index 8e29f4551c..0e7130a9b2 100644
--- a/testsuite/tests/basic/eval_order_4.ml
+++ b/testsuite/tests/basic/eval_order_4.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* PR#7531 *)
 
 let f =
diff --git a/testsuite/tests/basic/eval_order_6.ml b/testsuite/tests/basic/eval_order_6.ml
index 14526e3c46..bec1f7ed78 100644
--- a/testsuite/tests/basic/eval_order_6.ml
+++ b/testsuite/tests/basic/eval_order_6.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 type t =
   { mutable x : int;
     y : int }
diff --git a/testsuite/tests/basic/float.ml b/testsuite/tests/basic/float.ml
index 9ebabbc4b6..a17c70fe76 100644
--- a/testsuite/tests/basic/float.ml
+++ b/testsuite/tests/basic/float.ml
@@ -1 +1,3 @@
+(* TEST *)
+
 Printf.printf "1./.0. = %f\n" (1.0 /. 0.0);;
diff --git a/testsuite/tests/basic/float_physical_equality.ml b/testsuite/tests/basic/float_physical_equality.ml
index 1fba35784b..5e826a7138 100644
--- a/testsuite/tests/basic/float_physical_equality.ml
+++ b/testsuite/tests/basic/float_physical_equality.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let a = -0.
 let b = +0.
 
diff --git a/testsuite/tests/basic/includestruct.ml b/testsuite/tests/basic/includestruct.ml
index a9c4e91ba3..b141388b7a 100644
--- a/testsuite/tests/basic/includestruct.ml
+++ b/testsuite/tests/basic/includestruct.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* Test for "include <module-expr>" inside structures *)
 
 module A =
diff --git a/testsuite/tests/basic/localexn.ml b/testsuite/tests/basic/localexn.ml
index b0f8e85f47..2654d9bf8d 100755
--- a/testsuite/tests/basic/localexn.ml
+++ b/testsuite/tests/basic/localexn.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let f (type t) () =
   let exception E of t in
   (fun x -> E x), (function E _ -> print_endline "OK" | _ -> print_endline "KO")
diff --git a/testsuite/tests/basic/maps.ml b/testsuite/tests/basic/maps.ml
index cc95eb6383..9ed19c0fb7 100644
--- a/testsuite/tests/basic/maps.ml
+++ b/testsuite/tests/basic/maps.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 module IntMap = Map.Make(struct type t = int let compare x y = x-y end)
 
 let m1 = IntMap.add 0 "A" (IntMap.add 4 "Y" (IntMap.singleton 3 "X1"))
diff --git a/testsuite/tests/basic/min_int.ml b/testsuite/tests/basic/min_int.ml
index fe0dd7c824..0b85db471e 100644
--- a/testsuite/tests/basic/min_int.ml
+++ b/testsuite/tests/basic/min_int.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* This will test the parsing of the smallest integer on 32-bit architectures.
    It doesn't do much on 64-bit but at least it doesn't crash.
  *)
diff --git a/testsuite/tests/basic/ocamltests b/testsuite/tests/basic/ocamltests
new file mode 100644
index 0000000000..3ea795442a
--- /dev/null
+++ b/testsuite/tests/basic/ocamltests
@@ -0,0 +1,28 @@
+arrays.ml
+bigints.ml
+boxedints.ml
+constprop.ml
+divint.ml
+equality.ml
+eval_order_1.ml
+eval_order_2.ml
+eval_order_3.ml
+eval_order_4.ml
+eval_order_6.ml
+float.ml
+float_physical_equality.ml
+includestruct.ml
+localexn.ml
+maps.ml
+min_int.ml
+opt_variants.ml
+patmatch.ml
+pr7533.ml
+pr7657.ml
+recvalues.ml
+sets.ml
+stringmatch.ml
+switch_opts.ml
+tailcalls.ml
+trigraph.ml
+zero_divided_by_n.ml
diff --git a/testsuite/tests/basic/opt_variants.ml b/testsuite/tests/basic/opt_variants.ml
index 16966be206..6cc954efbe 100755
--- a/testsuite/tests/basic/opt_variants.ml
+++ b/testsuite/tests/basic/opt_variants.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let () =
   assert(Sys.getenv_opt "FOOBAR_UNLIKELY_TO_EXIST_42" = None);
 
diff --git a/testsuite/tests/basic/patmatch.ml b/testsuite/tests/basic/patmatch.ml
index c1c002390a..cbe1ca1ec0 100644
--- a/testsuite/tests/basic/patmatch.ml
+++ b/testsuite/tests/basic/patmatch.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* Tests for matchings on integers and characters *)
 
 (* Dense integer switch *)
diff --git a/testsuite/tests/basic/pr7533.ml b/testsuite/tests/basic/pr7533.ml
index 47bbeeea9e..739e4cb802 100644
--- a/testsuite/tests/basic/pr7533.ml
+++ b/testsuite/tests/basic/pr7533.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* PR#7533 *)
 
 exception Foo
diff --git a/testsuite/tests/basic/pr7657.ml b/testsuite/tests/basic/pr7657.ml
index 8803cf3428..221506d0dc 100755
--- a/testsuite/tests/basic/pr7657.ml
+++ b/testsuite/tests/basic/pr7657.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 [@@@ocaml.warning "-21-5"]
 
 let foo g () = g 1; ()
diff --git a/testsuite/tests/basic/recvalues.ml b/testsuite/tests/basic/recvalues.ml
index df32f5e702..5605202e13 100644
--- a/testsuite/tests/basic/recvalues.ml
+++ b/testsuite/tests/basic/recvalues.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* Recursive value definitions *)
 
 let _ =
diff --git a/testsuite/tests/basic/sets.ml b/testsuite/tests/basic/sets.ml
index 8ce6ad596b..ca5b14a125 100644
--- a/testsuite/tests/basic/sets.ml
+++ b/testsuite/tests/basic/sets.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 module IntSet = Set.Make(struct type t = int let compare x y = x-y end)
 
 let even = List.fold_right IntSet.add [0; -2; 2; 4; 6; -10] IntSet.empty
diff --git a/testsuite/tests/basic/stringmatch.ml b/testsuite/tests/basic/stringmatch.ml
index e1f4bdb471..ac14c6de84 100644
--- a/testsuite/tests/basic/stringmatch.ml
+++ b/testsuite/tests/basic/stringmatch.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* Empty string oddities *)
 
 let rec tst01 s = match s with
diff --git a/testsuite/tests/basic/switch_opts.ml b/testsuite/tests/basic/switch_opts.ml
index 67034de3b1..1a6dfb86f7 100644
--- a/testsuite/tests/basic/switch_opts.ml
+++ b/testsuite/tests/basic/switch_opts.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* Test for optimisation of jump tables to arrays of constants *)
 
 let p = Printf.printf
diff --git a/testsuite/tests/basic/tailcalls.ml b/testsuite/tests/basic/tailcalls.ml
index 9e998139c2..32ac474494 100644
--- a/testsuite/tests/basic/tailcalls.ml
+++ b/testsuite/tests/basic/tailcalls.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 let rec tailcall4 a b c d =
   if a < 0
   then b
diff --git a/testsuite/tests/basic/trigraph.ml b/testsuite/tests/basic/trigraph.ml
index 3b4914cfbb..871117fb6d 100644
--- a/testsuite/tests/basic/trigraph.ml
+++ b/testsuite/tests/basic/trigraph.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* PR#6373 *)
 
 let () = print_string "??'"
diff --git a/testsuite/tests/basic/trigraph.ml.silent-compilation b/testsuite/tests/basic/trigraph.ml.silent-compilation
deleted file mode 100644
index e69de29bb2..0000000000
--- a/testsuite/tests/basic/trigraph.ml.silent-compilation
+++ /dev/null
diff --git a/testsuite/tests/basic/zero_divided_by_n.ml b/testsuite/tests/basic/zero_divided_by_n.ml
index 1523d962cf..d977c897d2 100644
--- a/testsuite/tests/basic/zero_divided_by_n.ml
+++ b/testsuite/tests/basic/zero_divided_by_n.ml
@@ -1,3 +1,5 @@
+(* TEST *)
+
 (* Mantis 7201 *)
 
 let f () = 0 [@@inline never]