diff --git a/test/dune b/test/dune
index b25eb46..bbf4a04 100644
--- a/test/dune
+++ b/test/dune
@@ -4,112 +4,112 @@
 (rule
  (targets ext.out)
  (deps
-  (:< ext.cppo)
+  ext.cppo
   source.sh)
  (action
   (with-stdout-to
    %{targets}
    (run %{bin:cppo} -x "rot13:tr '[a-z]' '[n-za-m]'" -x
-     "source:sh source.sh '%F' %B %E" %{<}))))
+     "source:sh source.sh '%F' %B %E" ext.cppo))))
 
 (rule
  (targets comments.out)
  (deps
-  (:< comments.cppo))
+  comments.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} %{<}))))
+   (run %{bin:cppo} comments.cppo))))
 
 (rule
  (targets cond.out)
  (deps
-  (:< cond.cppo))
+  cond.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} %{<}))))
+   (run %{bin:cppo} cond.cppo))))
 
 (rule
  (targets tuple.out)
  (deps
-  (:< tuple.cppo))
+  tuple.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} %{<}))))
+   (run %{bin:cppo} tuple.cppo))))
 
 (rule
  (targets loc.out)
  (deps
-  (:< loc.cppo))
+  loc.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} %{<}))))
+   (run %{bin:cppo} loc.cppo))))
 
 (rule
  (targets paren_arg.out)
  (deps
-  (:< paren_arg.cppo))
+  paren_arg.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} %{<}))))
+   (run %{bin:cppo} paren_arg.cppo))))
 
 (rule
  (targets unmatched.out)
  (deps
-  (:< unmatched.cppo))
+  unmatched.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} %{<}))))
+   (run %{bin:cppo} unmatched.cppo))))
 
 (rule
  (targets version.out)
  (deps
-  (:< version.cppo))
+  version.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} -V X:123.05.2-alpha.1+foo-2.1 -V COQ:8.13+beta1 -V OCAML:4.12.0~alpha1 %{<}))))
+   (run %{bin:cppo} -V X:123.05.2-alpha.1+foo-2.1 -V COQ:8.13+beta1 -V OCAML:4.12.0~alpha1 version.cppo))))
 
 (rule
  (targets test.out)
  (deps
-  (:< test.cppo)
+  test.cppo
   incl.cppo
   incl2.cppo)
  (action
   (with-stdout-to
    %{targets}
-   (run %{bin:cppo} %{<}))))
+   (run %{bin:cppo} test.cppo))))
 
 (rule
  (targets lexical.out)
- (deps (:< lexical.cppo))
- (action (with-stdout-to %{targets} (run %{bin:cppo} %{<}))))
+ (deps lexical.cppo)
+ (action (with-stdout-to %{targets} (run %{bin:cppo} lexical.cppo))))
 
 (rule
  (targets scope.out)
- (deps (:< scope.cppo))
- (action (with-stdout-to %{targets} (run %{bin:cppo} %{<}))))
+ (deps scope.cppo)
+ (action (with-stdout-to %{targets} (run %{bin:cppo} scope.cppo))))
 
 (rule
  (targets higher_order_macros.out)
- (deps (:< higher_order_macros.cppo))
- (action (with-stdout-to %{targets} (run %{bin:cppo} %{<}))))
+ (deps higher_order_macros.cppo)
+ (action (with-stdout-to %{targets} (run %{bin:cppo} higher_order_macros.cppo))))
 
 (rule
  (targets include_define_on_last_line.out)
- (deps (:< include_define_on_last_line.cppo) define_on_last_line.cppo)
- (action (with-stdout-to %{targets} (run %{bin:cppo} %{<}))))
+ (deps include_define_on_last_line.cppo define_on_last_line.cppo)
+ (action (with-stdout-to %{targets} (run %{bin:cppo} include_define_on_last_line.cppo))))
 
 (rule
  (targets def.out)
- (deps (:< def.cppo))
- (action (with-stdout-to %{targets} (run %{bin:cppo} %{<}))))
+ (deps def.cppo)
+ (action (with-stdout-to %{targets} (run %{bin:cppo} def.cppo))))
 
 (rule (alias runtest) (package cppo)
       (action (diff ext.ref ext.out)))
