* automated/ert-tests.el (ert-test-skip-unless): New test case.

(ert-test-deftest): Adapt test for changed macro expansion.
(ert-test-run-tests-interactively):
* automated/ert-x-tests.el (ert-test-run-tests-interactively-2):
Add a skipping test.

* automated/file-notify-tests.el (top): Do not require tramp-sh.el.
(file-notify--test-local-enabled): Make it a function.  Check also
for `file-remote-p' of `temporary-file-directory'.
(file-notify--test-remote-enabled-checked): New defvar.
(file-notify--test-remote-enabled): Rewrite.  Do not use Tramp
internal functions.  Cache result.
(file-notify--deftest-remote, file-notify-test00-availability)
(file-notify-test01-add-watch, file-notify-test02-events)
(file-notify-test03-autorevert): Add checks with `skip_unless'.
(file-notify-test-all): Do not check `file-notify--test-local-enabled'.

1 files changed, 52 insertions, 24 deletions

diff --git a/test/automated/ert-tests.el b/test/automated/ert-tests.el
index a2be534c25c..cc82893dace 100644
--- a/test/automated/ert-tests.el
+++ b/test/automated/ert-tests.el
@@ -294,6 +294,20 @@ failed or if there was a problem."
                   "the error signaled was a subtype of the expected type")))))
     ))
 
+(ert-deftest ert-test-skip-unless ()
+  ;; Don't skip.
+  (let ((test (make-ert-test :body (lambda () (skip-unless t)))))
+    (let ((result (ert-run-test test)))
+      (should (ert-test-passed-p result))))
+  ;; Skip.
+  (let ((test (make-ert-test :body (lambda () (skip-unless nil)))))
+    (let ((result (ert-run-test test)))
+      (should (ert-test-skipped-p result))))
+  ;; Skip in case of error.
+  (let ((test (make-ert-test :body (lambda () (skip-unless (error "Foo"))))))
+    (let ((result (ert-run-test test)))
+      (should (ert-test-skipped-p result)))))
+
 (defmacro ert--test-my-list (&rest args)
   "Don't use this.  Instead, call `list' with ARGS, it does the same thing.
 
@@ -332,23 +346,31 @@ This macro is used to test if macroexpansion in `should' works."
 
 (ert-deftest ert-test-deftest ()
   (should (equal (macroexpand '(ert-deftest abc () "foo" :tags '(bar)))
-                 '(progn
-                    (ert-set-test 'abc
-                                  (make-ert-test :name 'abc
-                                                 :documentation "foo"
-                                                 :tags '(bar)
-                                                 :body (lambda ())))
-                    (push '(ert-deftest . abc) current-load-list)
-                    'abc)))
+		 '(progn
+		    (ert-set-test 'abc
+				  (progn
+				    (vector 'cl-struct-ert-test 'abc "foo"
+					    #'(lambda nil)
+					    nil ':passed
+					    '(bar))))
+		    (setq current-load-list
+			  (cons
+			   '(ert-deftest . abc)
+			   current-load-list))
+		    'abc)))
   (should (equal (macroexpand '(ert-deftest def ()
                                  :expected-result ':passed))
-                 '(progn
-                    (ert-set-test 'def
-                                  (make-ert-test :name 'def
-                                                 :expected-result-type ':passed
-                                                 :body (lambda ())))
-                    (push '(ert-deftest . def) current-load-list)
-                    'def)))
+		 '(progn
+		    (ert-set-test 'def
+				  (progn
+				    (vector 'cl-struct-ert-test 'def nil
+					    #'(lambda nil)
+					    nil ':passed 'nil)))
+		    (setq current-load-list
+			  (cons
+			   '(ert-deftest . def)
+			   current-load-list))
+		    'def)))
   ;; :documentation keyword is forbidden
   (should-error (macroexpand '(ert-deftest ghi ()
                                 :documentation "foo"))))
@@ -543,7 +565,10 @@ This macro is used to test if macroexpansion in `should' works."
                                      :body (lambda () (ert-pass))))
         (failing-test (make-ert-test :name 'failing-test
                                      :body (lambda () (ert-fail
-                                                       "failure message")))))
+                                                       "failure message"))))
+        (skipped-test (make-ert-test :name 'skipped-test
+                                     :body (lambda () (ert-skip
+                                                       "skip message")))))
     (let ((ert-debug-on-error nil))
       (let* ((buffer-name (generate-new-buffer-name " *ert-test-run-tests*"))
              (messages nil)
@@ -554,23 +579,26 @@ This macro is used to test if macroexpansion in `should' works."
           (unwind-protect
               (let ((case-fold-search nil))
                 (ert-run-tests-interactively
-                 `(member ,passing-test ,failing-test) buffer-name
+                 `(member ,passing-test ,failing-test, skipped-test) buffer-name
                  mock-message-fn)
                 (should (equal messages `(,(concat
-                                            "Ran 2 tests, 1 results were "
-                                            "as expected, 1 unexpected"))))
+                                            "Ran 3 tests, 1 results were "
+                                            "as expected, 1 unexpected, "
+					    "1 skipped"))))
                 (with-current-buffer buffer-name
                   (goto-char (point-min))
                   (should (equal
                            (buffer-substring (point-min)
                                              (save-excursion
-                                               (forward-line 4)
+                                               (forward-line 5)
                                                (point)))
                            (concat
-                            "Selector: (member <passing-test> <failing-test>)\n"
-                            "Passed: 1\n"
-                            "Failed: 1 (1 unexpected)\n"
-                            "Total:  2/2\n")))))
+                            "Selector: (member <passing-test> <failing-test> "
+			    "<skipped-test>)\n"
+                            "Passed:  1\n"
+                            "Failed:  1 (1 unexpected)\n"
+			    "Skipped: 1\n"
+                            "Total:   3/3\n")))))
             (when (get-buffer buffer-name)
               (kill-buffer buffer-name))))))))