      (lambda (re) (let ((continue t)
 			(result   t))
 		    (while continue ; ignore warnings, stop at errors
-		      (if (re-search-forward re (point-max) t) 
+		      (if (re-search-forward re (point-max) t)
 			  (if (erlang-eunit-is-compilation-warning)
 			      t
 			    (setq result nil)

                ((erlang-eunit-test-generator-p test-name)
                 (format "eunit:test({generator, %s, %s}%s)."
                         module-name test-name (erlang-eunit-opts)))
                (t (format "%% WARNING: '%s' is not a test function" test-name)))))
    (erlang-eunit-inferior-erlang-send-command command)))

;;; Run EUnit tests for the current module


;;; Compile source and EUnit test file and finally run EUnit tests for
;;; the current module
(defun erlang-eunit-compile-and-test (run-tests &optional under-cover)
   "Compile the source and test files and run the EUnit test suite.

If under-cover is set to t, the module under test is compile for
code coverage analysis.  If under-cover is left out or not set,
coverage analysis is disabled.  The result of the code coverage
is both printed to the erlang shell (the number of covered vs
uncovered functions in a module) and written to a buffer called
*<module> coverage* (which shows the source code for the module
and the number of times each line is covered).
With prefix arg, compiles for debug and runs tests with the verbose flag set."
  (let ((src-filename  (erlang-eunit-src-filename  buffer-file-name))
	(test-filename (erlang-eunit-test-filename buffer-file-name)))