@@ -158,135 +158,135 @@
 
 (rule
  (targets arity_mismatch.err)
- (deps (:< arity_mismatch.cppo))
+ (deps arity_mismatch.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} arity_mismatch.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff arity_mismatch.ref arity_mismatch.err)))
 
 (rule
  (targets applied_to_none.err)
- (deps (:< applied_to_none.cppo))
+ (deps applied_to_none.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} applied_to_none.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff applied_to_none.ref applied_to_none.err)))
 
 (rule
  (targets expects_no_args.err)
- (deps (:< expects_no_args.cppo))
+ (deps expects_no_args.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} expects_no_args.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff expects_no_args.ref expects_no_args.err)))
 
 (rule
  (targets already_defined.err)
- (deps (:< already_defined.cppo))
+ (deps already_defined.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} already_defined.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff already_defined.ref already_defined.err)))
 
 (rule
  (targets at_least_one_arg.err)
- (deps (:< at_least_one_arg.cppo))
+ (deps at_least_one_arg.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} at_least_one_arg.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff at_least_one_arg.ref at_least_one_arg.err)))
 
 (rule
  (targets comment_in_formals.err)
- (deps (:< comment_in_formals.cppo))
+ (deps comment_in_formals.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} comment_in_formals.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff comment_in_formals.ref comment_in_formals.err)))
 
 (rule
  (targets arity_mismatch_indirect.err)
- (deps (:< arity_mismatch_indirect.cppo))
+ (deps arity_mismatch_indirect.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} arity_mismatch_indirect.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff arity_mismatch_indirect.ref arity_mismatch_indirect.err)))
 
 (rule
  (targets expect_ident.err)
- (deps (:< expect_ident.cppo))
+ (deps expect_ident.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} expect_ident.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff expect_ident.ref expect_ident.err)))
 
 (rule
  (targets expect_ident_empty.err)
- (deps (:< expect_ident_empty.cppo))
+ (deps expect_ident_empty.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} expect_ident_empty.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff expect_ident_empty.ref expect_ident_empty.err)))
 
 (rule
  (targets undefined.err)
- (deps (:< undefined.cppo))
+ (deps undefined.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} undefined.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff undefined.ref undefined.err)))
 
 (rule
  (targets shape_mismatch.err)
- (deps (:< shape_mismatch.cppo))
+ (deps shape_mismatch.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} shape_mismatch.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff shape_mismatch.ref shape_mismatch.err)))
 
 (rule
  (targets int_expansion_error.err)
- (deps (:< int_expansion_error.cppo))
+ (deps int_expansion_error.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} int_expansion_error.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff int_expansion_error.ref int_expansion_error.err)))
 
 (rule
  (targets extraneous_enddef.err)
- (deps (:< extraneous_enddef.cppo))
+ (deps extraneous_enddef.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} extraneous_enddef.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff extraneous_enddef.ref extraneous_enddef.err)))
 
 (rule
  (targets missing_enddef.err)
- (deps (:< missing_enddef.cppo))
+ (deps missing_enddef.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} missing_enddef.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff missing_enddef.ref missing_enddef.err)))
 
 (rule
  (targets missing_endscope.err)
- (deps (:< missing_endscope.cppo))
+ (deps missing_endscope.cppo)
  (action (with-stderr-to %{targets}
-   (with-accepted-exit-codes (not 0) (run %{bin:cppo} %{<})))))
+   (with-accepted-exit-codes (not 0) (run %{bin:cppo} missing_endscope.cppo)))))
 
 (rule (alias runtest) (package cppo)
       (action (diff missing_endscope.ref missing_endscope.err)))